1 files changed, 106 insertions, 0 deletions
diff --git a/tests/new/CFlowThreads.java b/tests/new/CFlowThreads.java
new file mode 100644
index 000000000..3f6220e0a
--- /dev/null
+++ b/tests/new/CFlowThreads.java
@@ -0,0 +1,106 @@
+class CFlowThreads implements Runnable {
+    private static final int MAX_VALUE = 100;
+
+    public static void main(String[] argv) {
+        // Create a lot of threads
+        int x = 0;
+        while (x++ < 100) {
+            new Thread(new CFlowThreads()).start();
+            try {
+                Thread.sleep((long)(Math.random()*100));
+            } catch (Exception e) {}
+        }
+    }
+
+    public boolean gotOne(int x) {
+//        System.out.println("Succeeded, x = "+x);
+        return true;
+    }
+
+    public boolean methodA(int x) {
+        if (x % 2 == 0) return methodB(x+3);
+        else return methodC(x/2);
+    }
+
+    public boolean methodB(int x) {
+        if (x % 3 == 0) return methodC(x+4);
+        else return methodA(x/3);
+    }
+
+    public boolean methodC(int x) {
+        if (x > 2) return methodB(x-3);
+        else return gotOne(x);
+    }
+
+    public boolean startIt(int x) {
+        return methodA(x);
+    }
+
+    public void run() {
+        startIt((int)(Math.random()*MAX_VALUE));
+    }
+
+    static aspect OriginalValue of eachcflow(OriginalValue.entrypoints(int)) {
+        int recursioncount = 0;
+        int original;
+
+        pointcut entrypoints(int x):
+            instanceof(CFlowThreads) && receptions(boolean startIt(x));
+
+        before(int x): entrypoints(x) {
+            original = x;
+        }
+
+        pointcut successes(int x):
+            instanceof(CFlowThreads) && receptions(boolean gotOne(x));
+
+        pointcut recursiveCalls(int x):
+            instanceof(CFlowThreads) &&
+            receptions(boolean *(x)) && !receptions(boolean gotOne(x));
+
+        after(int x) returning (boolean s): successes(x) {
+//            System.out.println("Started at "+original+", used "+recursioncount+" hops");
+        }
+
+        boolean fail(int x) {
+//            System.out.println("Never gonna make it from "+original);
+            return false;
+        }
+
+        around(int x) returns boolean: recursiveCalls(x) {
+            if (recursioncount++ > 50) {
+                return fail(x);
+            } else {
+                return(proceed(x));
+            }
+        }
+    }
+    static aspect CheckValues {
+        static int[] hops = new int[MAX_VALUE];
+        static after(int x, OriginalValue a) returning (boolean s):
+            OriginalValue.successes(x) && hasaspect(a) {
+            synchronized (hops) {
+                if (hops[a.original] != 0) {
+                    if (hops[a.original] != a.recursioncount) {
+                        System.out.println("Error: "+a.original+" takes "+
+                            hops[a.original]+", not "+
+                            a.recursioncount+" hops.");
+                    }
+                } else {
+                    hops[a.original] = a.recursioncount;
+                }
+            }
+        }
+        static after(int x, OriginalValue a) returning (boolean s):
+            instanceof(a) && receptions(boolean fail(x)) {
+            synchronized (hops) {
+                if (hops[a.original] != 0 &&&& hops[a.original] != -1) {
+                    System.out.println("Error: "+a.original+" takes "+
+                        hops[a.original]+" hops, doesn't fail");
+                } else {
+                    hops[a.original] = -1;
+                }
+            }
+        }
+    }
+}