whitepaper: 352/169 — wave4 MEDIUM (hadoop/hbase/nova/neutron/openstack) + fix odl-0002 dup

defects/neutron/unit/NeutronTrustedPortsAlgorithm.java

@@ -0,0 +1,146 @@
+package unit;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * CWE-407 unit test: neutron-0001
+ * IptablesFirewallDriver.trusted_ports list vs set membership.
+ *
+ * Slow path: trusted_ports is a List — O(n) contains + O(n) remove = O(n²) per call.
+ * Fast path: trusted_ports is a Set — O(1) contains + O(1) remove = O(n) per call.
+ */
+public class NeutronTrustedPortsAlgorithm {
+
+    // --- slow: list-backed trusted ports (defective) ---
+    static long processTrustedPortsSlow(List<String> trustedPorts, List<String> portIds) {
+        long ops = 0;
+        for (String port : portIds) {
+            ops++;  // loop iteration
+            boolean found = false;
+            for (String tp : trustedPorts) {  // O(n) scan
+                ops++;
+                if (tp.equals(port)) { found = true; break; }
+            }
+            if (!found) {
+                trustedPorts.add(port);
+            }
+        }
+        return ops;
+    }
+
+    static long removeTrustedPortsSlow(List<String> trustedPorts, List<String> portIds) {
+        long ops = 0;
+        for (String port : portIds) {
+            ops++;
+            boolean found = false;
+            int idx = -1;
+            for (int i = 0; i < trustedPorts.size(); i++) {  // O(n) scan
+                ops++;
+                if (trustedPorts.get(i).equals(port)) { found = true; idx = i; break; }
+            }
+            if (found) {
+                trustedPorts.remove(idx);  // O(n) shift
+                // count the remove scan as ops too
+                ops += trustedPorts.size();
+            }
+        }
+        return ops;
+    }
+
+    // --- fast: set-backed trusted ports (fixed) ---
+    static long processTrustedPortsFast(Set<String> trustedPorts, List<String> portIds) {
+        long ops = 0;
+        for (String port : portIds) {
+            ops++;  // loop iteration + O(1) contains + O(1) add
+            if (!trustedPorts.contains(port)) {
+                trustedPorts.add(port);
+            }
+        }
+        return ops;
+    }
+
+    static long removeTrustedPortsFast(Set<String> trustedPorts, List<String> portIds) {
+        long ops = 0;
+        for (String port : portIds) {
+            ops++;  // O(1) contains + O(1) remove
+            trustedPorts.remove(port);
+        }
+        return ops;
+    }
+
+    public static void main(String[] args) {
+        int N = 2000;
+        int passed = 0;
+        int total = 0;
+
+        // Build initial trusted ports list/set
+        List<String> slowList = new ArrayList<>();
+        Set<String> fastSet = new HashSet<>();
+        List<String> portIds = new ArrayList<>();
+        for (int i = 0; i < N; i++) {
+            String p = "port-" + i;
+            slowList.add(p);
+            fastSet.add(p);
+        }
+        // New port_ids — N ports not yet trusted
+        List<String> newPortIds = new ArrayList<>();
+        for (int i = N; i < 2 * N; i++) {
+            newPortIds.add("port-" + i);
+        }
+        // Remove port_ids — first N ports
+        for (int i = 0; i < N; i++) {
+            portIds.add("port-" + i);
+        }
+
+        // Test 1: process (add) — slow vs fast ops
+        List<String> slowListCopy = new ArrayList<>(slowList);
+        Set<String> fastSetCopy = new HashSet<>(fastSet);
+        long slowOps = processTrustedPortsSlow(slowListCopy, newPortIds);
+        long fastOps = processTrustedPortsFast(fastSetCopy, newPortIds);
+        total++;
+        assert slowOps > fastOps * 10 :
+            "process: slow=" + slowOps + " fast=" + fastOps + " speedup insufficient";
+        System.out.println("Test 1 PASS: process_trusted_ports slow=" + slowOps +
+            " ops, fast=" + fastOps + " ops, speedup=" + (slowOps / Math.max(1, fastOps)) + "x");
+        passed++;
+
+        // Test 2: remove — slow vs fast ops
+        List<String> slowListRemove = new ArrayList<>(slowList);
+        Set<String> fastSetRemove = new HashSet<>(fastSet);
+        long slowRemOps = removeTrustedPortsSlow(slowListRemove, portIds);
+        long fastRemOps = removeTrustedPortsFast(fastSetRemove, portIds);
+        total++;
+        assert slowRemOps > fastRemOps * 10 :
+            "remove: slow=" + slowRemOps + " fast=" + fastRemOps + " speedup insufficient";
+        System.out.println("Test 2 PASS: remove_trusted_ports slow=" + slowRemOps +
+            " ops, fast=" + fastRemOps + " ops, speedup=" + (slowRemOps / Math.max(1, fastRemOps)) + "x");
+        passed++;
+
+        // Test 3: correctness — same elements result
+        List<String> corSlow = new ArrayList<>(slowList);
+        Set<String> corFast = new HashSet<>(fastSet);
+        processTrustedPortsSlow(corSlow, newPortIds);
+        processTrustedPortsFast(corFast, newPortIds);
+        total++;
+        assert new HashSet<>(corSlow).equals(corFast) :
+            "process: slow and fast produce different results";
+        System.out.println("Test 3 PASS: process_trusted_ports slow and fast agree");
+        passed++;
+
+        // Test 4: remove correctness
+        List<String> remSlow = new ArrayList<>(slowList);
+        Set<String> remFast = new HashSet<>(fastSet);
+        removeTrustedPortsSlow(remSlow, portIds);
+        removeTrustedPortsFast(remFast, portIds);
+        total++;
+        assert new HashSet<>(remSlow).equals(remFast) :
+            "remove: slow and fast produce different results";
+        System.out.println("Test 4 PASS: remove_trusted_ports slow and fast agree");
+        passed++;
+
+        System.out.println(passed + "/" + total + " PASS");
+    }
+}