(PR) Updating The Developemnt Branch After HotFix

TebogoYungMercykay · web-flow · commit c16d54deeddb · 2024-10-21T13:20:02.000+02:00
diff --git a/lib/src/main/java/org/assignment/ListSynchronization.java b/lib/src/main/java/org/assignment/ListSynchronization.java
@@ -9,7 +9,7 @@ public boolean simpleTestMethod() {
         return true;
     }
 
-    public boolean delayedMethod(int delayMillis) {
+    public boolean add(int delayMillis) {
         try {
             Thread.sleep(delayMillis);
         } catch (InterruptedException e) {
@@ -19,4 +19,12 @@ public boolean delayedMethod(int delayMillis) {
 
         return true;
     }
+
+    public boolean update(int delayMillis) {
+        return add(delayMillis);
+    }
+
+    public boolean delete(int delayMillis) {
+        return add(delayMillis);
+    }
 }
diff --git a/lib/src/test/java/org/assignment/CustomTestRunner.java b/lib/src/test/java/org/assignment/CustomTestRunner.java
@@ -19,6 +19,8 @@
 public class CustomTestRunner extends Runner {
 
     private final Class<?> testClass;
+    private int passedTests = 0;
+    private int failedTests = 0;
 
     public CustomTestRunner(Class<?> testClass) {
         this.testClass = testClass;
@@ -31,6 +33,7 @@ public Description getDescription() {
 
     @Override
     public void run(RunNotifier notifier) {
+        long startTime = System.currentTimeMillis();
         try {
             Object testInstance = testClass.getDeclaredConstructor().newInstance();
             Method[] methods = testClass.getDeclaredMethods();
@@ -54,6 +57,21 @@ public void run(RunNotifier notifier) {
             }
         } catch (Exception e) {
             e.printStackTrace();
+        } finally {
+            long endTime = System.currentTimeMillis();
+            long totalTime = endTime - startTime;
+            int totalTests = passedTests + failedTests;
+
+            // ANSI escape codes for colors
+            final String ANSI_RESET = "\u001B[0m";
+            final String ANSI_GREEN = "\u001B[32m";
+            final String ANSI_RED = "\u001B[31m";
+            final String ANSI_BLUE = "\u001B[34m";
+
+            System.out.println(ANSI_GREEN + "Total tests: " + totalTests + ANSI_RESET);
+            System.out.println(ANSI_GREEN + "Passed tests: " + passedTests + ANSI_RESET);
+            System.out.println(ANSI_RED + "Failed tests: " + failedTests + ANSI_RESET);
+            System.out.println(ANSI_BLUE + "Total time taken: " + totalTime + " ms" + ANSI_RESET);
         }
     }
 
@@ -62,8 +80,10 @@ private void runSequentialTest(Method method, Object testInstance, RunNotifier n
         notifier.fireTestStarted(description);
         try {
             method.invoke(testInstance);
+            passedTests++;
             notifier.fireTestFinished(description);
         } catch (Throwable t) {
+            failedTests++;
             notifier.fireTestFailure(new org.junit.runner.notification.Failure(description, t));
         }
     }
@@ -76,8 +96,10 @@ private void runConcurrentTest(Method method, Object testInstance, RunNotifier n
 
         executor.submit(() -> {
             try {
+                passedTests++;
                 method.invoke(testInstance);
             } catch (Throwable t) {
+                failedTests++;
                 notifier.fireTestFailure(new org.junit.runner.notification.Failure(description, t));
             } finally {
                 latch.countDown();
@@ -87,6 +109,7 @@ private void runConcurrentTest(Method method, Object testInstance, RunNotifier n
         try {
             latch.await();
         } catch (InterruptedException e) {
+            failedTests++;
             notifier.fireTestFailure(new org.junit.runner.notification.Failure(description, e));
         } finally {
             executor.shutdown();
diff --git a/lib/src/test/java/org/assignment/TestRunner.java b/lib/src/test/java/org/assignment/TestRunner.java
@@ -25,123 +25,111 @@ public void someLibraryMethodReturnsTrue() {
 
     @Test
     @Order(2)
-    @RunMode(ExecutionMode.CONCURRENT)
-    public void concurrentLibraryTest() throws InterruptedException {
+    @RunMode(ExecutionMode.SEQUENTIAL)
+    public void sequentialLibraryTest() {
         ListSynchronization classUnderTest = new ListSynchronization();
         int iterations = 10; 
-        CountDownLatch latch = new CountDownLatch(iterations);
-        ThreadPool threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors());
         AtomicBoolean hasFailed = new AtomicBoolean(false);
 
         long startTime = System.nanoTime();
         for (int i = 0; i < iterations; i++) {
-            threadPool.submitTask(() -> {
-                try {
-                    if (!classUnderTest.delayedMethod(5000)) {
-                        hasFailed.set(true);
-                    }
-                } finally {
-                    latch.countDown();
-                }
-            });
+            if (!classUnderTest.add(5000)) {
+                hasFailed.set(true);
+            }
         }
-
-        latch.await();
-        threadPool.shutdown();
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Concurrent test with %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
+        System.out.printf("Sequential test completed in %.2f ms%n", executionTime);
 
-        assertFalse("Concurrent test should not have any failures", hasFailed.get());
-        assertTrue("Concurrent test should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Sequential test should not have any failures", hasFailed.get());
+        assertTrue("Sequential test should complete in a reasonable time", executionTime < 60000); 
     }
 
     @Test
     @Order(3)
     @RunMode(ExecutionMode.SEQUENTIAL)
-    public void sequentialLibraryTest() {
+    public void sequentialLibraryTestShortDelay() {
         ListSynchronization classUnderTest = new ListSynchronization();
-        int iterations = 10; 
+        int iterations = 10;
         AtomicBoolean hasFailed = new AtomicBoolean(false);
 
         long startTime = System.nanoTime();
         for (int i = 0; i < iterations; i++) {
-            if (!classUnderTest.delayedMethod(5000)) {
+            if (!classUnderTest.update(1000)) { 
                 hasFailed.set(true);
             }
         }
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Sequential test completed in %.2f ms%n", executionTime);
+        System.out.printf("Sequential test with short delay completed in %.2f ms%n", executionTime);
 
-        assertFalse("Sequential test should not have any failures", hasFailed.get());
-        assertTrue("Sequential test should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Sequential test with short delay should not have any failures", hasFailed.get());
+        assertTrue("Sequential test with short delay should complete in a reasonable time", executionTime < 60000); 
     }
 
-    
     @Test
     @Order(4)
-    @RunMode(ExecutionMode.CONCURRENT)
-    public void concurrentLibraryTestShortDelay() throws InterruptedException {
+    @RunMode(ExecutionMode.SEQUENTIAL)
+    public void sequentialLibraryTestMediumDelay() {
         ListSynchronization classUnderTest = new ListSynchronization();
         int iterations = 10;
-        CountDownLatch latch = new CountDownLatch(iterations);
-        ThreadPool threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors());
         AtomicBoolean hasFailed = new AtomicBoolean(false);
 
         long startTime = System.nanoTime();
         for (int i = 0; i < iterations; i++) {
-            threadPool.submitTask(() -> {
-                try {
-                    if (!classUnderTest.delayedMethod(1000)) { 
-                        hasFailed.set(true);
-                    }
-                } finally {
-                    latch.countDown();
-                }
-            });
+            if (!classUnderTest.delete(3000)) { 
+                hasFailed.set(true);
+            }
         }
-
-        latch.await();
-        threadPool.shutdown();
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Concurrent test with short delay and %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
+        System.out.printf("Sequential test with medium delay completed in %.2f ms%n", executionTime);
 
-        assertFalse("Concurrent test with short delay should not have any failures", hasFailed.get());
-        assertTrue("Concurrent test with short delay should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Sequential test with medium delay should not have any failures", hasFailed.get());
+        assertTrue("Sequential test with medium delay should complete in a reasonable time", executionTime < 60000); 
     }
 
     @Test
     @Order(5)
-    @RunMode(ExecutionMode.SEQUENTIAL)
-    public void sequentialLibraryTestShortDelay() {
+    @RunMode(ExecutionMode.CONCURRENT)
+    public void concurrentLibraryTestMediumDelay() throws InterruptedException {
         ListSynchronization classUnderTest = new ListSynchronization();
         int iterations = 10;
+        CountDownLatch latch = new CountDownLatch(iterations);
+        ThreadPool threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors());
         AtomicBoolean hasFailed = new AtomicBoolean(false);
 
         long startTime = System.nanoTime();
         for (int i = 0; i < iterations; i++) {
-            if (!classUnderTest.delayedMethod(1000)) { 
-                hasFailed.set(true);
-            }
+            threadPool.submitTask(() -> {
+                try {
+                    if (!classUnderTest.add(5000)) { 
+                        hasFailed.set(true);
+                    }
+                } finally {
+                    latch.countDown();
+                }
+            });
         }
+
+        latch.await();
+        threadPool.shutdown();
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Sequential test with short delay completed in %.2f ms%n", executionTime);
+        System.out.printf("Concurrent test with medium delay and %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
 
-        assertFalse("Sequential test with short delay should not have any failures", hasFailed.get());
-        assertTrue("Sequential test with short delay should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Concurrent test with medium delay should not have any failures", hasFailed.get());
+        assertTrue("Concurrent test with medium delay should complete in a reasonable time", executionTime < 60000); 
     }
 
     @Test
     @Order(6)
     @RunMode(ExecutionMode.CONCURRENT)
-    public void concurrentLibraryTestMediumDelay() throws InterruptedException {
+    public void concurrentLibraryTestShortDelay() throws InterruptedException {
         ListSynchronization classUnderTest = new ListSynchronization();
         int iterations = 10;
         CountDownLatch latch = new CountDownLatch(iterations);
@@ -152,7 +140,7 @@ public void concurrentLibraryTestMediumDelay() throws InterruptedException {
         for (int i = 0; i < iterations; i++) {
             threadPool.submitTask(() -> {
                 try {
-                    if (!classUnderTest.delayedMethod(3000)) { 
+                    if (!classUnderTest.update(1000)) { 
                         hasFailed.set(true);
                     }
                 } finally {
@@ -166,32 +154,43 @@ public void concurrentLibraryTestMediumDelay() throws InterruptedException {
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Concurrent test with medium delay and %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
+        System.out.printf("Concurrent test with short delay and %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
 
-        assertFalse("Concurrent test with medium delay should not have any failures", hasFailed.get());
-        assertTrue("Concurrent test with medium delay should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Concurrent test with short delay should not have any failures", hasFailed.get());
+        assertTrue("Concurrent test with short delay should complete in a reasonable time", executionTime < 60000); 
     }
 
     @Test
     @Order(7)
-    @RunMode(ExecutionMode.SEQUENTIAL)
-    public void sequentialLibraryTestMediumDelay() {
+    @RunMode(ExecutionMode.CONCURRENT)
+    public void concurrentLibraryTest() throws InterruptedException {
         ListSynchronization classUnderTest = new ListSynchronization();
-        int iterations = 10;
+        int iterations = 10; 
+        CountDownLatch latch = new CountDownLatch(iterations);
+        ThreadPool threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors());
         AtomicBoolean hasFailed = new AtomicBoolean(false);
 
         long startTime = System.nanoTime();
         for (int i = 0; i < iterations; i++) {
-            if (!classUnderTest.delayedMethod(3000)) { 
-                hasFailed.set(true);
-            }
+            threadPool.submitTask(() -> {
+                try {
+                    if (!classUnderTest.delete(3000)) {
+                        hasFailed.set(true);
+                    }
+                } finally {
+                    latch.countDown();
+                }
+            });
         }
+
+        latch.await();
+        threadPool.shutdown();
         long endTime = System.nanoTime();
 
         double executionTime = (endTime - startTime) / 1_000_000.0;
-        System.out.printf("Sequential test with medium delay completed in %.2f ms%n", executionTime);
+        System.out.printf("Concurrent test with %d threads completed in %.2f ms%n", Runtime.getRuntime().availableProcessors(), executionTime);
 
-        assertFalse("Sequential test with medium delay should not have any failures", hasFailed.get());
-        assertTrue("Sequential test with medium delay should complete in a reasonable time", executionTime < 60000); 
+        assertFalse("Concurrent test should not have any failures", hasFailed.get());
+        assertTrue("Concurrent test should complete in a reasonable time", executionTime < 60000); 
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public boolean simpleTestMethod() {`
`9`	`9`	`return true;`
`10`	`10`	`}`
`11`	`11`
`12`		`- public boolean delayedMethod(int delayMillis) {`
	`12`	`+ public boolean add(int delayMillis) {`
`13`	`13`	`try {`
`14`	`14`	`Thread.sleep(delayMillis);`
`15`	`15`	`} catch (InterruptedException e) {`
`@@ -19,4 +19,12 @@ public boolean delayedMethod(int delayMillis) {`
`19`	`19`
`20`	`20`	`return true;`
`21`	`21`	`}`
	`22`	`+`
	`23`	`+ public boolean update(int delayMillis) {`
	`24`	`+ return add(delayMillis);`
	`25`	`+ }`
	`26`	`+`
	`27`	`+ public boolean delete(int delayMillis) {`
	`28`	`+ return add(delayMillis);`
	`29`	`+ }`
`22`	`30`	`}`