How to use getOutput method of org.testng.Reporter class

Should use .* to match them all as far as I know.

There's not a lot of context in that question but a quick google found the source.

Your test suite will create many instances of different classes and then run some tests on them. This particular parallel mode guarantees that whenever your test suite calls more than one method on any create instance this will be done in the same thread.

Why might this be important? Well, some functionality may depend on consistent threading, for example if they use ThreadLocal. Additionally, unless your instances are thread-safe allowing multiple threads to call methods on them could lead to interference.

If you're not sure what all this talk of thread safety is then you might not want to run your test suite in parallel. Or perhaps restrict it to parallel="tests" and make sure there's a clear separation between test tags.

Mockito supports changing the returned value; this support extends to PowerMockito. Just use OngoingStubbing.thenReturn(T value, T... values)

OngoingStubbing<T> thenReturn(T value, T... values)

Sets consecutive return values to be returned when the method is called.
E.g:

when(mock.someMethod()).thenReturn(1, 2, 3);

Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls.

So, in this case, you would do:

PowerMockito.when(DBUtil.getCurrentCount()).thenReturn(100, 150);

Note: this answer assumes you already know how to mock static methods. If you do not, see this question.

The "problem" is somehow related to the fact that you are compiling your tests using the jsr14 target mode which causes the compiler to emit JDK 1.4-compatible bytecode so I think that annotations are removed and TestNG doesn't detect anything to run.

My suggestion would be to configure the maven-compiler-plugin to use different compliance level when compiling code code from main and test as shown below:

<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.6</source>
    <target>jsr14</target>
  </configuration>
  <executions>
    <execution>
      <id>test-compile</id>
      <phase>process-test-sources</phase>
      <goals>
        <goal>testCompile</goal>
      </goals>
      <configuration>
        <source>1.6</source>
        <target>1.6</target>
      </configuration>
    </execution>
  </executions>
</plugin>

I did a quick test, it seems to work.

It seems to me that if you are using ANT you shouldn't need your class. I would just use three targets and assign the different properties within those targets.

We had a similar problem when running webdriver on a remote machine and trying to paste text into forms. The tests were working on our development machines. The solution was setting the environment variable

JAVA_TOOL_OPTIONS = -Dfile.encoding=UTF8

After that the webdriver copied with the right encoding for swedish characters.

No, an annotation is not a comment. An annotation is added to a field, class or method, using the syntax @Annotation. One of the best known annotations is @Override, used to signal a method is overriding one from a super class. For example:

public class MyClass {
  @Override
  public boolean equals(Object other) {
    //...
  }
}

See http://download.oracle.com/javase/1,5.0/docs/guide/language/annotations.html for more info.

You can use, along the expectedExceptions parameter to the @Test annotation, the expectedExceptionsMessageRegEx. However, this becomes quite a messy annotation:

@Test(
    expectedExceptions = MyException.class,
    expectedExceptionsMessageRegEx = "^regex for message here$"
)
public void testWhatever() 
{
    codeThatRaisesSomeException();
}

And note that the parameter value, as the parameter name suggests, is a regular expression...

Rather than that, why not just do this:

@Test
public void testWhatever()
{
    try {
        codeThatRaisesSomeException();
        fail("No exception thrown!");
    catch (MyException e) {
        assertEquals(e.getMessage(), "the expected message here");
    }
}

Ultimately, that is a matter of tastes; yours truly finds the latter more readable...

You can add variety to your test with Chained stubbing, so that you are not testing with random returning always same number.

 when(randomNumberMock.nextInt())
   .thenReturn(4)
   .thenReturn(12);

You could also parameterize your test. Here is example for TestNG.

@DataProvider()
public static Object[][] randomNumbers() {
    return new Object[][] {{2, 3}, {6, 7}, {19, 15}};
}

@Test(dataProvider = "random")
public void getChosenDataTypesTest(int first, int second) {
 when(randomNumberMock.nextInt())
   .thenReturn(first)
   .thenReturn(second);
} 

JUnit has similar feature for parameterized tests.

EDIT: Mocked method has to be

nextInt(anyInt())

because you are calling nextInt(int bound) not nextInt().

when(randomNumberMock.nextInt(anyInt())
   .thenReturn(4)
   .thenReturn(12);