unit-testing-with-junit

Author: shreyyq

docs/java/unit-testing-with-junit/introduction-to-junit-framework.md

@@ -0,0 +1,77 @@
+JUnit is a popular testing framework for Java that is widely used by developers to perform unit testing of Java applications. Here's an introduction to the JUnit framework:
+
+## Introduction to JUnit
+
+### What is JUnit?
+
+JUnit is a simple, open-source framework designed for writing and running automated tests in Java. It provides a set of annotations and APIs for creating and executing test cases, assertions for verifying expected outcomes, and test runners for executing tests and reporting results.
+
+### Key Features of JUnit
+
+1. **Annotations**: JUnit provides annotations such as `@Test`, `@Before`, `@After`, `@BeforeClass`, and `@AfterClass` to define test methods and setup/teardown methods.
+
+2. **Assertions**: JUnit provides a set of assertion methods in the `org.junit.Assert` class for validating expected outcomes in test cases.
+
+3. **Test Runners**: JUnit supports different test runners for executing tests, including `JUnitCore`, `JUnit4`, and IDE integrations with Eclipse, IntelliJ IDEA, and NetBeans.
+
+4. **Parameterized Tests**: JUnit allows you to run the same test method with different inputs by using parameterized tests.
+
+5. **Exception Testing**: JUnit provides mechanisms for testing expected exceptions by using the `@Test` annotation's `expected` attribute or the `@Rule` annotation with `ExpectedException`.
+
+### Example Test Class
+
+```java
+import org.junit.*;
+
+public class MyMathTest {
+
+    @BeforeClass
+    public static void setUpClass() {
+        // Setup once before any test methods run
+    }
+
+    @AfterClass
+    public static void tearDownClass() {
+        // Cleanup once after all test methods have run
+    }
+
+    @Before
+    public void setUp() {
+        // Setup before each test method
+    }
+
+    @After
+    public void tearDown() {
+        // Cleanup after each test method
+    }
+
+    @Test
+    public void testAdd() {
+        assertEquals(5, MyMath.add(2, 3));
+    }
+
+    @Test
+    public void testSubtract() {
+        assertEquals(2, MyMath.subtract(5, 3));
+    }
+
+    @Test(expected = ArithmeticException.class)
+    public void testDivideByZero() {
+        MyMath.divide(5, 0);
+    }
+}
+```
+
+### How to Use JUnit
+
+1. **Add JUnit Dependency**: Include the JUnit library in your project's build path or dependency management tool (e.g., Maven, Gradle).
+
+2. **Write Test Classes**: Create test classes with test methods annotated with `@Test` and perform assertions using JUnit's assertion methods.
+
+3. **Run Tests**: Execute tests using a test runner such as JUnitCore or an IDE that supports JUnit (e.g., Eclipse, IntelliJ IDEA).
+
+4. **Analyze Results**: Review test results to identify failures and errors, and debug issues in your code.
+
+### Conclusion
+
+JUnit is a powerful testing framework for Java that simplifies the process of writing and running automated tests. By following best practices and leveraging JUnit's features, developers can ensure the reliability and quality of their Java applications.

docs/java/unit-testing-with-junit/test-suites-and-assertions.md

