added a concurrency test that shows that things work even under heavy concurrency

spullara · spullara · commit d2e7e949614d · 2012-11-04T14:02:57.000-08:00
diff --git a/compiler/src/main/java/com/github/mustachejava/FallbackMustacheFactory.java b/compiler/src/main/java/com/github/mustachejava/FallbackMustacheFactory.java
@@ -9,7 +9,7 @@
  * 
  * @author gw0 [http://gw.tnode.com/] <gw.2012@tnode.com>
  */
-public class FallbackMustacheFactory extends DefaultMustacheFactory {
+public class    FallbackMustacheFactory extends DefaultMustacheFactory {
 	
 	/** List of fallback resource roots to search through. */
 	private Object[] resourceRoots;
diff --git a/compiler/src/test/java/com/github/mustachejava/ConcurrencyTest.java b/compiler/src/test/java/com/github/mustachejava/ConcurrencyTest.java
@@ -0,0 +1,89 @@
+package com.github.mustachejava;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.security.SecureRandom;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static junit.framework.Assert.assertEquals;
+
+/**
+ * Inspired by an unconfirmed bug report.
+ */
+public class ConcurrencyTest {
+
+  static Random r = new SecureRandom();
+
+  private static class TestObject {
+    final int a;
+    final int b;
+    final int c;
+
+    int aa() throws InterruptedException {
+      Thread.sleep(r.nextInt(10));
+      return a;
+    }
+
+    int bb() throws InterruptedException {
+      Thread.sleep(r.nextInt(10));
+      return b;
+    }
+
+    int cc() throws InterruptedException {
+      Thread.sleep(r.nextInt(10));
+      return c;
+    }
+
+    private TestObject(int a, int b, int c) {
+      this.a = a;
+      this.b = b;
+      this.c = c;
+    }
+  }
+
+  // Alternate render
+  static String render(TestObject to) {
+    return to.a + ":" + to.b + ":" + to.c;
+  }
+
+  @Test
+  public void testConcurrentExecution() throws InterruptedException {
+    String template = "{{aa}}:{{bb}}:{{cc}}";
+    final Mustache test = new DefaultMustacheFactory().compile(new StringReader(template), "test");
+    ExecutorService es = Executors.newCachedThreadPool();
+    final AtomicInteger total = new AtomicInteger();
+    final Semaphore semaphore = new Semaphore(100);
+    for (int i = 0; i < 100000; i++) {
+      semaphore.acquire();
+      es.submit(new Runnable() {
+        @Override
+        public void run() {
+          try {
+          TestObject testObject = new TestObject(r.nextInt(), r.nextInt(), r.nextInt());
+          StringWriter sw = new StringWriter();
+            test.execute(sw, testObject).flush();
+            if (!render(testObject).equals(sw.toString())) {
+              total.incrementAndGet();
+            }
+          } catch (IOException e) {
+            // Can't fail
+            e.printStackTrace();
+            System.exit(1);
+          } finally {
+            semaphore.release();
+          }
+        }
+      });
+    }
+    // Wait for them all to complete
+    semaphore.acquire(100);
+    assertEquals(0, total.intValue());
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`*`
`10`	`10`	`* @author gw0 [http://gw.tnode.com/] <[email protected]>`
`11`	`11`	`*/`
`12`		`-public class FallbackMustacheFactory extends DefaultMustacheFactory {`
	`12`	`+public class FallbackMustacheFactory extends DefaultMustacheFactory {`
`13`	`13`
`14`	`14`	`/** List of fallback resource roots to search through. */`
`15`	`15`	`private Object[] resourceRoots;`