fix tests

diylc/diylc-core/src/main/java/org/diylc/utils/SwitchUtils.java

@@ -44,7 +44,9 @@ public class SwitchUtils {
     List<Integer> commonPoints = new ArrayList<>();
     for (int i = 0; i < numPoints; i++) {
       final int finalI = i;
-      if (switchingMatrix.stream().allMatch(
+      if (!switchingMatrix.stream().allMatch(
+          l -> l.isEmpty()) &&
+          switchingMatrix.stream().allMatch(
           l -> l.isEmpty() ||
               l.stream().anyMatch(
               s -> s.contains(finalI)))) {
@@ -71,69 +73,4 @@ public class SwitchUtils {
     }
     return markers;
   }
-
-  public static List<Set<Integer>> getConnectedTerminals(ISwitch switchComponent, int numPoints) {
-
-    if (!Boolean.TRUE.equals(switchComponent.getHighlightConnectedTerminals())) {
-      return List.of();
-    }
-    List<Set<Integer>> connectedGroups = new ArrayList<>();
-
-    // Only process if we have a selected position and should render connections
-    if (switchComponent.getSelectedPosition() == null || !Boolean.TRUE.equals(
-        switchComponent.getHighlightConnectedTerminals())) {
-      return connectedGroups;
-    }
-
-    // First, collect all direct connections
-    List<int[]> connections = new ArrayList<>();
-    for (int i = 0; i < numPoints; i++) {
-      for (int j = i + 1; j < numPoints; j++) {
-        if (switchComponent.arePointsConnected(i, j, switchComponent.getSelectedPosition())) {
-          connections.add(new int[] {i, j});
-        }
-      }
-    }
-
-    // Create a map to track which points are in which group
-    Map<Integer, Set<Integer>> pointToGroup = new HashMap<>();
-
-    // Process each connection
-    for (int[] connection : connections) {
-      int p1 = connection[0];
-      int p2 = connection[1];
-
-      Set<Integer> group1 = pointToGroup.get(p1);
-      Set<Integer> group2 = pointToGroup.get(p2);
-
-      if (group1 == null && group2 == null) {
-        // Create new group
-        Set<Integer> newGroup = new HashSet<>();
-        newGroup.add(p1);
-        newGroup.add(p2);
-        pointToGroup.put(p1, newGroup);
-        pointToGroup.put(p2, newGroup);
-      } else if (group1 == null) {
-        // Add p1 to p2's group
-        group2.add(p1);
-        pointToGroup.put(p1, group2);
-      } else if (group2 == null) {
-        // Add p2 to p1's group
-        group1.add(p2);
-        pointToGroup.put(p2, group1);
-      } else if (group1 != group2) {
-        // Merge groups
-        group1.addAll(group2);
-        for (Integer p : group2) {
-          pointToGroup.put(p, group1);
-        }
-      }
-    }
-
-    // Collect unique groups
-    Set<Set<Integer>> uniqueGroups = new HashSet<>(pointToGroup.values());
-    connectedGroups.addAll(uniqueGroups);
-
-    return connectedGroups;
-  }
 }

diylc/diylc-core/src/test/java/org/diylc/utils/SwitchUtilsTest.java

@@ -10,22 +10,25 @@ public class SwitchUtilsTest {
 
     // Mock switch implementation for testing
     private static class MockSwitch implements ISwitch {
-        private final List<int[]> connections;
+        private final List<List<int[]>> connectionsByPosition;
         private final Integer selectedPosition;
         private final boolean renderConnected;
+        private final int positionCount;
 
-        public MockSwitch(List<int[]> connections, Integer selectedPosition, boolean renderConnected) {
+        public MockSwitch(List<List<int[]>> connectionsByPosition, Integer selectedPosition, boolean renderConnected) {
-            this.connections = connections;
+            this.connectionsByPosition = connectionsByPosition;
             this.selectedPosition = selectedPosition;
             this.renderConnected = renderConnected;
+            this.positionCount = connectionsByPosition.size();
         }
 
         @Override
         public boolean arePointsConnected(int index1, int index2, int position) {
-            if (position != selectedPosition) return false;
+            if (position >= connectionsByPosition.size()) return false;
-            return connections.stream()
+            return connectionsByPosition.get(position).stream()
-                .anyMatch(conn -> (conn[0] == index1 && conn[1] == index2) || 
+                .anyMatch(conn -> 
-                                (conn[0] == index2 && conn[1] == index1));
+                    (conn[0] == index1 && conn[1] == index2) || 
+                    (conn[0] == index2 && conn[1] == index1));
         }
 
         @Override
@@ -37,99 +40,147 @@ public class SwitchUtilsTest {
             return renderConnected;
         }
 
-        // Other interface methods not needed for testing
+        @Override 
-        @Override public int getPositionCount() { return 0; }
+        public int getPositionCount() { 
-        @Override public String getPositionName(int position) { return null; }
+            return positionCount; 
+        }
+
+        @Override 
+        public String getPositionName(int position) { 
+            return String.valueOf(position + 1); 
+        }
+    }
+
+    @Test
+    public void testSimpleSPSTSwitch() {
+        // Create a simple SPST switch with 2 points
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
+            Arrays.asList(new int[]{0, 1})  // Position 0
+        );
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
+        
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 2, true);
+        
+        // Both points are common in the only position
+        assertEquals("A", markers[0]);
+        assertEquals("B", markers[1]);
+    }
+
+    @Test
+    public void testSPDTSwitch() {
+        // Create an SPDT switch with 3 points
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
+            Arrays.asList(new int[]{0, 1}),  // Position 0
+            Arrays.asList(new int[]{0, 2})   // Position 1
+        );
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
+        
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 3, true);
+        
+        // Point 0 is common in all positions
+        assertEquals("A", markers[0]);
+        // Point 1 is connected to point 0 in position 0
+        assertEquals("A1", markers[1]);
+        // Point 2 is connected to point 0 in position 1
+        assertEquals("A2", markers[2]);
+    }
+
+    @Test
+    public void testDPDTSwitch() {
+        // Create a DPDT switch with 6 points
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
+            Arrays.asList(new int[]{0, 1}, new int[]{3, 4}),  // Position 0
+            Arrays.asList(new int[]{0, 2}, new int[]{3, 5})   // Position 1
+        );
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
+        
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 6, true);
+        
+        // Points 0 and 3 are common in all positions
+        assertEquals("A", markers[0]);
+        assertEquals("A1", markers[1]);
+        assertEquals("A2", markers[2]);
+        assertEquals("B", markers[3]);
+        assertEquals("B1", markers[4]);
+        assertEquals("B2", markers[5]);
+    }
+
+    @Test
+    public void testNonVerboseMarkers() {
+        // Create a DPDT switch with 6 points
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
+            Arrays.asList(new int[]{0, 1}, new int[]{3, 4}),  // Position 0
+            Arrays.asList(new int[]{0, 2}, new int[]{3, 5})   // Position 1
+        );
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
+
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 6, false);
+
+        // Points 0 and 3 are common in all positions
+        assertEquals("A", markers[0]);
+        assertEquals("1", markers[1]);
+        assertEquals("2", markers[2]);
+        assertEquals("B", markers[3]);
+        assertEquals("1", markers[4]);
+        assertEquals("2", markers[5]);
+    }
+
+    @Test
+    public void testMultiplePositions() {
+        // Test switch with multiple positions
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
+            Arrays.asList(new int[]{0, 1}),  // Position 0
+            Arrays.asList(new int[]{0, 2}),  // Position 1
+            Arrays.asList(new int[]{0, 3})   // Position 2
+        );
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
+        
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 4, true);
+        
+        // Point 0 is common in all positions
+        assertEquals("A", markers[0]);
+        // Points 1, 2, 3 are connected to point 0 in positions 0, 1, 2 respectively
+        assertEquals("A1", markers[1]);
+        assertEquals("A2", markers[2]);
+        assertEquals("A3", markers[3]);
     }
 
     @Test
     public void testNoConnections() {
-        MockSwitch mockSwitch = new MockSwitch(Collections.emptyList(), 0, true);
+        // Test switch with no connections
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 5);
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
-        assertTrue("Should return empty list when no connections", groups.isEmpty());
+            Collections.emptyList()  // Position 0 with no connections
-    }
-
-    @Test
-    public void testSingleConnection() {
-        List<int[]> connections = Arrays.asList(new int[]{0, 1});
-        MockSwitch mockSwitch = new MockSwitch(connections, 0, true);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 5);
-        
-        assertEquals("Should have one group", 1, groups.size());
-        assertTrue("Group should contain points 0 and 1", 
-            groups.get(0).containsAll(Arrays.asList(0, 1)));
-    }
-
-    @Test
-    public void testTransitiveConnections() {
-        // Test case where 1-2-3 are connected through 2
-        List<int[]> connections = Arrays.asList(
-            new int[]{1, 2},
-            new int[]{2, 3}
         );
-        MockSwitch mockSwitch = new MockSwitch(connections, 0, true);
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 5);
         