@@ -0,0 +1,64 @@
+In JUnit, test suites allow you to group multiple test classes together to execute them as a single unit. Assertions are used to verify expected outcomes in test methods. Here's how you can work with test suites and assertions in JUnit:
+
+### Test Suites
+
+A test suite is a collection of test cases (i.e., test classes) that can be executed together. You can create a test suite to run multiple test classes at once.
+
+```java
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({MyMathTest.class, OtherTest.class})
+public class AllTests {
+    // This class is just a holder for the above annotations
+}
+```
+
+### Assertions
+
+JUnit provides a set of assertion methods in the `org.junit.Assert` class to verify expected outcomes in test methods.
+
+```java
+import static org.junit.Assert.*;
+
+public class MyMathTest {
+
+    @Test
+    public void testAdd() {
+        assertEquals(5, MyMath.add(2, 3)); // Verifies that the actual result is equal to the expected value
+    }
+
+    @Test
+    public void testSubtract() {
+        assertTrue(MyMath.subtract(5, 3) == 2); // Verifies that the condition is true
+    }
+
+    @Test
+    public void testDivideByZero() {
+        try {
+            MyMath.divide(5, 0);
+            fail("Expected ArithmeticException was not thrown"); // Fails the test if the expected exception is not thrown
+        } catch (ArithmeticException e) {
+            // Expected exception
+        }
+    }
+}
+```
+
+### Common Assertion Methods
+
+- `assertEquals(expected, actual)`: Verifies that the expected and actual values are equal.
+- `assertTrue(condition)`: Verifies that the given condition is true.
+- `assertFalse(condition)`: Verifies that the given condition is false.
+- `assertNull(object)`: Verifies that the given object is null.
+- `assertNotNull(object)`: Verifies that the given object is not null.
+- `assertThrows(expectedException, executable)`: Verifies that the executable throws the expected exception.
+
+### Tips
+
+- Choose appropriate assertion methods based on the type of condition you want to verify.
+- Use descriptive error messages to provide context when assertions fail.
+- Combine multiple assertions in a single test method to verify different aspects of the code.
+
+By using test suites and assertions effectively in your JUnit tests, you can organize your tests efficiently and ensure that your code behaves as expected under different conditions.

docs/java/unit-testing-with-junit/writing-and-running-tests-withjunit.md

@@ -0,0 +1,72 @@
+To write and run tests with the JUnit framework, you can follow these steps:
+
+### 1. Write Test Classes
+
+Create test classes containing test methods annotated with `@Test` to specify which methods should be executed as tests. Use JUnit's assertion methods to validate the expected behavior of your code.
+
+```java
+import org.junit.*;
+import static org.junit.Assert.*;
+
+public class MyMathTest {
+
+    @Test
+    public void testAdd() {
+        assertEquals(5, MyMath.add(2, 3));
+    }
+
+    @Test
+    public void testSubtract() {
+        assertEquals(2, MyMath.subtract(5, 3));
+    }
+
+    @Test(expected = ArithmeticException.class)
+    public void testDivideByZero() {
+        MyMath.divide(5, 0);
+    }
+}
+```
+
+### 2. Compile Test Classes
+
+Compile your test classes along with the classes being tested. Ensure that JUnit library is in your classpath.
+
+### 3. Run Tests
+
+Execute your tests using a test runner. You can use one of the following methods:
+
+- **JUnit Runner**: Run tests programmatically using `JUnitCore` class.
+
+    ```java
+    import org.junit.runner.JUnitCore;
+    import org.junit.runner.Result;
+    import org.junit.runner.notification.Failure;
+
+    public class TestRunner {
+        public static void main(String[] args) {
+            Result result = JUnitCore.runClasses(MyMathTest.class);
+            for (Failure failure : result.getFailures()) {
+                System.out.println(failure.toString());
+            }
+            System.out.println(result.wasSuccessful());
+        }
+    }
+    ```
+
+- **IDE Integration**: Run tests directly from your IDE (e.g., Eclipse, IntelliJ IDEA) by right-clicking on the test class and selecting "Run as JUnit Test".
+
+- **Maven or Gradle**: Run tests using build automation tools like Maven or Gradle by executing test goals/tasks.
+
+### 4. Analyze Results
+
+Review the test results to identify any failures or errors. JUnit provides detailed information about which tests passed, which failed, and any exceptions that occurred during testing.
+
+### Tips:
+
+- Use `@Before` and `@After` annotations to execute setup and teardown methods before and after each test method.
+
+- Utilize parameterized tests with `@RunWith(Parameterized.class)` for testing multiple inputs.
+
+- Organize your test classes into separate packages and naming conventions (e.g., `MyClassTest`, `MyClassIntegrationTest`) for better organization.
+
+By following these steps, you can effectively write and run tests using the JUnit framework to ensure the quality and reliability of your Java applications.