java-topology/defects/inkscape/unit/InkscapeTest.java

import java.util.*;

/**
 * CWE-407 simulation tests for Inkscape defects.
 *
 * inkscape-0001: SPObject::getLinkedRecursive vector linear scan O(N^2)
 * inkscape-0002: ObjectSet::raise()/lower() vector membership in nested loop O(S*N)
 * inkscape-0003: get_all_items_recursive exclude vector scan O(C*E)
 */
public class InkscapeTest {

    // ========== inkscape-0001: getLinkedRecursive ==========

    /** Defective: std::find on vector for dedup — O(N^2) */
    static List<Integer> getLinkedRecursiveDefective(Map<Integer, List<Integer>> graph, int start) {
        List<Integer> objects = new ArrayList<>();
        getLinkedRecursiveHelper(graph, start, objects);
        return objects;
    }

    static void getLinkedRecursiveHelper(Map<Integer, List<Integer>> graph, int node, List<Integer> objects) {
        List<Integer> links = graph.getOrDefault(node, Collections.emptyList());
        for (int link : links) {
            // Defect: linear scan on growing list
            if (!objects.contains(link)) {
                objects.add(link);
                getLinkedRecursiveHelper(graph, link, objects);
            }
        }
    }

    /** Fixed: HashSet for O(1) dedup */
    static List<Integer> getLinkedRecursiveFixed(Map<Integer, List<Integer>> graph, int start) {
        List<Integer> objects = new ArrayList<>();
        Set<Integer> seen = new HashSet<>();
        getLinkedRecursiveFixedHelper(graph, start, objects, seen);
        return objects;
    }

    static void getLinkedRecursiveFixedHelper(Map<Integer, List<Integer>> graph, int node,
                                               List<Integer> objects, Set<Integer> seen) {
        List<Integer> links = graph.getOrDefault(node, Collections.emptyList());
        for (int link : links) {
            if (seen.add(link)) {
                objects.add(link);
                getLinkedRecursiveFixedHelper(graph, link, objects, seen);
            }
        }
    }

    static boolean testGetLinkedRecursive() {
        // Build a graph where node 0 links to 1..N, node 1 links to 2..N, etc.
        int N = 2000;
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int i = 0; i < N; i++) {
            List<Integer> links = new ArrayList<>();
            for (int j = i + 1; j < Math.min(i + 4, N); j++) {
                links.add(j);
            }
            graph.put(i, links);
        }

        // Warmup
        for (int i = 0; i < 3; i++) {
            getLinkedRecursiveDefective(graph, 0);
            getLinkedRecursiveFixed(graph, 0);
        }

        long t0 = System.nanoTime();
        for (int i = 0; i < 10; i++) getLinkedRecursiveDefective(graph, 0);
        long defective = System.nanoTime() - t0;

        t0 = System.nanoTime();
        for (int i = 0; i < 10; i++) getLinkedRecursiveFixed(graph, 0);
        long fixed = System.nanoTime() - t0;

