Notes

public class CT {
public int plus(int a, int b){
return a+b;
}

public int minus(int a, int b){
return a-b;
}

public String dream(){
return null;
}

public String sky(){
return "Sky has the limit";
}

public boolean even(int n){
return n%2==0;
}

public boolean odd(int n){
return n%2!=0;
}

public int[] array1(int[] x){
return x.clone();
}

public int divide(int a, int b){
if(b==0){
throw new ArithmeticException("Any number can't divide by zero.");
}
return a/b;
}
}........
import org.junit.Test;
import org.junit.jupiter.api.BeforeAll;

import java.time.Duration;

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

public class CTTest {
CT a = new CT();

@Test
public void plus(){
assertEquals(15, a.plus(10, 5));
}

@Test
public void minus(){
assertNotEquals(10, a.minus(10, 10));
}

@Test
public void dream(){
assertNull(a.dream());
}

@BeforeAll
static void setUp(){
System.out.println("Running @BeforeAll setup...");
}

@Test
public void sky(){
assertNotNull(a.sky());
}

@Test
public void even(){
assertTrue(a.even(4));
}

@Test
public void odd(){
assertFalse(a.odd(2));
}

@Test
public void array1(){
int[] array2 = {1,2,3,4};
assertArrayEquals(array2, a.array1(array2));
assertTimeout(Duration.ofMillis(1),()->a.plus(5,6));
}

@Test
public void divide(){
assertThrows(ArithmeticException.class,()->{
a.divide(5,0);
});
}
}.....
public class ACalculator {
public int add(int a, int b){
return a+b;
}

public int subtract(int a, int b){
return a-b;
}

public int multiply(int a, int b){
return a*b;
}

public int divide(int a, int b){
if (b==0) throw new ArithmeticException("Division by zero");
return a/b;
}

public String getNull(){
return null;
}
}..import org.junit.jupiter.api.*;

import java.time.Duration;
import java.util.List;

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

public class ACalculatorTest {
private ACalculator calculator;

@BeforeAll
static void setUpAll() {
System.out.println("before all");
}

@AfterAll
static void tearDownAll() {
System.out.println("after all");
}

@BeforeEach
void setUp() {
calculator = new ACalculator(); // Initialize the calculator instance
System.out.println("Setting up before each test.");
}

@AfterEach
void tearDown() {
System.out.println("Cleaning up after each test.");
}

@Test
void testAssertions() {
assertNull(calculator.getNull(), "Expected a null value");
assertNotNull(calculator, "Calculator instance should not be null");

assertEquals(5, calculator.add(2, 3), "Addition result mismatch");
assertNotEquals(6, calculator.subtract(8, 3), "Subtraction result mismatch");

assertThrows(ArithmeticException.class, () -> calculator.divide(5, 0), "Expected division by zero to throw");
assertDoesNotThrow(() -> calculator.divide(10, 2), "No exception expected for valid division");

try {
calculator.divide(10, 0);
fail("Division by zero should throw an exception");
} catch (ArithmeticException ignored) {}

assertTrue(calculator.multiply(2, 3) > 0, "Should return a positive result");
assertFalse(calculator.add(2, -5) > 0, "Result is not positive");

ACalculator sameCalculator = calculator;
ACalculator newCalculator = new ACalculator();
assertSame(calculator, sameCalculator, "Expected same object reference");
assertNotSame(calculator, newCalculator, "Expected different object references");

int[] expectedArray = {2, 4, 6};
int[] actualArray = {calculator.multiply(1, 2), calculator.multiply(2, 2), calculator.multiply(3, 2)};
assertArrayEquals(expectedArray, actualArray, "Arrays do not match");

List<String> expectedLines = List.of("Line 1", "Line 2", "Line 3");
List<String> actualLines = List.of("Line 1", "Line 2", "Line 3");
assertLinesMatch(expectedLines, actualLines, "Lines do not match");

assertTimeout(Duration.ofMillis(100), () -> calculator.add(1, 2), "Operation took too long");
}
}