wave7: 433/194 — kafka/flink/pulsar, spring/micronaut/quarkus, nginx/haproxy/traefik, linux/nomad/consul, numpy/pandas/sklearn, ES/OS/pg/sqlite/rustc/cargo
This commit is contained in:
parent
3735145aa5
commit
5fe6da7cc2
69 changed files with 6793 additions and 32 deletions
296
defects/nomad/unit/NomadAlgorithmTest.java
Normal file
296
defects/nomad/unit/NomadAlgorithmTest.java
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
package unit;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* nomad CWE-407 unit tests:
|
||||
*
|
||||
* nomad-0001: Bitmap.IndexesInRangeFiltered — slices.Contains(filter) inside O(range) loop
|
||||
* nomad-0002: stream/subscription.filter() — slices.Contains(namespaces) per event
|
||||
* nomad-0003: GetVaultConfigurations dedup — slices.Contains(secrets) inside nested loops
|
||||
* nomad-0004: checkstore.Difference — slices.Contains(ids) per stored check
|
||||
*
|
||||
* No JUnit, no external deps.
|
||||
* Compile: javac -d . NomadAlgorithmTest.java
|
||||
* Run: java -ea unit.NomadAlgorithmTest
|
||||
*/
|
||||
public class NomadAlgorithmTest {
|
||||
|
||||
static int passed = 0;
|
||||
static int total = 0;
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// nomad-0001: Bitmap.IndexesInRangeFiltered
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Slow: mirrors Go IndexesInRangeFiltered with slices.Contains.
|
||||
* For each index in [from, to], linearly scans filter[] → O(range × |filter|).
|
||||
*/
|
||||
static long slowIndexesInRangeFiltered(boolean[] bitmap, int from, int to, int[] filter) {
|
||||
long ops = 0;
|
||||
List<Integer> result = new ArrayList<>();
|
||||
for (int i = from; i <= to; i++) {
|
||||
ops++;
|
||||
if (!bitmap[i]) {
|
||||
if (filter.length == 0) {
|
||||
result.add(i);
|
||||
} else {
|
||||
// linear scan — the defect
|
||||
boolean skip = false;
|
||||
for (int f : filter) {
|
||||
ops++;
|
||||
if (f == i) { skip = true; break; }
|
||||
}
|
||||
if (!skip) result.add(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast: build map[int] from filter once, then O(1) lookup per index → O(range + |filter|).
|
||||
*/
|
||||
static long fastIndexesInRangeFiltered(boolean[] bitmap, int from, int to, int[] filter) {
|
||||
long ops = 0;
|
||||
Set<Integer> filterSet = new HashSet<>();
|
||||
for (int f : filter) { filterSet.add(f); ops++; }
|
||||
List<Integer> result = new ArrayList<>();
|
||||
for (int i = from; i <= to; i++) {
|
||||
ops++;
|
||||
if (!bitmap[i]) {
|
||||
if (filterSet.isEmpty() || !filterSet.contains(i)) {
|
||||
result.add(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
static void testBitmapFilter() {
|
||||
System.out.println("--- nomad-0001: Bitmap.IndexesInRangeFiltered ---");
|
||||
// Simulate port range 20000-60000 (40000 ports), P already-offered ports
|
||||
int minPort = 20000;
|
||||
int maxPort = 60000;
|
||||
int bitmapSize = maxPort + 1;
|
||||
boolean[] bitmap = new boolean[bitmapSize]; // all false = available
|
||||
|
||||
int[] offerSizes = {10, 50, 100};
|
||||
for (int p : offerSizes) {
|
||||
int[] filter = new int[p];
|
||||
for (int i = 0; i < p; i++) filter[i] = minPort + i;
|
||||
|
||||
long slowOps = slowIndexesInRangeFiltered(bitmap, minPort, maxPort, filter);
|
||||
long fastOps = fastIndexesInRangeFiltered(bitmap, minPort, maxPort, filter);
|
||||
|
||||
double ratio = (double) slowOps / fastOps;
|
||||
boolean pass = ratio > (double) p / 2.0; // conservative: expect at least p/2 speedup
|
||||
total++;
|
||||
if (pass) passed++;
|
||||
System.out.printf(" range=%d filter=%-3d slow=%,10d fast=%,10d ratio=%6.1fx %s%n",
|
||||
maxPort - minPort, p, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
|
||||
assert pass : "nomad-0001 FAIL: ratio=" + ratio + " expected >" + (p / 2.0);
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// nomad-0002: stream/subscription filter — namespace check per event
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Slow: slices.Contains(namespaces, event.Namespace) per event → O(E × N).
|
||||
*/
|
||||
static long slowFilterEvents(String[] events, String[] namespaces) {
|
||||
long ops = 0;
|
||||
List<String> result = new ArrayList<>();
|
||||
for (String event : events) {
|
||||
ops++;
|
||||
// linear scan over namespaces
|
||||
boolean found = false;
|
||||
for (String ns : namespaces) {
|
||||
ops++;
|
||||
if (ns.equals(event)) { found = true; break; }
|
||||
}
|
||||
if (found) result.add(event);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast: pre-build HashSet from namespaces → O(E + N).
|
||||
*/
|
||||
static long fastFilterEvents(String[] events, String[] namespaces) {
|
||||
long ops = 0;
|
||||
Set<String> nsSet = new HashSet<>();
|
||||
for (String ns : namespaces) { nsSet.add(ns); ops++; }
|
||||
List<String> result = new ArrayList<>();
|
||||
for (String event : events) {
|
||||
ops++;
|
||||
if (nsSet.contains(event)) result.add(event);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
static void testStreamNamespaceFilter() {
|
||||
System.out.println("--- nomad-0002: stream filter namespace scan ---");
|
||||
int[] eventCounts = {1000, 5000, 10000};
|
||||
int namespaceCount = 50;
|
||||
String[] namespaces = new String[namespaceCount];
|
||||
for (int i = 0; i < namespaceCount; i++) namespaces[i] = "ns-" + i;
|
||||
|
||||
for (int e : eventCounts) {
|
||||
String[] events = new String[e];
|
||||
for (int i = 0; i < e; i++) events[i] = "ns-" + (i % namespaceCount);
|
||||
|
||||
long slowOps = slowFilterEvents(events, namespaces);
|
||||
long fastOps = fastFilterEvents(events, namespaces);
|
||||
|
||||
double ratio = (double) slowOps / fastOps;
|
||||
boolean pass = ratio > (double) namespaceCount / 3.0;
|
||||
total++;
|
||||
if (pass) passed++;
|
||||
System.out.printf(" events=%-5d namespaces=%d slow=%,10d fast=%,8d ratio=%6.1fx %s%n",
|
||||
e, namespaceCount, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
|
||||
assert pass : "nomad-0002 FAIL: ratio=" + ratio;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// nomad-0003: GetVaultConfigurations secret provider dedup
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Slow: accumulate providers in a list, slices.Contains check per entry → O(S²).
|
||||
*/
|
||||
static long slowProviderDedup(String[] providers) {
|
||||
long ops = 0;
|
||||
List<String> secrets = new ArrayList<>();
|
||||
for (String p : providers) {
|
||||
ops++;
|
||||
boolean found = false;
|
||||
for (String existing : secrets) {
|
||||
ops++;
|
||||
if (existing.equals(p)) { found = true; break; }
|
||||
}
|
||||
if (!found) secrets.add(p);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast: use HashSet for O(1) contains → O(S).
|
||||
*/
|
||||
static long fastProviderDedup(String[] providers) {
|
||||
long ops = 0;
|
||||
Set<String> seen = new HashSet<>();
|
||||
for (String p : providers) {
|
||||
ops++;
|
||||
seen.add(p);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
static void testVaultSecretsDedup() {
|
||||
System.out.println("--- nomad-0003: vault secrets provider dedup ---");
|
||||
// Many tasks, few unique providers → worst case for the dedup scan
|
||||
int[] sizes = {200, 500, 1000};
|
||||
int uniqueProviders = 10;
|
||||
|
||||
for (int n : sizes) {
|
||||
String[] providers = new String[n];
|
||||
for (int i = 0; i < n; i++) providers[i] = "provider-" + (i % uniqueProviders);
|
||||
|
||||
long slowOps = slowProviderDedup(providers);
|
||||
long fastOps = fastProviderDedup(providers);
|
||||
|
||||
double ratio = (double) slowOps / fastOps;
|
||||
boolean pass = ratio > 5.0;
|
||||
total++;
|
||||
if (pass) passed++;
|
||||
System.out.printf(" tasks=%-4d unique=%d slow=%,8d fast=%,6d ratio=%6.1fx %s%n",
|
||||
n, uniqueProviders, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
|
||||
assert pass : "nomad-0003 FAIL: ratio=" + ratio;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// nomad-0004: checkstore.Difference — O(current × ids)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Slow: for each stored ID, scan the ids[] slice → O(C × I).
|
||||
*/
|
||||
static long slowDifference(String[] stored, String[] ids) {
|
||||
long ops = 0;
|
||||
List<String> remove = new ArrayList<>();
|
||||
for (String id : stored) {
|
||||
ops++;
|
||||
boolean found = false;
|
||||
for (String x : ids) {
|
||||
ops++;
|
||||
if (x.equals(id)) { found = true; break; }
|
||||
}
|
||||
if (!found) remove.add(id);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast: build set from ids, O(1) lookup per stored ID → O(C + I).
|
||||
*/
|
||||
static long fastDifference(String[] stored, String[] ids) {
|
||||
long ops = 0;
|
||||
Set<String> idSet = new HashSet<>();
|
||||
for (String x : ids) { idSet.add(x); ops++; }
|
||||
List<String> remove = new ArrayList<>();
|
||||
for (String id : stored) {
|
||||
ops++;
|
||||
if (!idSet.contains(id)) remove.add(id);
|
||||
}
|
||||
return ops;
|
||||
}
|
||||
|
||||
static void testChecksStoreDifference() {
|
||||
System.out.println("--- nomad-0004: checkstore.Difference ---");
|
||||
int[] storedCounts = {100, 500, 1000};
|
||||
int idCount = 80;
|
||||
|
||||
for (int c : storedCounts) {
|
||||
String[] stored = new String[c];
|
||||
for (int i = 0; i < c; i++) stored[i] = "check-" + i;
|
||||
String[] ids = new String[idCount];
|
||||
for (int i = 0; i < idCount; i++) ids[i] = "check-" + (i * 3); // sparse overlap
|
||||
|
||||
long slowOps = slowDifference(stored, ids);
|
||||
long fastOps = fastDifference(stored, ids);
|
||||
|
||||
double ratio = (double) slowOps / fastOps;
|
||||
boolean pass = ratio > (double) idCount / 3.0;
|
||||
total++;
|
||||
if (pass) passed++;
|
||||
System.out.printf(" stored=%-4d ids=%d slow=%,8d fast=%,6d ratio=%6.1fx %s%n",
|
||||
c, idCount, slowOps, fastOps, ratio, pass ? "PASS" : "FAIL");
|
||||
assert pass : "nomad-0004 FAIL: ratio=" + ratio;
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("=== Nomad CWE-407 unit tests ===");
|
||||
testBitmapFilter();
|
||||
testStreamNamespaceFilter();
|
||||
testVaultSecretsDedup();
|
||||
testChecksStoreDifference();
|
||||
System.out.printf("%n%d/%d PASS%n", passed, total);
|
||||
if (passed != total) {
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue