A Comprehensive Guide to Java Mocking Frameworks

import java.lang.Math;

public class MathAPI {

    public MathAPI() {
    }
    // Function to find the minimum of two integers
    public int min(int a, int b) {
        return Math.min(a, b);
    }

    // Function to find the maximum of two integers
    public int max(int a, int b) {
        return Math.max(a, b);
    }

    // Function to calculate the square root of an integer
    public double squareRoot(int num) {
        return Math.sqrt(num);
    }

    // Function to calculate the power of an integer
    public double power(int base, int exponent) {
        return Math.pow(base, exponent);
    }

    // Function to find the floor value of a float
    public float floor(float num) {
        return (float) Math.floor(num);
    }

    public void main(String[] args) {
        // Example usage
        int a = 5, b = 8;
        System.out.println("Min: " + min(a, b));
        System.out.println("Max: " + max(a, b));
        System.out.println("Square Root: " + squareRoot(a));
        System.out.println("Power: " + power(a, 2));
        float c = 3.14f;
        System.out.println("Floor: " + floor(c));
    }
}

<dependencies>  
	 <dependency> 
		 <groupId>org.junit.jupiter</groupId>  
		 <artifactId>junit-jupiter-api</artifactId>  
		 <version>5.9.0</version>  
		 <scope>test</scope>  
	 </dependency>
 </dependencies>

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MathAPITestJUnit {
    MathAPI mathAPI = new MathAPI();

	@BeforeAll
	public static void classLevelSetUpRunsOnce() throws java.lang.Exception {
		// Runs only once for class level initializations, before any test is executed. 
        System.out.println("before class");
    }  
	
	@BeforeEach  
    public void beforeEachTestSetUp() throws java.lang.Exception {
	// Runs before each test , specify common pre-test setup code here.
        System.out.println("before");  
    }  
	
    @Test
    @Timeout(10000)
    public void testMinFunction() {
		//Will fail if it takes longer than 10000 milliseconds

        assertEquals(3, mathAPI.min(3, 5));
        assertEquals(-2, mathAPI.min(0, -2));
    }

    @Test
    public void testMaxFunction() {
        assertEquals(5, mathAPI.max(3, 5));
        assertEquals(0, mathAPI.max(0, -2));
    }

    @Test
    public void testSquareRootFunction() {
        assertEquals(2.0, mathAPI.squareRoot(4),  0.001);
        assertEquals(6.0, mathAPI.squareRoot(36), 0.001);
        assertEquals(Double.NaN, mathAPI.squareRoot(-1), 0.001);
    }

    @Test
    public void testPowerFunction() {
        assertEquals(8, mathAPI.power(2, 3));
        assertEquals(1, mathAPI.power(5, 0));
        //assertEquals(1.0 / 16, MathAPI.power(2, -4), 0.001);
    }

    @Test
    public void testFloorFunction() {
        assertEquals(3, mathAPI.floor(3.8f));
        assertEquals(-4, mathAPI.floor(-3.2f));
    }
	
	@AfterEach  
    public void tearDown() throws java.lang.Exception {
	//Runs after each test 
        System.out.println("Runs after each test");  
    }  
  
    @AfterAll 
    public static void tearDownAfterClass() throws java.lang.Exception {
	//Runs after all tests in this class are executed 
        System.out.println("Runs after class execution");  
    }  	
}

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.4.0</version>
    <scope>test</scope>
</dependency>

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

public class MathAPITestMockito {

    @Test
    public void testMinFunction() {
        // Mockito enables the use of a mock abject instead of a real MathAPI object. 
        MathAPI mathAPI = Mockito.mock(MathAPI.class);

        // Define the inputs
        int num1 = 5;
        int num2 = 10;
        // Set up the mock behavior for the min function
        when(mathAPI.min(num1, num2)).thenReturn(Math.min(num1, num2));
		
        // Call the methosd to be tested. 
        int result = mathAPI.min(num1, num2);
        // Assert
        assertEquals(Math.min(num1, num2), result);
    }

