Merge branch 'master' into my_algorithm

Nishitha0730 · web-flow · commit 157d6c81757f · 2025-07-20T13:43:16.000+05:30
diff --git a/DIRECTORY.md b/DIRECTORY.md
@@ -1042,6 +1042,7 @@
           - 📄 [GrahamScanTest](src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)
           - 📄 [MidpointCircleTest](src/test/java/com/thealgorithms/geometry/MidpointCircleTest.java)
           - 📄 [MidpointEllipseTest](src/test/java/com/thealgorithms/geometry/MidpointEllipseTest.java)
+          - 📄 [PointTest](src/test/java/com/thealgorithms/geometry/PointTest.java)
         - 📁 **graph**
           - 📄 [ConstrainedShortestPathTest](src/test/java/com/thealgorithms/graph/ConstrainedShortestPathTest.java)
           - 📄 [StronglyConnectedComponentOptimizedTest](src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java)
diff --git a/src/test/java/com/thealgorithms/geometry/PointTest.java b/src/test/java/com/thealgorithms/geometry/PointTest.java
@@ -0,0 +1,117 @@
+package com.thealgorithms.geometry;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class PointTest {
+
+    @Test
+    void testCompareTo() {
+        Point p1 = new Point(1, 2);
+        Point p2 = new Point(5, -1);
+        Point p3 = new Point(3, 9);
+        Point p4 = new Point(3, 9);
+        assertEquals(1, p1.compareTo(p2));
+        assertEquals(-1, p2.compareTo(p3));
+        assertEquals(0, p3.compareTo(p4));
+    }
+
+    @Test
+    void testToString() {
+        Point p = new Point(-3, 5);
+        assertEquals("(-3, 5)", p.toString());
+    }
+
+    @Test
+    void testPolarOrder() {
+        Point p = new Point(0, 0);
+        assertNotNull(p.polarOrder());
+    }
+
+    @Test
+    void testOrientation() {
+        // setup points
+        Point pA = new Point(0, 0);
+        Point pB = new Point(1, 0);
+        Point pC = new Point(1, 1);
+
+        // test for left curve
+        assertEquals(1, Point.orientation(pA, pB, pC));
+
+        // test for right curve
+        pB = new Point(0, 1);
+        assertEquals(-1, Point.orientation(pA, pB, pC));
+
+        // test for left curve
+        pC = new Point(-1, 1);
+        assertEquals(1, Point.orientation(pA, pB, pC));
+
+        // test for right curve
+        pB = new Point(1, 0);
+        pC = new Point(1, -1);
+        assertEquals(-1, Point.orientation(pA, pB, pC));
+
+        // test for collinearity
+        pB = new Point(1, 1);
+        pC = new Point(2, 2);
+        assertEquals(0, Point.orientation(pA, pB, pC));
+    }
+
+    @Test
+    void testPolarOrderCompare() {
+        Point ref = new Point(0, 0);
+
+        Point pA = new Point(1, 1);
+        Point pB = new Point(1, -1);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(3, 0);
+        pB = new Point(2, 0);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(0, 1);
+        pB = new Point(-1, 1);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(1, 1);
+        pB = new Point(2, 2);
+        assertEquals(0, ref.polarOrder().compare(pA, pB));
+
+        pA = new Point(1, 2);
+        pB = new Point(2, 1);
+        assertTrue(ref.polarOrder().compare(pA, pB) > 0);
+
+        pA = new Point(2, 1);
+        pB = new Point(1, 2);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(-1, 0);
+        pB = new Point(-2, 0);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(2, 3);
+        pB = new Point(2, 3);
+        assertEquals(0, ref.polarOrder().compare(pA, pB));
+
+        pA = new Point(0, 1);
+        pB = new Point(0, -1);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        ref = new Point(1, 1);
+
+        pA = new Point(1, 2);
+        pB = new Point(2, 2);
+        assertTrue(ref.polarOrder().compare(pA, pB) > 0);
+
+        pA = new Point(2, 1);
+        pB = new Point(2, 0);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+
+        pA = new Point(0, 1);
+        pB = new Point(1, 0);
+        assertTrue(ref.polarOrder().compare(pA, pB) < 0);
+    }
+}
diff --git a/src/test/java/com/thealgorithms/others/CRCAlgorithmTest.java b/src/test/java/com/thealgorithms/others/CRCAlgorithmTest.java
@@ -1,29 +1,82 @@
-
 package com.thealgorithms.others;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
 
 public class CRCAlgorithmTest {
 
     @Test
-    void test1() {
+    void testNoErrorsWithZeroBER() {
         CRCAlgorithm c = new CRCAlgorithm("10010101010100101010010000001010010101010", 10, 0.0);
-
-        // A bit-error rate of 0.0 should not provide any wrong messages
-        c.changeMess();
+        c.generateRandomMess();
         c.divideMessageWithP(false);
-        assertEquals(c.getWrongMess(), 0);
+        c.changeMess();
+        c.divideMessageWithP(true);
+        assertEquals(0, c.getWrongMess(), "BER=0 should produce no wrong messages");
+        assertEquals(0, c.getWrongMessCaught(), "No errors, so no caught wrong messages");
+        assertEquals(0, c.getWrongMessNotCaught(), "No errors, so no uncaught wrong messages");
+        assertTrue(c.getCorrectMess() > 0, "Should have some correct messages");
     }
 
     @Test
-    void test2() {
+    void testAllErrorsWithBEROne() {
         CRCAlgorithm c = new CRCAlgorithm("10010101010100101010010000001010010101010", 10, 1.0);
+        c.generateRandomMess();
+        c.divideMessageWithP(false);
+        c.changeMess();
+        c.divideMessageWithP(true);
+        assertTrue(c.getWrongMess() > 0, "BER=1 should produce wrong messages");
+        assertEquals(0, c.getCorrectMess(), "BER=1 should produce no correct messages");
+    }
 
-        // A bit error rate of 1.0 should not provide any correct messages
+    @Test
+    void testIntermediateBER() {
+        CRCAlgorithm c = new CRCAlgorithm("1101", 4, 0.5);
+        c.generateRandomMess();
+        for (int i = 0; i < 1000; i++) {
+            c.refactor();
+            c.generateRandomMess();
+            c.divideMessageWithP(false);
+            c.changeMess();
+            c.divideMessageWithP(true);
+        }
+        assertTrue(c.getWrongMess() > 0, "Some wrong messages expected with BER=0.5");
+        assertTrue(c.getWrongMessCaught() >= 0, "Wrong messages caught counter >= 0");
+        assertTrue(c.getWrongMessNotCaught() >= 0, "Wrong messages not caught counter >= 0");
+        assertTrue(c.getCorrectMess() >= 0, "Correct messages counter >= 0");
+        assertEquals(c.getWrongMess(), c.getWrongMessCaught() + c.getWrongMessNotCaught(), "Sum of caught and not caught wrong messages should equal total wrong messages");
+    }
+
+    @Test
+    void testMessageChangedFlag() {
+        CRCAlgorithm c = new CRCAlgorithm("1010", 4, 1.0);
+        c.generateRandomMess();
+        c.divideMessageWithP(false);
+        c.changeMess();
+        assertTrue(c.getWrongMess() > 0, "Message should be marked as changed with BER=1");
+    }
+
+    @Test
+    void testSmallMessageSize() {
+        CRCAlgorithm c = new CRCAlgorithm("11", 2, 0.0);
+        c.generateRandomMess();
+        c.divideMessageWithP(false);
         c.changeMess();
+        c.divideMessageWithP(true);
+        assertEquals(0, c.getWrongMess(), "No errors expected for BER=0 with small message");
+    }
+
+    @Test
+    void testLargeMessageSize() {
+        CRCAlgorithm c = new CRCAlgorithm("1101", 1000, 0.01);
+        c.generateRandomMess();
         c.divideMessageWithP(false);
-        assertEquals(c.getCorrectMess(), 0);
+        c.changeMess();
+        c.divideMessageWithP(true);
+        // Just ensure counters are updated, no exceptions
+        assertTrue(c.getWrongMess() >= 0);
+        assertTrue(c.getCorrectMess() >= 0);
     }
 }
