Author: maschmid
Date: 2012-06-26 03:46:14 -0400 (Tue, 26 Jun 2012)
New Revision: 14951
Modified:
branches/community/Seam_2_3/seam-integration-tests/src/test/java/org/jboss/seam/test/integration/ConcurrentFactoryTest.java
Log:
fix ConcurrentFactoryTest
Modified:
branches/community/Seam_2_3/seam-integration-tests/src/test/java/org/jboss/seam/test/integration/ConcurrentFactoryTest.java
===================================================================
---
branches/community/Seam_2_3/seam-integration-tests/src/test/java/org/jboss/seam/test/integration/ConcurrentFactoryTest.java 2012-06-25
07:37:51 UTC (rev 14950)
+++
branches/community/Seam_2_3/seam-integration-tests/src/test/java/org/jboss/seam/test/integration/ConcurrentFactoryTest.java 2012-06-26
07:46:14 UTC (rev 14951)
@@ -2,75 +2,121 @@
import static org.jboss.seam.ScopeType.APPLICATION;
-import org.jboss.arquillian.container.test.api.Deployment;
-import org.jboss.arquillian.container.test.api.OverProtocol;
-import org.jboss.arquillian.junit.Arquillian;
+import java.io.Serializable;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.jboss.seam.annotations.Create;
import org.jboss.seam.annotations.Factory;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
-import org.jboss.seam.contexts.ServletLifecycle;
+import org.jboss.seam.annotations.Scope;
+import org.jboss.seam.core.Expressions;
import org.jboss.seam.mock.JUnitSeamTest;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.After;
-import org.junit.runner.RunWith;
+// JBSEAM-4669
public class ConcurrentFactoryTest
extends JUnitSeamTest
{
-
- // TODO: Implement a different way to run concurrent test for junit
- // @Test(threadPoolSize = 2, invocationCount = 2)
- @Test
- @Ignore
+ private volatile boolean exceptionOccured = false;
+ static AtomicInteger testSequence = new AtomicInteger(0);
+
+ private void concurrentFactoryCallTest() throws Exception {
+ new ComponentTest() {
+ @Override
+ protected void testComponents() throws Exception {
+ int myTestSequence;
+ myTestSequence = testSequence.getAndIncrement();
+ if (myTestSequence == 0) {
+ assert
"TestString".equals(getValue("#{concurrentFactoryTest.LockHoldingComponent.string}"));
+ } else {
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ assert
"TestString".equals(getValue("#{concurrentFactoryTest.dependentString}"));
+ }
+ System.out.println(myTestSequence);
+
+ }
+ }.run();
+ }
+
+ private class ConcurrentFactoryCallTestThread extends Thread
+ {
+ public void run() {
+ try
+ {
+ ConcurrentFactoryTest.this.concurrentFactoryCallTest();
+ }
+ catch (Throwable e)
+ {
+ e.printStackTrace();
+ ConcurrentFactoryTest.this.exceptionOccured = true;
+ }
+ };
+ }
+
+ @Test(timeout=10000)
public void concurrentFactoryCall()
throws Exception
{
- new ComponentTest() {
- @Override
- protected void testComponents() throws Exception {
- assert "slowly created
String".equals(getValue("#{concurrentFactoryTest.component.injectedString}"));
- }
- }.run();
+ Thread thread1 = new ConcurrentFactoryCallTestThread();
+ Thread thread2 = new ConcurrentFactoryCallTestThread();
+
+ thread1.start();
+ thread2.start();
+
+ thread1.join();
+ thread2.join();
+
+ assert !exceptionOccured;
}
- @After
- @Override
- public void end()
- {
- if (session != null) {
- // Because we run in threads. Only the first thread that finishes ends the
session.
- ServletLifecycle.endSession(session);
+ @Name("concurrentFactoryTest.LockHoldingComponent")
+ @Scope(APPLICATION)
+ static public class LockHoldingComponent implements Serializable {
+ @In(value = "concurrentFactoryTest.slowlyCreatedComponent", create =
true) SlowlyCreatedComponent slowlyCreatedComponent;
+
+ public String getString() {
+ return (String)
Expressions.instance().createValueExpression("#{concurrentFactoryTest.plainFactoryGeneratedString}").getValue();
}
- session = null;
}
- @Name("concurrentFactoryTest.component")
- static public class Component {
- @In(value = "concurrentFactoryTest.slowlyCreatedString") String
injectedString;
-
- public String getInjectedString() {
- return injectedString;
+ @Name("concurrentFactoryTest.slowlyCreatedComponent")
+ static public class SlowlyCreatedComponent {
+ @Create
+ public void slowlyCreate() {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
}
}
+
+ @Name("concurrentFactoryTest.dependentFactory")
+ static public class DependentFactory {
+ @Factory(value = "concurrentFactoryTest.dependentString", scope =
APPLICATION, autoCreate = true)
+ public String createString() {
+ return (String)
Expressions.instance().createValueExpression("#{concurrentFactoryTest.LockHoldingComponent.string}").getValue();
+ }
+ }
- @Name("concurrentFactoryTest.SlowFactory")
- static public class SlowFactory {
- @Factory(value = "concurrentFactoryTest.slowlyCreatedString", scope =
APPLICATION, autoCreate = true)
- public String slowlyCreateString() {
- try
- {
- Thread.sleep(1000);
- return "slowly created String";
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- return null;
- }
- }
+ @Name("concurrentFactoryTest.plainFactory")
+ static public class PlainFactory {
+ @Factory(value = "concurrentFactoryTest.plainFactoryGeneratedString",
scope = APPLICATION, autoCreate = true)
+ public String createPlainString() {
+ return "TestString";
+ }
}
-
-
+ @After
+ @Override
+ public void end()
+ {
+ // don't attempt to endSession, as it will block in the deadlocked
org.jboss.seam.Component.getInstanceFromFactory lock
+ }
}
Show replies by date