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

defects/meson/unit/ExtraFilesAlgorithm.java

@@ -0,0 +1,108 @@
+package unit;
+
+import java.util.*;
+
+/**
+ * CWE-407 unit test: meson-0001
+ * BuildTarget.add_deps extra_files dedup — O(n²) list "not in" scan vs O(n) set guard.
+ *
+ * Simulates mesonbuild/build.py:1572:
+ *   self.extra_files.extend(f for f in dep.extra_files if f not in self.extra_files)
+ *
+ *   slow: "f not in self.extra_files" is O(len(extra_files)) per element → O(D*F*E)
+ *   fast: shadow set → O(D*F) amortised
+ */
+public class ExtraFilesAlgorithm {
+
+    // Slow: mirrors Python "if f not in self.extra_files" — list scan per element
+    static long slowAddDepsExtraFiles(List<List<String>> depsExtraFiles) {
+        long ops = 0;
+        List<String> extraFiles = new ArrayList<>();
+        for (List<String> depFiles : depsExtraFiles) {
+            for (String f : depFiles) {
+                boolean alreadyIn = false;
+                for (String existing : extraFiles) { // O(E) scan
+                    ops++;
+                    if (existing.equals(f)) { alreadyIn = true; break; }
+                }
+                if (!alreadyIn) extraFiles.add(f);
+            }
+        }
+        return ops;
+    }
+
+    // Fast: shadow set for O(1) membership
+    static long fastAddDepsExtraFiles(List<List<String>> depsExtraFiles) {
+        long ops = 0;
+        List<String> extraFiles = new ArrayList<>();
+        Set<String> extraFilesSet = new HashSet<>();
+        for (List<String> depFiles : depsExtraFiles) {
+            for (String f : depFiles) {
+                ops++;
+                if (extraFilesSet.add(f)) {
+                    extraFiles.add(f);
+                }
+            }
+        }
+        return ops;
+    }
+
+    // Generate D deps each contributing F extra files, with X% overlap
+    static List<List<String>> makeDepFiles(int D, int F, int uniqueFiles) {
+        List<List<String>> result = new ArrayList<>(D);
+        Random rng = new Random(42);
+        for (int d = 0; d < D; d++) {
+            List<String> files = new ArrayList<>(F);
+            for (int f = 0; f < F; f++) {
+                // Pick randomly from uniqueFiles pool — high overlap expected
+                files.add("header_" + rng.nextInt(uniqueFiles) + ".h");
+            }
+            result.add(files);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        // D=deps, F=files-per-dep, unique=unique-file-pool
+        int[][] configs = {
+            {20,  20,  30},   // small: 20 deps, 20 files each, 30 unique → high overlap
+            {50,  50,  80},
+            {100, 100, 150},
+            {200, 200, 300},
+        };
+        int passed = 0, total = 0;
+
+        for (int[] cfg : configs) {
+            int D = cfg[0], F = cfg[1], U = cfg[2];
+            List<List<String>> depFiles = makeDepFiles(D, F, U);
+
+            long slowOps = slowAddDepsExtraFiles(depFiles);
+            long fastOps = fastAddDepsExtraFiles(depFiles);
+            double ratio = (double) slowOps / fastOps;
+
+            total++;
+            System.out.printf("D=%3d F=%3d unique=%3d  slow=%8d  fast=%6d  ratio=%.1fx%n",
+                D, F, U, slowOps, fastOps, ratio);
+            assert ratio > 3.0 : "Expected ratio > 3 for D=" + D + ", got " + ratio;
+            passed++;
+        }
+
+        // Correctness: same unique set produced (order may differ so compare as sets)
+        List<List<String>> input = Arrays.asList(
+            Arrays.asList("a.h", "b.h", "c.h"),
+            Arrays.asList("b.h", "d.h"),
+            Arrays.asList("a.h", "e.h")
+        );
+        List<String> slowOut = new ArrayList<>();
+        for (List<String> dep : input)
+            for (String f : dep)
+                if (!slowOut.contains(f)) slowOut.add(f);
+        Set<String> fastOut = new LinkedHashSet<>();
+        for (List<String> dep : input) fastOut.addAll(dep);
+        assert new HashSet<>(slowOut).equals(new HashSet<>(fastOut)) :
+            "Correctness: " + slowOut + " vs " + fastOut;
+        passed++; total++;
+
+        System.out.printf("%d/%d PASS%n", passed, total);
+    }
+}