理解这些 JUnit 测试结果

Question

I am doing some exercises for my CS course and they are giving us Junit tests however they only tell us if we fail or pass. The output/expected output is jibberish to me.

I am given expected output/output in this fashion:

java.lang.AssertionError: expected <3143794514> but was <459133821> 

I notice that the value <459133821L> is also found in the code of the test. However, I'm still a beginner. Apparently adler32 is meant to check for errors through checksums, but I don't know how to utilize this. Is there some way to have this show more meaningful messages so I know what is going wrong with my code?

Eg: I am expected to count all the words in a string. Can these tests show me what input/output is returning the incorrect answer?

Here is a sample of the JUnit class:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.*;
import java.io.*;
import java.util.zip.Adler32;

public class TestStringProblems {

    private static final int RUNS = 100000;
    private static final int SEED = 12345;
    private StringProblems sp = new StringProblems();

    @Test
    public void testCountWords() {
        BufferedReader br = null;
        Adler32 check = new Adler32();
        int count = 0;
        try {
            br = new BufferedReader(new FileReader("warandpeace.txt"));
            String line = br.readLine();
            while(line != null) {
                int words = sp.countWords(line.trim());
                count += words;
                check.update(words);
                line = br.readLine(); 
            }
        } catch(IOException e) { System.out.println("Error: " + e); assertTrue(false); }
        finally { try { br.close(); } catch(Exception e) { } }
        assertEquals(count, 562491); // number of words in War and Peace
        assertEquals(check.getValue(), 2309395892L); // checksum of word counts
    }

    @Test
    public void testRemoveDuplicates() {
        Adler32 check = new Adler32();
        java.util.Random rng = new java.util.Random(SEED);
        for(int i = 0; i < RUNS; i++) {
            StringBuilder sb = new StringBuilder();
            int len = rng.nextInt(500);
            for(int j = 0; j < len; j++) {
                char c = (char)(1 + rng.nextInt(50000));
                int rep = rng.nextInt(10) + 1;
                for(int k = 0; k < rep; k++) {
                    sb.append(c);
                }
            }
            check.update(sp.removeDuplicates(sb.toString()).getBytes());
        }
        assertEquals(check.getValue(), 459133821L);
    }


}

Thanks.

public class StringProblems {

    public String removeDuplicates(String s) {
        String newStr = "";
        if (s.length() == 0) {
            return s;
        }

        int length = s.length() - 1;
        for(int i = 0;i<length+1;i++) {
            if(i!=0 && s.charAt(i)!=s.charAt(i-1)) {
                newStr += s.charAt(i);
            }
        }


        return s.charAt(0) + newStr;
    }

    public int countWords(String s) {
        String newStr = s.trim(); // removes unnecessary whitespace

        if (newStr.isEmpty()) {
            return 0;
        }

        return newStr.split("\\W+").length; // should work since it creates an array of substrings, 
                                            // length should indicate how many substrings are in the new string
    }



}

Answer 1

You're "expected" and "actuals" are backward.

http://junit.sourceforge.net/javadoc/org/junit/Assert.html

The first parameter to assertEquals is EXPECTED, the second is ACTUAL.

The error you are seeing is obviously firing on this line: assertEquals(check.getValue(), 459133821L);

You need to swap your expected and actuals and THEN ALSO fix your calculations. You're still getting the wrong answer if you are trying to get 459133821L. I haven't looked over all of your code, but these tests are showing you the input output and what is giving you the correct answer. Figure out why you are trying to hit 459133821L in testRemoveDuplicates (which at a glance seems to be using a random so I'm not sure how you know what to expect), and you'll solve it.