diff options
Diffstat (limited to 'israfil-foundation-container/src/test/java')
12 files changed, 1212 insertions, 0 deletions
diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/ContainerTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/ContainerTest.java new file mode 100644 index 0000000..ab0e624 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/ContainerTest.java @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container; + +import net.israfil.foundation.container.error.ComponentAlreadyRegisteredError; + +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +public class ContainerTest { + + AbstractContainer container = null; + AbstractContainer child = null; + + + @BeforeMethod(alwaysRun=true) + public void setUp() { + container = new AbstractContainer() { + public void start() { } + public Object getComponent(Object key) { return getStoredComponent(key); } + }; + child = new AbstractContainer(container) { + public void start() { } + public Object getComponent(Object key) { return getStoredComponent(key); } + }; + } + + @AfterMethod(alwaysRun=true) + public void tearDown() { + child = null; + container = null; + } + + @Test + public void testContainerWithSingleComponent() { + FakeComponent component = new FakeComponent1(); + container.store(FakeComponent.class, component); + Assert.assertSame(container.getComponent(FakeComponent.class), component); + } + + @Test + public void testContainerWithMultipleComponents() { + FakeComponent component = new FakeComponent1(); + FakeDependentComponent component2 = new FakeDependentComponent(component); + container.store(FakeComponent.class, component); + container.store(FakeDependentComponent.class, component2); + Assert.assertSame(container.getComponent(FakeComponent.class), component); + Assert.assertSame(container.getComponent(FakeDependentComponent.class), component2); + } + + @Test(expectedExceptions=ComponentAlreadyRegisteredError.class) + public void testContainerWithDuplicateComponents() { + FakeComponent component1 = new FakeComponent1(); + FakeComponent component2 = new FakeComponent2(); + container.store(FakeComponent.class,component1); + container.store(FakeComponent.class,component2); + } + + @Test + public void testContainerWithRepeatedRegistrationsOfTheSameComponent() { + FakeComponent component1 = new FakeComponent1(); + container.store(FakeComponent.class,component1); + container.store(FakeComponent.class,component1); + } + + @Test + public void testContainerWithParent() { + FakeComponent component1 = new FakeComponent1(); + container.store(FakeComponent.class,component1); + Assert.assertTrue(child.hasComponent(FakeComponent.class)); + Assert.assertSame(child.getComponent(FakeComponent.class), component1); + } + + @Test(expectedExceptions=ComponentAlreadyRegisteredError.class) + public void testDuplicateRegistrationWithFirstObjectInParent() { + FakeComponent component1 = new FakeComponent1(); + FakeComponent component2 = new FakeComponent2(); + container.store(FakeComponent.class,component1); + child.store(FakeComponent.class,component2); + } + + @Test + public void testDuplicateComponentsInPeerContainers() { + AbstractContainer child2 = new AbstractContainer(container) { + public void start() { } + public Object getComponent(Object key) { return getStoredComponent(key); } + }; + FakeComponent component1 = new FakeComponent1(); + FakeComponent component2 = new FakeComponent2(); + child.store(FakeComponent.class,component1); + child2.store(FakeComponent.class,component2); + Assert.assertTrue(child.hasComponent(FakeComponent.class)); + Assert.assertSame(child.getComponent(FakeComponent.class), component1); + Assert.assertNotSame(child2.getComponent(FakeComponent.class), component1); + Assert.assertTrue(child2.hasComponent(FakeComponent.class)); + Assert.assertSame(child2.getComponent(FakeComponent.class), component2); + Assert.assertNotSame(child2.getComponent(FakeComponent.class), component1); + Assert.assertFalse(container.hasComponent(FakeComponent.class)); + } + + public abstract class FakeComponent { + public abstract boolean isTrue(); + } + public class FakeComponent1 extends FakeComponent { + public boolean isTrue() { return false; } + } + public class FakeComponent2 extends FakeComponent { + public boolean isTrue() { return false; } + } + public class FakeDependentComponent { + private final FakeComponent fake; + public FakeDependentComponent(FakeComponent component) { + this.fake = component; + } + public boolean isTrue() { return fake.isTrue(); } + } +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/DefaultContainerTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/DefaultContainerTest.java new file mode 100644 index 0000000..1d108b0 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/DefaultContainerTest.java @@ -0,0 +1,263 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container; + + +import net.israfil.foundation.container.adapters.AbstractAutoWiringAdapter; +import net.israfil.foundation.container.adapters.IndependentAutoWiringAdapter; +import net.israfil.foundation.container.error.ComponentAlreadyRegisteredError; +import net.israfil.foundation.container.error.CouldNotCreateComponentError; +import net.israfil.foundation.container.error.UnsatisfiedDependencyError; + +import org.testng.Assert; +import org.testng.annotations.Test; + +public class DefaultContainerTest { + + + public DefaultContainer createContainer() { return new DefaultContainer(); } + public DefaultContainer createContainer(boolean tf) { return new DefaultContainer(tf); } + public DefaultContainer createContainer(Container c) { return new DefaultContainer(c); } + public DefaultContainer createContainer(Container c, boolean tf) { return new DefaultContainer(c,tf); } + public TestableContainer createTestableContainer() { return new TestableDefaultContainer(); } + + @Test + public void testAutoWiringContainer() { + TestableContainer container = createTestableContainer(); + container.registerType(A.class, A1.class); + container.registerType(B.class,B.adapter); + container.registerType(D.class,D.adapter); // out of order + container.registerType(C.class, new AbstractAutoWiringAdapter( + C.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new C((A)param[0]); + } + }); + container.start(); + Assert.assertFalse(container.isStored(A.class)); + Assert.assertNotNull(container.getComponent(A.class)); + Assert.assertTrue(container.isStored(A.class)); + Assert.assertFalse(container.isStored(B.class)); + Assert.assertNotNull(container.getComponent(B.class)); + Assert.assertTrue(container.isStored(B.class)); + Assert.assertFalse(container.isStored(C.class)); + Assert.assertFalse(container.isStored(D.class)); + Assert.assertNotNull(container.getComponent(D.class)); + Assert.assertTrue(container.isStored(C.class)); + Assert.assertTrue(container.isStored(D.class)); + } + + @Test(expectedExceptions=UnsatisfiedDependencyError.class) + public void testMissingDependenciesFailingLate() { + AutoWiringAdaptableContainer container = createContainer(); + container.registerType(B.class,B.adapter); + container.start(); + Assert.assertTrue(container.isRunning()); + container.getComponent(B.class); + } + + @Test + public void testDelayedFailureWithMissingDependencies() { + AutoWiringAdaptableContainer container = createContainer(); + container.registerType(B.class,B.adapter); + container.start(); + } + + @Test(expectedExceptions=UnsatisfiedDependencyError.class) + public void testMissingDependenciesFailingEarly() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(B.class,B.adapter); + container.start(); + } + + @Test + public void testMultipleStartups() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(A.class,A1.class); + container.registerType(B.class,B.adapter); + container.start(); + Assert.assertTrue(container.isRunning()); + container.start(); // no error. + } + + @Test(expectedExceptions=RuntimeException.class) + public void testStartupWithUnstartedParent() { + AutoWiringAdaptableContainer parent = createContainer(); + AutoWiringAdaptableContainer child = createContainer(parent); + parent.registerType(A.class,A1.class); + child.registerType(B.class,B.adapter); + child.start(); // failed to start parent. + } + + @Test(expectedExceptions=ComponentAlreadyRegisteredError.class) + public void testDuplicateRegistration() { + AutoWiringAdaptableContainer container = createContainer(); + container.registerType(A.class,A1.class); + container.registerType(A.class,new AutoWiringAdapter() { + public Object create(Object[] parameters) throws IllegalAccessException, InstantiationException { + return null; + } + public Object[] dependencies() { return null; } + public Class getType() { return null; } + }); + } + + @Test(expectedExceptions=RuntimeException.class) + public void testRegistryFailureAfterStart() { + AutoWiringAdaptableContainer container = createContainer(); + container.registerType(A.class,A1.class); + container.registerType(B.class,B.adapter); + container.start(); + container.registerType(D.class,D.adapter); + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testIllegalAccessDuringConstruction() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(ComponentWithProtectedConstructor.class,ComponentWithProtectedConstructor.class); + container.start(); + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testInstantiationErrorDuringConstruction() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(A.class,A.class); + container.start(); + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testNullComponentCreation() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(A.class,new IndependentAutoWiringAdapter(A.class) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return null; + } + }); + container.start(); + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testArbitraryErrorInComponentCreation() { + AutoWiringAdaptableContainer container = createContainer(true); + container.registerType(A.class,new IndependentAutoWiringAdapter(A.class) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + throw new RuntimeException("Random error"); + } + }); + container.start(); + } + + + @Test + public void testAutowiringWithDependencyInParentContainerWithEarlyInstantiation() { + AutoWiringAdaptableContainer parent = createContainer(true); + AutoWiringAdaptableContainer child = createContainer(parent,true); + parent.registerType(A.class,A1.class); + child.registerType(B.class,B.adapter); + parent.start(); + child.start(); + Assert.assertNotNull(child.getComponent(B.class)); + } + + @Test + public void testAutowiringWithDependencyInParentContainerWithLateIntantiation() { + AutoWiringAdaptableContainer parent = createContainer(); + AutoWiringAdaptableContainer child = createContainer(parent); + parent.registerType(A.class,A1.class); + child.registerType(B.class,B.adapter); + parent.start(); + child.start(); + Assert.assertNotNull(child.getComponent(B.class)); + } + + public static abstract class A { + } + public static class A1 extends A { + } + public static class B { + private final A a; + public B(A a) { + if (a==null) throw new IllegalArgumentException("B cannot support null constructor arguments."); + this.a = a; + } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + B.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new B((A)param[0]); + } + }; + } + public static class C { + private final A a; + public C(A a) { + if (a==null) throw new IllegalArgumentException("C cannot support null constructor arguments."); + this.a = a; + } + } + public static class D { + private final C c; + public D(C c) { + if (c==null) throw new IllegalArgumentException("D cannot support null constructor arguments."); + this.c = c; + } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + D.class, + new Object[] {C.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new D((C)param[0]); + } + }; + } + + public static class ComponentWithProtectedConstructor { + protected ComponentWithProtectedConstructor() {} + } + + public static interface TestableContainer extends AutoWiringAdaptableContainer { + public boolean isStored(Object key); + } + + public static class TestableDefaultContainer extends DefaultContainer implements TestableContainer { + public boolean isStored(Object key) { + return super.isStored(key); + } + } + + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LegacyContainerTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LegacyContainerTest.java new file mode 100644 index 0000000..4e69610 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LegacyContainerTest.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container; + + + +public class LegacyContainerTest extends DefaultContainerTest { + + public DefaultContainer createContainer() { return new DefaultAutoWiringAdaptableContainer(); } + public DefaultContainer createContainer(boolean tf) { return new DefaultAutoWiringAdaptableContainer(tf); } + public DefaultContainer createContainer(Container c) { return new DefaultAutoWiringAdaptableContainer(c); } + public DefaultContainer createContainer(Container c, boolean tf) { return new DefaultAutoWiringAdaptableContainer(c,tf); } + public TestableContainer createTestableContainer() { return new TestableLegacyContainer(); } + + public static class TestableLegacyContainer extends DefaultAutoWiringAdaptableContainer implements TestableContainer { + public boolean isStored(Object key) { + return super.isStored(key); + } + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LifecycleTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LifecycleTest.java new file mode 100644 index 0000000..920f17c --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/LifecycleTest.java @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container; + +import net.israfil.foundation.container.adapters.AbstractAutoWiringAdapter; +import net.israfil.foundation.container.adapters.IndependentAutoWiringAdapter; + +import org.testng.Assert; +import org.testng.annotations.Test; + + +public class LifecycleTest { + + @Test() + public void testAbstractStartable() { + Startable s = new AbstractStartable() {}; + Assert.assertFalse(s.isRunning()); + s.start(); + Assert.assertTrue(s.isRunning()); + } + + @Test() + public void testStartupOfSingleComponent() { + AutoWiringAdaptableContainer container = new DefaultContainer(); + final A1 a1 = new A1(); + container.registerType(A.class, new IndependentAutoWiringAdapter(A1.class) { + public Object create(Object[] args) { return a1; } + }); + Assert.assertFalse(a1.isRunning()); + container.start(); + container.getComponent(A.class); + Assert.assertTrue(a1.isRunning()); + } + + @Test() + public void testStartupOfStartedComponent() { + AutoWiringAdaptableContainer container = new DefaultContainer(); + final A2 a2 = new A2(); + a2.start(); + container.registerType(A.class, new IndependentAutoWiringAdapter(A.class) { + public Object create(Object[] args) { return a2; } + }); + container.start(); + container.getComponent(A.class); + Assert.assertEquals(a2.invoked,1); + } + + @Test() + public void testStartupOfMultipleComponents() { + AutoWiringAdaptableContainer container = new DefaultContainer(); + final A1 a1 = new A1(); + final C c = new C(a1); + container.registerType(A.class, new IndependentAutoWiringAdapter(A1.class) { + public Object create(Object[] args) { return a1; } + }); + container.registerType(B.class, B.adapter); + container.registerType(C.class, new AbstractAutoWiringAdapter( + C.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return c; + } + }); + Assert.assertFalse(a1.isRunning()); + Assert.assertFalse(c.isRunning()); + container.start(); + container.getComponent(A.class); + Assert.assertFalse(c.isRunning()); + Assert.assertTrue(a1.isRunning()); + container.getComponent(C.class); + Assert.assertTrue(c.isRunning()); + Assert.assertTrue(a1.isRunning()); + } + + public static interface A { + } + + public static class A1 extends AbstractStartable implements A { + public void start() { super.start(); } + } + + public static class A2 extends AbstractStartable implements A { + public int invoked = 0; + public void start() { + super.start(); + invoked++; + } + } + + public static class B { + private final A a; + public B(A a) { + if (a==null) throw new IllegalArgumentException("B cannot support null constructor arguments."); + this.a = a; + } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + B.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new B((A)param[0]); + } + }; + } + public static class C extends AbstractStartable implements Startable{ + private final A a; + public C(A a) { + if (a==null) throw new IllegalArgumentException("C cannot support null constructor arguments."); + this.a = a; + } + public void start() { super.start(); } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + C.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new C((A)param[0]); + } + }; + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/MultiThreadedAutoWiringContainerTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/MultiThreadedAutoWiringContainerTest.java new file mode 100644 index 0000000..dabc119 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/MultiThreadedAutoWiringContainerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container; + +import net.israfil.foundation.container.adapters.AbstractAutoWiringAdapter; + +import org.testng.Assert; +import org.testng.annotations.Test; + + +public class MultiThreadedAutoWiringContainerTest { + + @Test() + public void testMissingDependenciesWiringEarly() { + AutoWiringAdaptableContainer container = new DefaultContainer(true); + container.registerType(A.class,A1.class); + container.registerType(B.class,B.adapter); + container.start(); + Assert.assertNotNull(container.getComponent(B.class)); + } + + public static abstract class A { + } + public static class A1 extends A { + } + public static class B { + private final A a; + public B(A a) { + if (a==null) throw new IllegalArgumentException("B cannot support null constructor arguments."); + this.a = a; + } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + B.class, + new Object[] {A.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new B((A)param[0]); + } + }; + } + public static class C { + private final A a; + public C(A a) { + if (a==null) throw new IllegalArgumentException("C cannot support null constructor arguments."); + this.a = a; + } + } + public static class D { + private final C c; + public D(C c) { + if (c==null) throw new IllegalArgumentException("D cannot support null constructor arguments."); + this.c = c; + } + public static final AutoWiringAdapter adapter = new AbstractAutoWiringAdapter( + D.class, + new Object[] {C.class} + ) { + public Object create(Object[] param) throws IllegalAccessException, InstantiationException { + return new D((C)param[0]); + } + }; + } + + public static class E { + protected E() {} + } + + public static class TestableAutoWiringAdaptableContainer extends DefaultContainer { + public boolean isStored(Object key) { + return super.isStored(key); + } + } +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/adapters/AdaptersTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/adapters/AdaptersTest.java new file mode 100644 index 0000000..62150ed --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/adapters/AdaptersTest.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.adapters; + +import net.israfil.foundation.container.AutoWiringAdapter; + +import org.testng.Assert; +import org.testng.annotations.Test; + +/** + * Tests + * @author cgruber + * + */ +public class AdaptersTest { + + @Test(expectedExceptions=IllegalArgumentException.class) + public void testIndependentAutoWiringAdapterWithNullType() { + new IndependentAutoWiringAdapter(null); + } + + @Test + public void testIndependentAutoWiringAdapterWithEmptyParamters() throws Exception { + AutoWiringAdapter awa = new IndependentAutoWiringAdapter(Fake.class); + Fake fake = (Fake)awa.create(new Object[0]); + Assert.assertNotNull(fake); + } + + @Test + public void testIndependentAutoWiringAdapterWithNullParamters() throws Exception { + AutoWiringAdapter awa = new IndependentAutoWiringAdapter(Fake.class); + Fake fake = (Fake)awa.create(null); + Assert.assertNotNull(fake); // should not reach this assert. + } + + @Test(expectedExceptions=IllegalArgumentException.class) + public void testIndependentAutoWiringAdapterWithNonEmptyParamters() throws Exception { + AutoWiringAdapter awa = new IndependentAutoWiringAdapter(Fake.class); + Object[] parameters = new Object[1]; + parameters[0] = "A"; + Fake fake = (Fake)awa.create(parameters); + Assert.assertNotNull(fake); // should not reach this assert. + } + + public static class Fake { + public Fake() {} + } +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/ComponentAlreadyRegisteredErrorTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/ComponentAlreadyRegisteredErrorTest.java new file mode 100644 index 0000000..fdaa7fa --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/ComponentAlreadyRegisteredErrorTest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.error; + +import org.testng.annotations.Test; + + + +public class ComponentAlreadyRegisteredErrorTest { + + @Test(expectedExceptions=ComponentAlreadyRegisteredError.class) + public void testSimpleErrorThrow() throws Throwable { + Throwable error = new ComponentAlreadyRegisteredError(); + throw error; + } + + @Test(expectedExceptions=ComponentAlreadyRegisteredError.class) + public void testSimpleErrorThrowWithString() throws Throwable { + Throwable error = new ComponentAlreadyRegisteredError("test"); + throw error; + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CouldNotCreateComponentTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CouldNotCreateComponentTest.java new file mode 100644 index 0000000..87d43a4 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CouldNotCreateComponentTest.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.error; + +import org.testng.annotations.Test; + + + +public class CouldNotCreateComponentTest { + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testSimpleErrorThrow() throws Throwable { + Throwable error = new CouldNotCreateComponentError(); + throw error; + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testSimpleErrorThrowWithString() throws Throwable { + Throwable error = new CouldNotCreateComponentError("test"); + throw error; + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testSimpleErrorThrowWithThrowable() { + RuntimeException error = new CouldNotCreateComponentError( + new RuntimeException("test2") + ); + throw error; + } + + @Test(expectedExceptions=CouldNotCreateComponentError.class) + public void testSimpleErrorThrowWithStringAndThrowable() { + RuntimeException error = new CouldNotCreateComponentError( + "test", + new RuntimeException("test2") + ); + throw error; + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CyclicalDependencyErrorTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CyclicalDependencyErrorTest.java new file mode 100644 index 0000000..fc2fd93 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/CyclicalDependencyErrorTest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.error; + +import org.testng.annotations.Test; + + + +public class CyclicalDependencyErrorTest { + + @Test(expectedExceptions=CyclicalDependencyError.class) + public void testSimpleErrorThrow() throws Throwable { + Throwable error = new CyclicalDependencyError(); + throw error; + } + + @Test(expectedExceptions=CyclicalDependencyError.class) + public void testSimpleErrorThrowWithString() throws Throwable { + Throwable error = new CyclicalDependencyError("test"); + throw error; + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/UnsatisfiedDependencyErrorTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/UnsatisfiedDependencyErrorTest.java new file mode 100644 index 0000000..c668b5d --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/error/UnsatisfiedDependencyErrorTest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.error; + +import org.testng.annotations.Test; + + + +public class UnsatisfiedDependencyErrorTest { + + @Test(expectedExceptions=UnsatisfiedDependencyError.class) + public void testSimpleErrorThrow() throws Throwable { + Throwable error = new UnsatisfiedDependencyError(); + throw error; + } + + @Test(expectedExceptions=UnsatisfiedDependencyError.class) + public void testSimpleErrorThrowWithString() throws Throwable { + Throwable error = new UnsatisfiedDependencyError("test"); + throw error; + } + +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/CyclicalDependencyDetectionTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/CyclicalDependencyDetectionTest.java new file mode 100644 index 0000000..781ad92 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/CyclicalDependencyDetectionTest.java @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.util; + +import java.util.HashMap; +import java.util.Map; + +import net.israfil.foundation.container.AutoWiringAdapter; +import net.israfil.foundation.container.adapters.AbstractAutoWiringAdapter; +import net.israfil.foundation.container.adapters.IndependentAutoWiringAdapter; +import net.israfil.foundation.container.error.CyclicalDependencyError; + +import org.testng.annotations.Test; + + +public class CyclicalDependencyDetectionTest { + + @Test() + public void testCircularDependencyCheckWithNonCyclicGraph() { + // setup non-circular graph. + Map<Object,Object> registry = new HashMap<Object,Object>(); + registry.put("a", new FakeAutoWireAdapter(new Object[]{"b","e","d"})); + registry.put("b", new FakeAutoWireAdapter(new Object[]{"f","c"})); + registry.put("c", new IndependentAutoWiringAdapter(Object.class)); + registry.put("d", new FakeAutoWireAdapter(new Object[]{"e"})); + registry.put("e", new FakeAutoWireAdapter(new Object[]{"c"})); + registry.put("f", new IndependentAutoWiringAdapter(Object.class)); + NonDuplicateStack<Object> nds = new NonDuplicateStack<Object>(); + for (Object key : registry.keySet()) { + nds.push(key); + CyclicalReferenceDetectionUtil.detectCircularDependencies(registry, nds, (AutoWiringAdapter)registry.get(key)); + nds.pop(); + } + } + + @Test(expectedExceptions=CyclicalDependencyError.class) + public void testCircularDependencyCheckWithCyclicalGraph() { + // setup circular graph. + Map<Object,Object> registry = new HashMap<Object,Object>(); + registry.put("a", new FakeAutoWireAdapter(new Object[]{"b","e","d"})); + registry.put("b", new FakeAutoWireAdapter(new Object[]{"f","c"})); + registry.put("c", new FakeAutoWireAdapter(new Object[]{"d"})); + registry.put("d", new FakeAutoWireAdapter(new Object[]{"e"})); + registry.put("e", new FakeAutoWireAdapter(new Object[]{"c"})); + registry.put("f", new IndependentAutoWiringAdapter(Object.class)); + NonDuplicateStack<Object> nds = new NonDuplicateStack<Object>(); + for (Object key : registry.keySet()) { + nds.push(key); + CyclicalReferenceDetectionUtil.detectCircularDependencies(registry, nds, (AutoWiringAdapter)registry.get(key)); + nds.pop(); + } + } + + + public static class FakeAutoWireAdapter extends AbstractAutoWiringAdapter { + public FakeAutoWireAdapter(Object[] dependencies) { + super(Object.class, dependencies); + } + public Object create(Object[] parameters) throws IllegalAccessException, InstantiationException { + return null; + } + } +} diff --git a/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/NonDuplicateStackTest.java b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/NonDuplicateStackTest.java new file mode 100644 index 0000000..a67afb0 --- /dev/null +++ b/israfil-foundation-container/src/test/java/net/israfil/foundation/container/util/NonDuplicateStackTest.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2008 Israfil Consulting Services Corporation + * Copyright (c) 2008 Christian Edward Gruber + * All Rights Reserved + * + * This software is licensed under the Berkeley Standard Distribution license, + * (BSD license), as defined below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Israfil Consulting Services nor the names of its contributors + * may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * $Id: Copyright.java 618 2008-04-14 14:03:03Z christianedwardgruber $ + */ +package net.israfil.foundation.container.util; + +import java.util.Stack; + +import org.testng.Assert; +import org.testng.annotations.Test; + + +public class NonDuplicateStackTest { + + @Test() + public void testBasicStackBehaviour() { + String s1 = "Hi."; + String s2 = "Hi"; + String s3 = "Bye."; + Stack<Object> stack = new NonDuplicateStack<Object>(); + stack.push(s1); + stack.push(s2); + stack.push(s3); + Assert.assertSame(stack.pop(),s3); + Assert.assertSame(stack.pop(),s2); + Assert.assertSame(stack.pop(),s1); + } + + @Test(expectedExceptions=IllegalArgumentException.class) + public void testDuplicateHandlingByObjectRef() { + Object o1 = new Object(); + Object o2 = new Object(); + Object o3 = new Object(); + Stack<Object> stack = new NonDuplicateStack<Object>(); + stack.push(o1); + stack.push(o2); + stack.push(o3); + stack.push(o2); + } + + @Test(expectedExceptions=IllegalArgumentException.class) + public void testDuplicateHandlingByValue() { + String s1 = "Hi."; + String s2 = "Hi"; + String s3 = "Bye."; + String s4 = "Hi"; + Stack<Object> stack = new NonDuplicateStack<Object>(); + stack.push(s1); + stack.push(s2); + stack.push(s3); + stack.push(s4); + } + +} |