    @Test
    public void testMaxFunction() {
        MathAPI mathAPI = Mockito.mock(MathAPI.class);
        int num1 = 5, num2 = 10;
        // Set up the mock behavior for the max function
        when(mathAPI.max(num1, num2)).thenReturn(Math.max(num1, num2));
        
		int result = mathAPI.max(num1, num2);
        // Assert or Test the output 
        assertEquals(Math.max(num1, num2), result);
    }

    @Test
    public void testSquareRootFunction() {
        MathAPI mathAPI = Mockito.mock(MathAPI.class);

        int number = 25;
        when(mathAPI.squareRoot(number)).thenReturn(Math.sqrt(number));


        double result = mathAPI.squareRoot(number);
        assertEquals(Math.sqrt(number), result);
    }

    @Test
    public void testPowerFunction() {

        MathAPI mathAPI = Mockito.mock(MathAPI.class);

        int base = 2, exponent = 3;

        // Set up the mock behavior for the power function
        when(mathAPI.power(base, exponent)).thenReturn(Math.pow(base, exponent));


        double result = mathAPI.power(base, exponent);
        assertEquals(Math.pow(base, exponent), result);
    }

    @Test
    public void testFloorFunction() {

        MathAPI mathAPI = Mockito.mock(MathAPI.class);

        float number = 7.8f;
        when(mathAPI.floor(number)).thenReturn((float)Math.floor(number));

        double result = mathAPI.floor(number);
        assertEquals(Math.floor(number), result);
    }
}

    import java.lang.Math;

    public class MathAPISF {

        public MathAPISF() {
        }
        // Function to find the minimum of two integers
        public static int min(int a, int b) {
            return Math.min(a, b);
        }

        // Function to find the maximum of two integers
        public static int max(int a, int b) {
            return Math.max(a, b);
        }

        // Function to calculate the square root of an integer
        public final double squareRoot(int num) {
            return Math.sqrt(num);
        }

        // Function to calculate the power of an integer
        public final double power(int base, int exponent) {
            return Math.pow(base, exponent);
        }

        // Function to find the floor value of a float
        public final float floor(float num) {
            return (float) Math.floor(num);
        }

        public static void main(String[] args) {
            // Example usage
            int a = 5, b = 8;
            System.out.println("Min: " + min(a, b));
            System.out.println("Max: " + max(a, b));
            MathAPISF sf = new MathAPISF();
            System.out.println("Square Root: " + sf.squareRoot(a));
            System.out.println("Power: " + sf.power(a, 2));
            float c = 3.14f;
            System.out.println("Floor: " + sf.floor(c));
        }
    }

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-core</artifactId>
    <version>2.0.9</version>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>2.0.9</version>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito2</artifactId>
    <version>2.0.9</version>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-testng-common</artifactId>
    <version>2.0.9</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.12.4</version>
</dependency>
<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.10.14</version>
</dependency>
<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy-agent</artifactId>
    <version>1.10.14</version>
</dependency>
<dependency>
    <groupId>org.objenesis</groupId>
    <artifactId>objenesis</artifactId>
    <version>3.0.1</version>
</dependency>

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.testng.PowerMockTestCase;
import org.testng.annotations.BeforeTest;

import static org.junit.Assert.assertEquals;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.powermock.api.mockito.PowerMockito.verifyNew;
import static org.powermock.api.mockito.PowerMockito.when;

@RunWith(PowerMockRunner.class)
@PrepareForTest({ MathAPISF.class }) // FQCN used here, accepts array of classes or wildcards, e.g. com.my.static.*

public class PowerMockMathAPITest extends PowerMockTestCase{

    @BeforeTest
    public void init() {
        initMocks(this);
    }

