Do i need to prefix 'test' to every unit test method i create with GWTTestCase?

Question

I am learning how to perform unit testing in GWT. So i create a class which extends the GWTTestCase class and write test methods inside it.

The problem is that if i don't prefix the word 'test' to even one function in this class(public or private) apart from the inherited 'getModuleName' method, i get an 'initialization error'.

Now am i doing something wrong or is it a rule to add this prefix? If its actually a rule, what is the reason for this?

public class hellotest extends GWTTestCase{
@Override
public String getModuleName() {
    // TODO Auto-generated method stub
    return "hellopackage.Hello1";
}

public void test()
{
    assertTrue(true);
}

public void test2()
{
    assertTrue(true);
}

public void notTest3()     //Produces initialization error
{
    assertTrue(true);
}
}

The Stack trace of the 'initialization error' :-

// Compiled from Filter.java (version 1.5 : 49.0, super bit)
public abstract class org.junit.runner.manipulation.Filter {

  // Field descriptor #14 Lorg/junit/runner/manipulation/Filter;
  public static final org.junit.runner.manipulation.Filter ALL;

  // Method descriptor #16 ()V
  // Stack: 1, Locals: 1
  public Filter();
    0  aload_0 [this]
    1  invokespecial java.lang.Object() [1]
    4  return
      Line numbers:
        [pc: 0, line: 17]
      Local variable table:
        [pc: 0, pc: 5] local: this index: 0 type: org.junit.runner.manipulation.Filter

  // Method descriptor #22 (Lorg/junit/runner/Description;)Lorg/junit/runner/manipulation/Filter;
  // Stack: 3, Locals: 1
  public static org.junit.runner.manipulation.Filter matchMethodDescription(org.junit.runner.Description desiredDescription);
    0  new org.junit.runner.manipulation.Filter$2 [2]
    3  dup
    4  aload_0 [desiredDescription]
    5  invokespecial org.junit.runner.manipulation.Filter$2(org.junit.runner.Description) [3]
    8  areturn
      Line numbers:
        [pc: 0, line: 48]
      Local variable table:
        [pc: 0, pc: 9] local: desiredDescription index: 0 type: org.junit.runner.Description

  // Method descriptor #26 (Lorg/junit/runner/Description;)Z
  public abstract boolean shouldRun(org.junit.runner.Description arg0);

  // Method descriptor #28 ()Ljava/lang/String;
  public abstract java.lang.String describe();

  // Method descriptor #30 (Ljava/lang/Object;)V
  // Stack: 2, Locals: 3
  public void apply(java.lang.Object child) throws org.junit.runner.manipulation.NoTestsRemainException;
     0  aload_1 [child]
     1  instanceof org.junit.runner.manipulation.Filterable [4]
     4  ifne 8
     7  return
     8  aload_1 [child]
     9  checkcast org.junit.runner.manipulation.Filterable [4]
    12  astore_2 [filterable]
    13  aload_2 [filterable]
    14  aload_0 [this]
    15  invokeinterface org.junit.runner.manipulation.Filterable.filter(org.junit.runner.manipulation.Filter) : void [5] [nargs: 2]
    20  return
      Line numbers:
        [pc: 0, line: 93]
        [pc: 7, line: 94]
        [pc: 8, line: 96]
        [pc: 13, line: 97]
        [pc: 20, line: 98]
      Local variable table:
        [pc: 0, pc: 21] local: this index: 0 type: org.junit.runner.manipulation.Filter
        [pc: 0, pc: 21] local: child index: 1 type: java.lang.Object
        [pc: 13, pc: 21] local: filterable index: 2 type: org.junit.runner.manipulation.Filterable

  // Method descriptor #38 (Lorg/junit/runner/manipulation/Filter;)Lorg/junit/runner/manipulation/Filter;
  // Stack: 5, Locals: 3
  public org.junit.runner.manipulation.Filter intersect(org.junit.runner.manipulation.Filter second);
     0  aload_1 [second]
     1  aload_0 [this]
     2  if_acmpeq 12
     5  aload_1 [second]
     6  getstatic org.junit.runner.manipulation.Filter.ALL : org.junit.runner.manipulation.Filter [6]
     9  if_acmpne 14
    12  aload_0 [this]
    13  areturn
    14  aload_0 [this]
    15  astore_2 [first]
    16  new org.junit.runner.manipulation.Filter$3 [7]
    19  dup
    20  aload_0 [this]
    21  aload_2 [first]
    22  aload_1 [second]
    23  invokespecial org.junit.runner.manipulation.Filter$3(org.junit.runner.manipulation.Filter, org.junit.runner.manipulation.Filter, org.junit.runner.manipulation.Filter) [8]
    26  areturn
      Line numbers:
        [pc: 0, line: 105]
        [pc: 12, line: 106]
        [pc: 14, line: 108]
        [pc: 16, line: 109]
      Local variable table:
        [pc: 0, pc: 27] local: this index: 0 type: org.junit.runner.manipulation.Filter
        [pc: 0, pc: 27] local: second index: 1 type: org.junit.runner.manipulation.Filter
        [pc: 16, pc: 27] local: first index: 2 type: org.junit.runner.manipulation.Filter

  // Method descriptor #16 ()V
  // Stack: 2, Locals: 0
  static {};
     0  new org.junit.runner.manipulation.Filter$1 [9]
     3  dup
     4  invokespecial org.junit.runner.manipulation.Filter$1() [10]
     7  putstatic org.junit.runner.manipulation.Filter.ALL : org.junit.runner.manipulation.Filter [6]
    10  return
      Line numbers:
        [pc: 0, line: 21]

  Inner classes:
    [inner class info: #2 org/junit/runner/manipulation/Filter$2, outer class info: #0
     inner name: #0, accessflags: 8 static],
    [inner class info: #7 org/junit/runner/manipulation/Filter$3, outer class info: #0
     inner name: #0, accessflags: 0 default],
    [inner class info: #9 org/junit/runner/manipulation/Filter$1, outer class info: #0
     inner name: #0, accessflags: 8 static]
}

Answer 1

GWTTestCase extends JUnit 3 TestCase, and in JUnit 3, test methods are indeed supposed to start with test.

The reason is that it's how JUnit has been designed: it searches for public void methods starting with test in the test cases. That was done before Java 5, when annotations didn't exist yet. Nowadays, JUnit 4 (and 5) uses annotations to "flag" test methods.

Answer 2

Besides the question "is it technically required" which is answered already; you might also consider conventions.

Most unit tests I ever saw ... do start with testWhatever().

The point is: naming is a core element of writing clean, readable, maintainable code. That is true for production code; but hey, a lot of people think that your test code is even more important than production code ... so writing clean, readable, maintainable test code is an important part of software development.

In other words: probably most people expect that test methods start with "test". But in the end: the point would be that the names say what is actually tested; so test(), test1(), ... and so on would be really really bad names for test methods.

(and side note: if you are interested in writing good tests, check out assertThat; and forget about using any other of the assert calls).