-        assertEquals("Should have one group", 1, groups.size());
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 3, true);
-        assertTrue("Group should contain points 1, 2, and 3", 
+        
-            groups.get(0).containsAll(Arrays.asList(1, 2, 3)));
+        // No common points when there are no connections
+        assertNull(markers[0]);
+        assertNull(markers[1]);
+        assertNull(markers[2]);
     }
 
     @Test
-    public void testMultipleGroups() {
+    public void testComplexSwitch() {
-        // Test case with two separate groups: {1,2,3} and {4,6,7}
+        // Test a more complex switch with multiple poles and positions
-        List<int[]> connections = Arrays.asList(
+        List<List<int[]>> connectionsByPosition = Arrays.asList(
-            new int[]{2, 3},
+            Arrays.asList(new int[]{0, 1}, new int[]{3, 4}, new int[]{6, 7}),  // Position 0
-            new int[]{1, 3},
+            Arrays.asList(new int[]{0, 2}, new int[]{3, 5}, new int[]{6, 8})   // Position 1
-            new int[]{4, 7},
-            new int[]{4, 6}
         );
-        MockSwitch mockSwitch = new MockSwitch(connections, 0, true);
+        MockSwitch mockSwitch = new MockSwitch(connectionsByPosition, 0, true);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 8);
         
-        assertEquals("Should have two groups", 2, groups.size());
+        String[] markers = SwitchUtils.getSwitchingMarkers(mockSwitch, 9, true);
-        assertTrue("Groups should contain {1,2,3} and {4,6,7}",
-            groups.stream().anyMatch(g -> g.containsAll(Arrays.asList(1, 2, 3))) &&
-            groups.stream().anyMatch(g -> g.containsAll(Arrays.asList(4, 6, 7))));
-    }
         
-    @Test
+        // Points 0, 3, and 6 are common in all positions
-    public void testRenderConnectedFalse() {
+        assertEquals("A", markers[0]);
-        List<int[]> connections = Arrays.asList(new int[]{0, 1});
+        assertEquals("A1", markers[1]);
-        MockSwitch mockSwitch = new MockSwitch(connections, 0, false);
+        assertEquals("A2", markers[2]);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 5);
+        assertEquals("B", markers[3]);
-        assertTrue("Should return empty list when renderConnected is false", groups.isEmpty());
+        assertEquals("B1", markers[4]);
-    }
+        assertEquals("B2", markers[5]);
-
+        assertEquals("C", markers[6]);
-    @Test
+        assertEquals("C1", markers[7]);
-    public void testNoSelectedPosition() {
+        assertEquals("C2", markers[8]);
-        List<int[]> connections = Arrays.asList(new int[]{0, 1});
-        MockSwitch mockSwitch = new MockSwitch(connections, null, true);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 5);
-        assertTrue("Should return empty list when no position selected", groups.isEmpty());
-    }
-
-    @Test
-    public void testComplexConnections() {
-        // Test case with multiple interconnected points
-        List<int[]> connections = Arrays.asList(
-            new int[]{0, 1},
-            new int[]{1, 2},
-            new int[]{2, 3},
-            new int[]{3, 0},  // Creates a circle
-            new int[]{4, 5},
-            new int[]{5, 6},
-            new int[]{7, 8}   // Separate pair
-        );
-        MockSwitch mockSwitch = new MockSwitch(connections, 0, true);
-        List<Set<Integer>> groups = SwitchUtils.getConnectedTerminals(mockSwitch, 9);
-        
-        assertEquals("Should have three groups", 3, groups.size());
-        assertTrue("Should have group with points 0,1,2,3",
-            groups.stream().anyMatch(g -> g.containsAll(Arrays.asList(0, 1, 2, 3))));
-        assertTrue("Should have group with points 4,5,6",
-            groups.stream().anyMatch(g -> g.containsAll(Arrays.asList(4, 5, 6))));
-        assertTrue("Should have group with points 7,8",
-            groups.stream().anyMatch(g -> g.containsAll(Arrays.asList(7, 8))));
     }
 }