    @Test
    public void testMathAPI() throws Exception {
        // Using Powermock to mock static methods in the MathAPI class
        PowerMockito.mockStatic(MathAPISF.class);

        // Setting up an expectation, Mocking min(0, x) function
        PowerMockito.when(MathAPISF.min(0, 10)).thenReturn(0);

        // Mocking the max(x, y) function
        PowerMockito.when(MathAPISF.max(5, 8)).thenReturn(8);

        // Call the methods in your class, invocations are delegated to the mock class created via mockStatic() above
        // For example:
        int result1 = MathAPISF.min(0, 10);
        int result2 = MathAPISF.max(5, 8);

        // Verify that the methods in your class are working as expected
        assertEquals(0, result1);
        assertEquals(8, result2);

        // Optionally, verify that static methods in the Math class were called n times [ specified via times(n) ]
        PowerMockito.verifyStatic(MathAPISF.class, Mockito.times(1));//checks if the immediately following method call(in the next line) took place
        MathAPISF.min(0, 10);
        PowerMockito.verifyStatic(MathAPISF.class, Mockito.times(1));
        MathAPISF.max(5, 8);
    }
    /* ==================================================================== */
    /** To test the final methods of the class, we use PowerMockito.mock(class) instead of mockStatic() method.
     If your class has a no-argument constructor, setup an expectation that whenever that no-arg constructor is invoked, a mock  instance should be returned rather than a real one. This way we test a contructor also.
     */
    @Test
    public void testMathAPIFinal() throws Exception {
        MathAPISF mathMock = PowerMockito.mock(MathAPISF.class) ;
        PowerMockito.whenNew(MathAPISF.class).withNoArguments().thenReturn(mathMock);

        //Next, instantiate MathAPI using the default no-arguments contructor, and verify
        MathAPISF mathMock2 = new MathAPISF();
        verifyNew(MathAPISF.class).withNoArguments();

        //Set the expectation for the final method(s); this will be checked later via assertEquals() method.
        when(mathMock2.squareRoot(25)).thenReturn(5.0);
        when(mathMock2.power(2, 3)).thenReturn(8.0);

        // Execute the final methods
        int result1 = (int) mathMock2.squareRoot(25);
        int  result2 = (int) mathMock2.power(2, 3);

        // Assertions to confirm(verify) that the methods was indeed called, and the values setup by the mocking expectation were actually returned
        assertEquals(5, result1);
        assertEquals(8, result2);
    }
}

	@Test
	public void powermockSpyFinal() throws Exception {

		MathAPISF myMathMock2 = PowerMockito.spy(new MathAPISF());
		//Now, you can call the class's static and final methods using the mock object named myMathMock.
		PowerMockito.when(myMathMock2.power(2, 3)).thenReturn(8.00);
		double result2 = myMathMock2.power(2, 3);
		// Assertions to confirm(verify) that t   he methods was indeed called, and the values setup by the mocking expectation were actually returned
		assertEquals(8.00, result2, 1);
	}

	@Test
	public void powermockSpyFloor() throws Exception {

		MathAPISF myMathMock3 = PowerMockito.spy(new MathAPISF());
		//doReturn(10).when(myMathMock3).min(0, 10);
		PowerMockito.when(myMathMock3.floor(7.9f)).thenReturn(7.0f);
		float valueReturnedByMethod = myMathMock3.floor(7.9f);
		//You can then use Mockito to verify if the method was called.
		Mockito.verify(myMathMock3).floor(7.9f);
		//And then check if the value returned by the final ( or static) method was indeed according to the expectation.
		assertEquals(7.0f, valueReturnedByMethod,1);

	}

--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/java.util=ALL-UNNAMED
--add-opens java.base/java.lang.reflect=ALL-UNNAMED

<dependency>
    <groupId>com.github.tomakehurst</groupId>
    <artifactId>wiremock-jre8-standalone</artifactId>
    <version>2.31.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.2</version>
    <scope>test</scope>
</dependency>

import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.client.WireMock;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import wiremock.org.apache.http.HttpResponse;
import wiremock.org.apache.http.client.methods.HttpGet;
import wiremock.org.apache.http.impl.client.CloseableHttpClient;
import wiremock.org.apache.http.impl.client.HttpClients;

