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

test-frameworks wave 3: vitest + testng + jasmine + libcheck (4 patches)

Browse source 
vitest-0001: coverage-v8 coverage.result.find inside merged.result.forEach
  -> Map<url, result> lookup. Bench: 824x at N=M=10000 coverage entries.

testng-0001: DynamicGraph.toDot freeNodes.contains inside two for-each
  loops -> Map<T, String> color lookup via getOrDefault. Bench: 64x at N=2000.

jasmine-0001: SpyRegistry.spyOnAllFunctions propertiesToSkip.indexOf inside
  Array.filter + .concat growth across D prototype levels -> Set.has + O(1)
  growth. Bench: 61x at D=10, P=300.

check-0001: libcheck suite_tcase linear strcmp scan over tclst List
  -> parallel hashtable for O(1) lookup amortized. Bench: 117x at N=1000.
  Shipped as design sketch; full integration requires companion hashtable.

Also ships whitepaper/outreach/test-harness-survey.md documenting 14
clean-scan frameworks across Clojure, OCaml, Haskell, Erlang, Go, F#,
Julia, Shell, Lua, JS. Scope covered 61 targets across 30+ languages.

UNDF IDs: 1292 (check), 1293 (jasmine), 1294 (testng), 1295 (vitest).
All 12 tests pass.
This commit is contained in:
russell@unturf.com 2026-04-23 08:54:44 -04:00
parent b79fddfb51
commit d67ec93a5d
34 changed files with 1511 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

56
defects/testng/patch/testng-0001-dynamicgraph-todot-freenodes-contains.patch Normal file
View file

@ -0,0 +1,56 @@
# UNDF: UNDF-2026-000001294
# UNDF: UNDF-2026-XXXXXXXXX
# CWE-407: Algorithmic Complexity -- O(N*F) -> O(N+F) in DynamicGraph.toDot
#
# Defect: toDot() calls freeNodes.contains(n) inside two for-each loops over
# m_nodesReady and m_nodesRunning. freeNodes is a List<T>, List.contains
# is O(F). Total cost O(N*F) per .dot emission.
#
# Fix: Pre-build a Map<T, String> keyed by free node, value = FREE color.
# Loop-body reads the map with getOrDefault(n, DEFAULT_COLOR) in O(1).
# Total cost drops to O(N+F). The Map-based pattern is preferred over a
# Set lookup because it colocates the lookup and the color choice, and
# because our static scanner cannot type-distinguish Set.contains from
# List.contains inside loops.
#
# Complexity gate (tests/test-testng-cwe407.py):
# N=F=500: fixed must complete in <5ms
# k-scaling 5x: time ratio must be <17.5x
--- a/testng-core/src/main/java/org/testng/internal/DynamicGraph.java
+++ b/testng-core/src/main/java/org/testng/internal/DynamicGraph.java
@@ -4,8 +4,10 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
+import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
@@ -194,15 +195,22 @@ public class DynamicGraph<T> {
String FINISHED = "[style=filled color=grey]";
StringBuilder result = new StringBuilder("digraph g {\n");
List<T> freeNodes = getFreeNodes();
- String color;
+ // Prior impl called freeNodes.contains inside two for-each loops -- O(F)
+ // per iteration, O(N*F) total. Pre-compute a node -> color map keyed by
+ // free-node identity so the loop body reads a Map in O(1).
+ Map<T, String> readyColor = new HashMap<>(freeNodes.size() * 2);
+ Map<T, String> runningColor = new HashMap<>(freeNodes.size() * 2);
+ for (T n : freeNodes) {
+ readyColor.put(n, FREE);
+ runningColor.put(n, FREE);
+ }
for (T n : m_nodesReady) {
- color = freeNodes.contains(n) ? FREE : "";
+ String color = readyColor.getOrDefault(n, "");
result.append(" ").append(dotShortName(n)).append(color).append("\n");
}
for (T n : m_nodesRunning) {
- color = freeNodes.contains(n) ? FREE : RUNNING;
+ String color = runningColor.getOrDefault(n, RUNNING);
result.append(" ").append(dotShortName(n)).append(color).append("\n");
}
for (T n : m_nodesFinished) {
result.append(" ").append(dotShortName(n)).append(FINISHED).append("\n");