How to use Interface IBuffer class of org.testng.reporters package

What you need is a Parameterized test. For example (from the wiki) this:

@RunWith(Parameterized.class)
public class FibonacciTest {
    @Parameters
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {     
                 { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 }  
           });
    }

    private int fInput;

    private int fExpected;

    public FibonacciTest(int input, int expected) {
        fInput= input;
        fExpected= expected;
    }

    @Test
    public void test() {
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

is how one looks like.

You might also want to look into TestNG's Data Providers which are a bit more usable.

One of the easiest ways is ServletTester from Jetty. Everything is done within embedded Jetty automatically, so there is no port opened during the testing! If you use Maven than the following artifact is required to enable this method:

<dependency>
  <groupId>org.mortbay.jetty</groupId>
  <artifactId>jetty-servlet-tester</artifactId>
  <version>6.1.16</version>
  <scope>test</scope>
</dependency>

Example:

Prepare ServletTester

ServletTester tester=new ServletTester(); 
tester.addServlet(HelloServlet.class, "/hello"); 
tester.start();

Create HTTP request

HttpTester request = new HttpTester(); 
request.setMethod("GET");
request.setHeader("Host","tester"); 
request.setURI("/hello");
request.setVersion("HTTP/1.0");

Call servlet and retrieve response:

HttpTester response = new HttpTester();
response.parse(tester.getResponses(request.generate()));

Assert what you want to check on response and it's content:

assertEquals(200,response.getStatus()); 
assertEquals("Hello Servlet",response.getContent());

Using Adb

To get Device Name

adb.exe -s " +deviceID+ " shell getprop ro.product.model

To get Device OS Version

adb.exe -s " +deviceID+ " shell getprop ro.build.version.release

To get App Version

adb -s " +deviceID+ " shell dumpsys package yourPackageName | grep versionName

It is impossible to depend on a method from different classes.

However, it is definitely possible to depend on a group from different classes. If you want to use XML, this is the documentation for that: http://testng.org/doc/documentation-main.html#dependencies-in-xml

Look at the first example of a suite in the TestNG documentation:

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name="Suite1" verbose="1" >
  <test name="Nopackage" >
    <classes>
       <class name="NoPackageTest" />
    </classes>
  </test>

  <test name="Regression1">
    <classes>
      <class name="test.sample.ParameterSample"/>
      <class name="test.sample.ParameterTest"/>
    </classes>
  </test>
</suite>

What is causing your error is verbose="1.0". TestNG tries to parse 1.0 to an int, causing the exception.

You probably want verbose="1" there instead.

As a side note, the TestNG documentation is rather sparse about the verbose attribute. This blogpost does a good job at explaining what values the attribute can have:

Before understanding the usage of verbose attribute, first you have to know the values it can accept. Verbose attribute can takes values from 1 to 10 as shown below:

verbose="1"
verbose="2"
verbose="3"
verbose="4"
verbose="5"
verbose="6"
verbose="7"
verbose="8"
verbose="9"
verbose="10"

If we specify the verbose attribute with smaller number, then the test results log details in the Eclipse IDE -> 'console' window will be less. But if you want to get more details and want to see more clarity on the test results log details in the Eclipse IDE -> 'console' window then you have to assign larger number to the verbose attribute.

Of course, this does not only apply to Eclipse, it is a TestNG configuration.

try new SkipException("message"); this will skip the tests if the provided condition is not true.

It all works well, please have a look at the demo I prepared. Mind the fact that you cannot set the system property to null value - it might be a problem as well.

The static metamodel classes are populated when hibernate is loaded. So, either you configure hibernate context in your test or you populate the attributes manually before the method execution. In you code, you could do:

@Test
public void doIt() {
    BookingSystem_.code = new SingularAttributeMock<BookingSystem, Integer>();
    bookingService.saveBooking(booking);
  }
}

The class SingularAttributeMock can be created custom-made in order to use it in your tests. You can also use any other implementation of the SingularAttribute class.

public class SingularAttributeMock<X, Y> implements SingularAttribute<X, Y> {
   //Overriding methods of SingularAttribute...
}

You're missing the annotation @PrepareForTest and the use of mockStatic() which are required when you wish to mock a final static class with PowerMockito. I think where you might be getting confused is that you're dealing with a final static class and not only a final class, so there are a few additional mock calls you need to be aware of.

Given these implementation classes

/*
The final static class that's giving you all the mocking grief
*/
public final class FinalStaticClass {

    // this object instance "will not" be returned when we mock() the class
    private static MyObject obj = new MyObject();

    public static MyObject getMyObject() {
        return obj; 
    }
}

/*
A simple value object used by MyClass
*/
public class MyObject {

}

/*
The class you wish to test
*/
public class MyClass {

    private MyObject obj;

    public void methodToTest() {
        obj = FinalStaticClass.getMyObject();
        // do something
    }

    public MyObject getMyObject() {
        return obj;
    }
}

Make sure you include powermock-mockito-1.4.10-full.jar in your project, then you can use this test class

import static org.junit.Assert.assertEquals;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

import ...    

@RunWith(PowerMockRunner.class)
@PrepareForTest(FinalStaticClass.class)
public class MyClassTest{

    @Mock
    MyObject expectedObject;

    @InjectMocks
    MyClass myClass = new MyClass();

    @Test
    public void test1(){

        // mock all static methods
        mockStatic(FinalStaticClass.class);

        when(FinalStaticClass.getMyObject()).thenReturn(expectedObject);

        // execute the method under test
        myClass.methodToTest();

        assertEquals(expectedObject, myClass.getMyObject());

    }
}

You can see that expectedObject is a mock that you have created in the test and not the implementation returned from FinalStaticClass