import java.io.InputStream;

import static com.github.tomakehurst.wiremock.client.WireMock.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MathApiIntegrationTestWireMock {

    private static WireMockServer wireMockServer;

    @BeforeAll
    public static void setup() {
        wireMockServer = new WireMockServer();
        wireMockServer.start();
        WireMock.configureFor("localhost", wireMockServer.port());
		// default port is 8080, you can specify any other port here, OR via @AutoConfigureWireMock annotation OR via --post command line parameter OR just set port to 0 so that wiremock chooses a random port which can then be referred via (wiremock.server.port)  endpoint property.
    }

    @AfterAll
    public static void tearDown() {
        wireMockServer.stop();
    }

    @Test
    public void testMinFunction() throws Exception {
        // Define the expected request and response for the min function, if your request has many query parameters you can consider using multiple  ".withQueryParam("parameter1", equalTo("value1"))" for readability. 
	
        stubFor(get(urlEqualTo("/MathAPI/min?param1=7¶m2=8"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody("{\"result\": 7}")
                ));
		// aResponse() is a static method in the WireMock class, used to create a new ResponseDefinitionBuilder object 
        // Your actual code to make the API call and assert the result goes here
		CloseableHttpClient testHttpClient = HttpClients.createDefault();
		HttpGet request = new HttpGet("http://localhost:8080/MathAPI/min?param1=7¶m2=8");
		 HttpResponse httpResponse = testHttpClient.execute(request);
		String responseString = HTTPResponseToString(httpResponse); 
		
        // Verify that the expected request was made
        verify(getRequestedFor(urlEqualTo("/MathAPI/min?param1=7¶m2=8")));
				
		// OR for an exact number of calls, use the code below 
		// verify(exactly(1), getRequestedFor(urlEqualTo("http://localhost:8080/MathAPI/min?param1=7¶m2=8")));
		assertEquals("{\"result\": 7}", responseString); 
    }

    @Test
    public void testMaxFunction() throws Exception {
        // Define the expected request and response for the max function
        stubFor(get(urlEqualTo("/MathAPI/max?param1=8¶m2=5"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody("{\"result\": 8}")
                ));
        
		// Make the API call
        CloseableHttpClient testHttpClient = HttpClients.createDefault();
		HttpGet request = new HttpGet("http://localhost:8080/MathAPI/max?param1=8¶m2=5");
		HttpResponse httpResponse = testHttpClient.execute(request);
		String responseString = HTTPResponseToString(httpResponse);

        // Verify that the expected request was made
        verify(getRequestedFor(urlEqualTo("/MathAPI/max?param1=8¶m2=5")));
		assertEquals("{\"result\": 8}", responseString); 
		
    }

    // Similar tests for squareroot(), power(), and floor() functions
	
	private String HTTPResponseToString(HttpResponse myResponse) throws Exception {
		InputStream responseStream = myResponse.getEntity().getContent();
		java.util.Scanner scanner = new java.util.Scanner(responseStream, "UTF-8");
		String responseString = scanner.useDelimiter("\\Z").next();
		scanner.close();
		return responseString;
	}
}

stubFor(post(urlPathEqualTo("/min"))
.willReturn(permanentRedirect("someURL/MathAPI/calculateMin")));

stubFor(post(urlEqualTo("/min"))
.willReturn(aResponse()
.withFixedDelay(400)
.withStatus(200)
.withBody("{\"result\": 7}")
));

withFault.(withFault (EMPTY_RESPONSE/Fault.MALFORMED_RESPONSE_CHUNK/EMPTY_RESPONSE/RANDOM_DATA_THEN_CLOSE/CONNECTION_RESET_BY_PEER) ) 

.willReturn(aResponse()
.withBody(FixtureHelpers.fixture("fixtures/my_test.json"))
.withHeader("Content-Type", "text/json")
.withStatus(200)));