engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

whitepaper: 312 sites / 151 ecosystems — wave2+3 defect tables and PDF rebuild

Browse source 
Add 88 new defect entries to HIGH and MEDIUM tables:
  HIGH: mysql-0001/0002, mariadb-0001, redis-0001/0002, valkey-0001/0002, openvpn-0001,
        vlc-0001, prometheus-0001, otel-collector-0001, cockroachdb-0001..0004,
        tidb-0001..0008, kubernetes-0001/0002, go-0001, kotlin-0002, scala-0001,
        allegro5-0001, sdl2-0001, grafana-0001, clickhouse-0001, duckdb-0001,
        mongodb-0001, envoy-0001, istio-0001, cilium-0001, linkerd2-0001,
        linux-0001/0002/0003, tor-0002/0003, curl-0001, julia-0001, lua-0001,
        perl5-0001, nats-0001, spring-0003/0004, tomcat-0001, onos-0002, odl-0002

  MEDIUM: helm-0001, mariadb-0002, openssl-0001/0002, memcached-0001,
          cassandra-0001..0004, flink-0001, storm-0001/0002, zookeeper-0001..0003,
          pip-0001, gradle-0001, nginx-0001, haproxy-0001, caddy-0001, varnish-0001,
          ffmpeg-0001, gstreamer-0001, raylib-0001, love2d-0001, php-0001/0002,
          r-source-0001, cpython-0002, ruby-0001, rabbitmq-0003/0004, activemq-0001,
          ovs-0001, onos-0003, odl-0002, jetty-0001

PDF: 976K
This commit is contained in:
russell@unturf.com 2026-03-27 15:23:43 -04:00
parent b3842ab6b8
commit 9934133dcf
260 changed files with 18278 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

183
defects/rabbitmq/unit/RabbitMQQueueTest.java
View file

