187 lines
7.5 KiB
Java
187 lines
7.5 KiB
Java
package unit;
|
||
|
||
import java.util.ArrayList;
|
||
import java.util.HashSet;
|
||
import java.util.List;
|
||
|
||
/**
|
||
* IgraphCohesiveBlocksTest
|
||
*
|
||
* Models CWE-407 defect igraph-0001:
|
||
*
|
||
* python-igraph CohesiveBlocks.max_cohesion() — list membership scan
|
||
* File: src/igraph/clustering.py, line 1311
|
||
*
|
||
* Defective: self._clusters is a list-of-lists; `if idx in cluster` is
|
||
* O(|cluster|) per block, O(B×C) per call, O(V×B×C) for all
|
||
* vertices — degrades to O(V²) when B×C ~ V.
|
||
*
|
||
* Fixed: self._cluster_sets is a list-of-frozensets; `if idx in
|
||
* cluster_set` is O(1); full-pass cost is O(V×B).
|
||
*
|
||
* Tests instrument comparison counts explicitly — no wall-clock timing.
|
||
*/
|
||
public class IgraphCohesiveBlocksTest {
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Model: a CohesiveBlocks object with B blocks, each of size C.
|
||
// Vertex indices are integers 0..V-1.
|
||
// We simulate max_cohesion(idx) for each vertex 0..V-1.
|
||
// -----------------------------------------------------------------------
|
||
|
||
/**
|
||
* Defective path: each cluster stored as ArrayList.
|
||
* `if idx in cluster` performs a linear scan of the list.
|
||
*
|
||
* @param numVertices V — total vertex count
|
||
* @param numBlocks B — number of cohesive blocks
|
||
* @param clusterSize C — vertices per block (each block = consecutive V IDs)
|
||
* @return total element comparisons across all V calls to max_cohesion
|
||
*/
|
||
static long defectiveMaxCohesion(int numVertices, int numBlocks, int clusterSize) {
|
||
// Build B clusters, each containing clusterSize consecutive vertex IDs
|
||
// (wrapping mod V to keep IDs in range)
|
||
List<ArrayList<Integer>> clusters = new ArrayList<>();
|
||
int[] cohesion = new int[numBlocks];
|
||
for (int b = 0; b < numBlocks; b++) {
|
||
ArrayList<Integer> cluster = new ArrayList<>();
|
||
for (int c = 0; c < clusterSize; c++) {
|
||
cluster.add((b * clusterSize + c) % numVertices);
|
||
}
|
||
clusters.add(cluster);
|
||
cohesion[b] = b + 1; // arbitrary cohesion score
|
||
}
|
||
|
||
long comparisons = 0;
|
||
// Simulate max_cohesion(idx) for every vertex (the natural full-pass use)
|
||
for (int idx = 0; idx < numVertices; idx++) {
|
||
// Defective: for each block, scan the list linearly
|
||
for (int b = 0; b < numBlocks; b++) {
|
||
ArrayList<Integer> cluster = clusters.get(b);
|
||
for (Integer member : cluster) {
|
||
comparisons++; // O(|cluster|) list scan
|
||
if (member.equals(idx)) {
|
||
break; // found — stop scanning this cluster
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return comparisons;
|
||
}
|
||
|
||
/**
|
||
* Fixed path: each cluster stored as HashSet (models Python frozenset).
|
||
* `if idx in cluster_set` is O(1) average.
|
||
*
|
||
* @param numVertices V
|
||
* @param numBlocks B
|
||
* @param clusterSize C
|
||
* @return total hash lookups across all V calls to max_cohesion
|
||
*/
|
||
static long fixedMaxCohesion(int numVertices, int numBlocks, int clusterSize) {
|
||
List<HashSet<Integer>> clusterSets = new ArrayList<>();
|
||
for (int b = 0; b < numBlocks; b++) {
|
||
HashSet<Integer> set = new HashSet<>();
|
||
for (int c = 0; c < clusterSize; c++) {
|
||
set.add((b * clusterSize + c) % numVertices);
|
||
}
|
||
clusterSets.add(set);
|
||
}
|
||
|
||
long lookups = 0;
|
||
for (int idx = 0; idx < numVertices; idx++) {
|
||
for (int b = 0; b < numBlocks; b++) {
|
||
lookups++; // O(1) hash probe — CWE-407 fix
|
||
clusterSets.get(b).contains(idx);
|
||
}
|
||
}
|
||
return lookups;
|
||
}
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Test 1: defective cost > fixed cost at V=100, B=20, C=10
|
||
// -----------------------------------------------------------------------
|
||
static void test1_listScanCostsMoreThanSetLookup() {
|
||
int V = 100, B = 20, C = 10;
|
||
long defectOps = defectiveMaxCohesion(V, B, C);
|
||
long fixedOps = fixedMaxCohesion(V, B, C);
|
||
|
||
System.out.printf(
|
||
"test1: V=%d B=%d C=%d defect_comparisons=%d fixed_lookups=%d%n",
|
||
V, B, C, defectOps, fixedOps);
|
||
|
||
assert defectOps > fixedOps
|
||
: "igraph-0001: list scan must do more work than set lookup; defect="
|
||
+ defectOps + " fixed=" + fixedOps;
|
||
// Fixed cost is exactly V*B (one hash probe per block per vertex)
|
||
assert fixedOps == (long) V * B
|
||
: "igraph-0001: fixed lookups should be V*B=" + ((long) V * B)
|
||
+ " got " + fixedOps;
|
||
}
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Test 2: defect grows super-linearly with clusterSize; fixed does not
|
||
// Doubling C doubles defect cost (more comparisons per scan),
|
||
// but fixed cost stays constant (O(1) per lookup regardless of C).
|
||
// -----------------------------------------------------------------------
|
||
static void test2_defectGrowsWithClusterSize() {
|
||
int V = 80, B = 10;
|
||
int C1 = 8, C2 = 16; // double cluster size
|
||
|
||
long d1 = defectiveMaxCohesion(V, B, C1);
|
||
long d2 = defectiveMaxCohesion(V, B, C2);
|
||
long f1 = fixedMaxCohesion(V, B, C1);
|
||
long f2 = fixedMaxCohesion(V, B, C2);
|
||
|
||
System.out.printf(
|
||
"test2: V=%d B=%d C1=%d defect=%d fixed=%d | C2=%d defect=%d fixed=%d%n",
|
||
V, B, C1, d1, f1, C2, d2, f2);
|
||
|
||
// Defect cost grows with C; fixed cost is independent of C
|
||
assert d2 > d1
|
||
: "igraph-0001: defect comparisons must grow as cluster size increases";
|
||
assert f2 == f1
|
||
: "igraph-0001: fixed lookups must not change with cluster size; f1="
|
||
+ f1 + " f2=" + f2;
|
||
}
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Test 3: at large scale (V=500, B=50, C=50) defect cost is at least
|
||
// 10x the fixed cost — demonstrating quadratic vs linear behaviour.
|
||
// -----------------------------------------------------------------------
|
||
static void test3_largeScaleSpeedup() {
|
||
int V = 500, B = 50, C = 50;
|
||
long defectOps = defectiveMaxCohesion(V, B, C);
|
||
long fixedOps = fixedMaxCohesion(V, B, C);
|
||
|
||
double ratio = (double) defectOps / Math.max(1, fixedOps);
|
||
|
||
System.out.printf(
|
||
"test3: V=%d B=%d C=%d defect=%d fixed=%d ratio=%.1fx%n",
|
||
V, B, C, defectOps, fixedOps, ratio);
|
||
|
||
assert ratio >= 10.0
|
||
: "igraph-0001: expected >= 10x speedup from set; got ratio=" + ratio;
|
||
}
|
||
|
||
// -----------------------------------------------------------------------
|
||
// Main
|
||
// -----------------------------------------------------------------------
|
||
public static void main(String[] args) {
|
||
System.out.println("=== IgraphCohesiveBlocksTest ===");
|
||
System.out.println("Modelling CWE-407: igraph-0001 — CohesiveBlocks.max_cohesion list scan");
|
||
System.out.println();
|
||
|
||
test1_listScanCostsMoreThanSetLookup();
|
||
System.out.println(" PASS test1_listScanCostsMoreThanSetLookup");
|
||
|
||
test2_defectGrowsWithClusterSize();
|
||
System.out.println(" PASS test2_defectGrowsWithClusterSize");
|
||
|
||
test3_largeScaleSpeedup();
|
||
System.out.println(" PASS test3_largeScaleSpeedup");
|
||
|
||
System.out.println();
|
||
System.out.println("3/3 PASS");
|
||
}
|
||
}
|