How to use Interface INavigatorPanel class of org.testng.reporters.jq package

The problem is that your getDriver method is static.

Solution #1: Make method non-static (this will either need to make the driver variable non-static as well, or use return Browser.getDriver(); )

public WebDriver getDriver() {
    return driver;
}

Or, call the getDriver method by using Browser.getDriver

WebElement query = Browser.getDriver().findElement(By.name("q"));

Declare a parameter of type ITestResult in your @AfterMethod and TestNG will inject it:

@AfterMethod
public void afterMethod(ITestResult result) {
  System.out.println("method name:" + result.getMethod().getMethodName());
}

Yes, that's the default behavior of TestNG and I had introduced it through that pull request to fix the bug https://github.com/cbeust/testng/issues/2022

To set the JVM arguments in intelliJ, choose Run > Edit Configurations, and add this JVM argument in the VM options section after -ea (which would be there by default.

For more information on editing configurations, please refer to the official documentation here

Added screenshot for easy to find in Intellij

Argument value

-ea -Dtestng.dtd.http=true

If the above does not work do at template level, this will fix it, which is

Run--> Edit configuration --> template --> testng

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

The answer for this problem is rather straightforward.

@Parameters({"Param1","Param2"}) , Param1 and Param2 are the names of parameters in testng.xml, those aren't values assigned to String p1, String p2 during runtime.

The two XML parameters have to be defined, otherwise a test is ignored. You can define optional values assigned automatically to p1 and p2 using the "Optional" annotation:

@Parameters({"param1","param2"})
@Test(enabled = true)
public void testTestExample(@Optional("test1111") String p1, @Optional("test2222")String p2){
    System.out.println("Parameter's value : " + p1 + ", " + p2);
}

1. should i use maven-surefire-plugin and do a heavy cleanup in the test package?
2. is it any way to tell hudson (not in pom.xml of the project being built) to run specific unit tests and ignore others?

If you just want to run unit tests in a single-module project, you can do

mvn test

That will run all maven lifecycle phases up to test, including compile and test-compile (as you can see in built-in lifecycle bindings, the surefire:test goal is executed in phase test). Now if you want to restrict the unit tests that are executed, you can configure the surefire:test plugin execution with the test parameter:

mvn test -Dtest=Funky*Test

(This will execute all test classes that start with Funky and end with Test)

Unfortunately, the command line configuration is limited, if you want multiple includes and excludes you will have to do some XML configuration. I'd suggest to use a dedicated profile for hudson:

<profiles>
    <profile>
        <id>hudson</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.6</version>
                    <configuration>
                        <includes>
                            <include>**/TestA.java</include>
                            <include>**/Funky*Test.java</include>
                            <include>**/Test**.java</include>
                        </includes>
                        <excludes>
                            <!-- overrides above include -->
                            <exclude>**/TestButNotMe.java</exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Now you can let your hudson call maven like this:

mvn -Phudson test

When testing CompletableFuture you need to wait until all its steps are completed.

Instead of a Thread.sleep, add a final fut.join()

TestNG will run all the public methods from a class with a @Test annotation. Maybe you could change the methods you don't want TestNG to run to be non-public

As I said in comment above, Mockito do not support mocking static methods.

Use Powermock

Example:

@RunWith(PowerMockRunner.class)
@PrepareForTest(A.class)
public class YourTestClass{
    PowerMockito.mockStatic(A.class);

    when(A.getMyClass()()).thenReturn(...);

}

Also,

MyClass.getMyClass();

getMyClass() belongs to class A or class Myclass ?