@ -125,6 +125,73 @@ public class RabbitMQQueueTest {
return (long) nodeCount + consumerCount;
}
// -----------------------------------------------------------------------
// RMQ-003 helpers — check_declare_arguments: lists:filter + lists:member
// -----------------------------------------------------------------------
/**
* Defective: for each validator in declare_args (D elements), call
* lists:member against queueTypeArgs (Q elements) — O(D * Q) comparisons.
*/
static long rmq003Defective(List<String> declareArgs, List<String> queueTypeArgs) {
long comparisons = 0;
List<String> validators = new ArrayList<>();
for (String arg : declareArgs) {
// lists:member scan
for (String qa : queueTypeArgs) {
comparisons++;
if (arg.equals(qa)) { validators.add(arg); break; }
}
}
return comparisons;
}
/**
* Fixed: convert queueTypeArgs to a Set first, then filter in O(D).
*/
static long rmq003Fixed(List<String> declareArgs, List<String> queueTypeArgs) {
long comparisons = 0;
Set<String> queueTypeArgsSet = new HashSet<>(queueTypeArgs);
List<String> validators = new ArrayList<>();
for (String arg : declareArgs) {
comparisons++;
if (queueTypeArgsSet.contains(arg)) { validators.add(arg); }
}
return comparisons;
}
// -----------------------------------------------------------------------
// RMQ-004 helpers — check_arguments_key: lists:foreach + lists:member
// -----------------------------------------------------------------------
/**
* Defective: for each supplied arg (A elements), scan invalidArgs list (I elements) — O(A * I).
*/
static long rmq004Defective(List<String> suppliedArgs, List<String> invalidArgs) {
long comparisons = 0;
for (String arg : suppliedArgs) {
for (String inv : invalidArgs) {
comparisons++;
if (arg.equals(inv)) { break; }
}
}
return comparisons;
}
/**
* Fixed: build invalidArgs set once, then probe O(1) per arg — O(I + A).
*/
static long rmq004Fixed(List<String> suppliedArgs, List<String> invalidArgs) {
long comparisons = 0;
Set<String> invalidArgsSet = new HashSet<>(invalidArgs);
comparisons += invalidArgs.size(); // set construction: I insertions
for (String arg : suppliedArgs) {
comparisons++; // O(1) probe
invalidArgsSet.contains(arg);
}
return comparisons;
}
// -----------------------------------------------------------------------
// Test methods
// -----------------------------------------------------------------------
@ -201,7 +268,99 @@ public class RabbitMQQueueTest {
}
/**
* Test 5: RMQ-001 + RMQ-002 combined — end-to-end correctness.
* Test 5: RMQ-003 — check_declare_arguments validator filter.
* D=21 declare_args, Q=8 queue-type args, worst-case: no matches → full scan.
* Defective: O(D*Q) = 168 comparisons. Fixed: O(D) = 21.
*/
static void test_rmq003_comparison_ratio() {
final int D = 21, Q = 8;
List<String> declareArgs = new ArrayList<>();
for (int i = 0; i < D; i++) declareArgs.add("x-arg-" + i);
List<String> queueTypeArgs = new ArrayList<>();
// Q args that are NOT in declareArgs → worst-case full scan per element
for (int i = 0; i < Q; i++) queueTypeArgs.add("x-type-" + i);
long sOps = rmq003Defective(declareArgs, queueTypeArgs);
long fOps = rmq003Fixed(declareArgs, queueTypeArgs);
double ratio = (double) sOps / fOps;
System.out.printf(" RMQ-003 comparison ratio slow=%d fast=%d ratio=%.1fx%n",
sOps, fOps, ratio);
assert sOps > fOps * 5 : "RMQ-003: expected sOps > fOps*5, got slow=" + sOps + " fast=" + fOps;
}
/**
* Test 6: RMQ-003 — scaling: doubling Q doubles defective cost, fixed cost constant.
*/
static void test_rmq003_scaling_with_queue_type_args() {
final int D = 21;
List<String> declareArgs = new ArrayList<>();
for (int i = 0; i < D; i++) declareArgs.add("x-arg-" + i);
List<String> qaLo = new ArrayList<>(), qaHi = new ArrayList<>();
for (int i = 0; i < 8; i++) qaLo.add("x-qt-" + i);
for (int i = 0; i < 80; i++) qaHi.add("x-qt-" + i);
long sLo = rmq003Defective(declareArgs, qaLo);
long sHi = rmq003Defective(declareArgs, qaHi);
long fLo = rmq003Fixed(declareArgs, qaLo);
long fHi = rmq003Fixed(declareArgs, qaHi);
double sScale = (double) sHi / sLo;
double fScale = (double) fHi / fLo;
System.out.printf(" RMQ-003 Q scaling slowScale=%.1fx fastScale=%.1fx%n", sScale, fScale);
assert sScale > 5.0 : "RMQ-003: defective should scale with Q, got " + sScale;
assert fScale < 5.0 : "RMQ-003: fixed should not scale strongly with Q, got " + fScale;
}
/**
* Test 7: RMQ-004 — check_arguments_key member scan.
* A=21 supplied args, I=15 invalid args, worst-case full scan per arg.
* Defective: O(A*I) = 315. Fixed: O(I+A) = 36.
*/
static void test_rmq004_comparison_ratio() {
final int A = 21, I = 15;
List<String> suppliedArgs = new ArrayList<>();
for (int i = 0; i < A; i++) suppliedArgs.add("x-arg-" + i);
List<String> invalidArgs = new ArrayList<>();
// invalidArgs that don't overlap with suppliedArgs → worst-case full scan
for (int i = 0; i < I; i++) invalidArgs.add("x-inv-" + i);
long sOps = rmq004Defective(suppliedArgs, invalidArgs);
long fOps = rmq004Fixed(suppliedArgs, invalidArgs);
double ratio = (double) sOps / fOps;
System.out.printf(" RMQ-004 comparison ratio slow=%d fast=%d ratio=%.1fx%n",
sOps, fOps, ratio);
assert sOps > fOps * 5 : "RMQ-004: expected sOps > fOps*5, got slow=" + sOps + " fast=" + fOps;
}
/**
* Test 8: RMQ-004 — scaling: doubling I doubles defective, barely changes fixed.
*/
static void test_rmq004_scaling_with_invalid_args() {
final int A = 21;
List<String> suppliedArgs = new ArrayList<>();
for (int i = 0; i < A; i++) suppliedArgs.add("x-arg-" + i);
List<String> invLo = new ArrayList<>(), invHi = new ArrayList<>();
for (int i = 0; i < 15; i++) invLo.add("x-inv-" + i);
for (int i = 0; i < 150; i++) invHi.add("x-inv-" + i);
long sLo = rmq004Defective(suppliedArgs, invLo);
long sHi = rmq004Defective(suppliedArgs, invHi);
long fLo = rmq004Fixed(suppliedArgs, invLo);
long fHi = rmq004Fixed(suppliedArgs, invHi);
double sScale = (double) sHi / sLo;
double fScale = (double) fHi / fLo;
System.out.printf(" RMQ-004 I scaling slowScale=%.1fx fastScale=%.1fx%n", sScale, fScale);
assert sScale > 5.0 : "RMQ-004: defective should scale with I, got " + sScale;
assert fHi < sHi : "RMQ-004: fixed should be cheaper than defective at high I";
}
/**
* Test 10: RMQ-001 + RMQ-002 combined — end-to-end correctness.
* Both defective and fixed paths must agree on which messages match.
*/
static void test_correctness_both_defects() {
@ -251,17 +410,21 @@ public class RabbitMQQueueTest {
// -----------------------------------------------------------------------
public static void main(String[] args) {
System.out.println("RabbitMQQueueTest — CWE-407 model tests");
System.out.println("=========================================");
System.out.println("RabbitMQQueueTest — CWE-407 model tests (RMQ-001..004)");
System.out.println("=======================================================");
run("test_rmq001_comparison_ratio", RabbitMQQueueTest::test_rmq001_comparison_ratio);
run("test_rmq001_scaling_with_pids", RabbitMQQueueTest::test_rmq001_scaling_with_pids);
run("test_rmq002_comparison_ratio", RabbitMQQueueTest::test_rmq002_comparison_ratio);
run("test_rmq002_scaling_with_consumers", RabbitMQQueueTest::test_rmq002_scaling_with_consumers);
run("test_correctness_both_defects", RabbitMQQueueTest::test_correctness_both_defects);
run("test_rmq001_comparison_ratio", RabbitMQQueueTest::test_rmq001_comparison_ratio);
run("test_rmq001_scaling_with_pids", RabbitMQQueueTest::test_rmq001_scaling_with_pids);
run("test_rmq002_comparison_ratio", RabbitMQQueueTest::test_rmq002_comparison_ratio);
run("test_rmq002_scaling_with_consumers", RabbitMQQueueTest::test_rmq002_scaling_with_consumers);
run("test_rmq003_comparison_ratio", RabbitMQQueueTest::test_rmq003_comparison_ratio);
run("test_rmq003_scaling_with_queue_type_args", RabbitMQQueueTest::test_rmq003_scaling_with_queue_type_args);
run("test_rmq004_comparison_ratio", RabbitMQQueueTest::test_rmq004_comparison_ratio);
run("test_rmq004_scaling_with_invalid_args", RabbitMQQueueTest::test_rmq004_scaling_with_invalid_args);
run("test_correctness_both_defects", RabbitMQQueueTest::test_correctness_both_defects);
System.out.println("=========================================");
System.out.println("ALL TESTS PASSED");
System.out.println("=======================================================");
System.out.println("9/9 PASS");
}
@FunctionalInterface interface TestFn { void run() throws Exception; }