        double ratio = (double) defective / fixed;
        System.out.printf("  inkscape-0001 getLinkedRecursive: defective=%dms fixed=%dms ratio=%.1fx%n",
                defective / 1_000_000, fixed / 1_000_000, ratio);
        return ratio > 2.0;
    }

    // ========== inkscape-0002: raise()/lower() ==========

    /** Defective: std::find on items_copy for each sibling */
    static int raiseDefective(List<Integer> selected, List<Integer> allSiblings) {
        int ops = 0;
        for (int child : selected) {
            for (int sibling : allSiblings) {
                if (sibling == child) continue;
                // Defect: linear scan on selected list
                if (!selected.contains(sibling)) {
                    ops++;
                    break;
                }
            }
        }
        return ops;
    }

    /** Fixed: HashSet for O(1) membership */
    static int raiseFixed(List<Integer> selected, List<Integer> allSiblings) {
        Set<Integer> selectedSet = new HashSet<>(selected);
        int ops = 0;
        for (int child : selected) {
            for (int sibling : allSiblings) {
                if (sibling == child) continue;
                if (!selectedSet.contains(sibling)) {
                    ops++;
                    break;
                }
            }
        }
        return ops;
    }

    static boolean testRaiseLower() {
        int S = 1000; // selected objects
        int N = 2000; // total siblings
        List<Integer> selected = new ArrayList<>();
        for (int i = 0; i < S; i++) selected.add(i * 2);
        List<Integer> allSiblings = new ArrayList<>();
        for (int i = 0; i < N; i++) allSiblings.add(i);

        // Warmup
        for (int i = 0; i < 3; i++) {
            raiseDefective(selected, allSiblings);
            raiseFixed(selected, allSiblings);
        }

        long t0 = System.nanoTime();
        for (int i = 0; i < 50; i++) raiseDefective(selected, allSiblings);
        long defective = System.nanoTime() - t0;

        t0 = System.nanoTime();
        for (int i = 0; i < 50; i++) raiseFixed(selected, allSiblings);
        long fixed = System.nanoTime() - t0;

        double ratio = (double) defective / fixed;
        System.out.printf("  inkscape-0002 raise/lower:        defective=%dms fixed=%dms ratio=%.1fx%n",
                defective / 1_000_000, fixed / 1_000_000, ratio);
        return ratio > 2.0;
    }

    // ========== inkscape-0003: get_all_items_recursive exclude ==========

    /** Defective: std::find on exclude vector per child */
    static List<Integer> getAllItemsDefective(List<Integer> allChildren, List<Integer> exclude) {
        List<Integer> result = new ArrayList<>();
        for (int child : allChildren) {
            if (exclude.isEmpty() || !exclude.contains(child)) {
                result.add(child);
            }
        }
        return result;
    }

    /** Fixed: unordered_set for O(1) exclusion check */
    static List<Integer> getAllItemsFixed(List<Integer> allChildren, List<Integer> exclude) {
        Set<Integer> excludeSet = new HashSet<>(exclude);
        List<Integer> result = new ArrayList<>();
        for (int child : allChildren) {
            if (excludeSet.isEmpty() || !excludeSet.contains(child)) {
                result.add(child);
            }
        }
        return result;
    }

    static boolean testGetAllItemsExclude() {
        int C = 2000; // children in document
        int E = 1000; // excluded (current selection for invert)
        List<Integer> allChildren = new ArrayList<>();
        for (int i = 0; i < C; i++) allChildren.add(i);
        List<Integer> exclude = new ArrayList<>();
        for (int i = 0; i < E; i++) exclude.add(i * 2);

        // Warmup
        for (int i = 0; i < 3; i++) {
            getAllItemsDefective(allChildren, exclude);
            getAllItemsFixed(allChildren, exclude);
        }

        long t0 = System.nanoTime();
        for (int i = 0; i < 100; i++) getAllItemsDefective(allChildren, exclude);
        long defective = System.nanoTime() - t0;

        t0 = System.nanoTime();
        for (int i = 0; i < 100; i++) getAllItemsFixed(allChildren, exclude);
        long fixed = System.nanoTime() - t0;

        double ratio = (double) defective / fixed;
        System.out.printf("  inkscape-0003 getAllItems exclude: defective=%dms fixed=%dms ratio=%.1fx%n",
                defective / 1_000_000, fixed / 1_000_000, ratio);
        return ratio > 2.0;
    }

    // ========== Main ==========

    public static void main(String[] args) {
        System.out.println("Inkscape CWE-407 unit tests");
        System.out.println("==========================");

        boolean p1 = testGetLinkedRecursive();
        boolean p2 = testRaiseLower();
        boolean p3 = testGetAllItemsExclude();

        System.out.println();
        System.out.printf("inkscape-0001 getLinkedRecursive: %s%n", p1 ? "PASS" : "FAIL");
        System.out.printf("inkscape-0002 raise/lower:        %s%n", p2 ? "PASS" : "FAIL");
        System.out.printf("inkscape-0003 getAllItems exclude: %s%n", p3 ? "PASS" : "FAIL");

        if (!p1 || !p2 || !p3) {
            System.exit(1);
        }
        System.out.println("\nAll 3 tests PASS");
    }
}