From 7c279747beb43c7e88633a6228a155a30e6834f7 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 27 May 2024 11:38:33 -0400 Subject: Initial import --- .../foundation/dynamic/DynamicObjectTest.java | 120 ++++++++++++ .../foundation/dynamic/DynamicUtilTest.java | 160 ++++++++++++++++ .../dynamic/DynamicallyAccessibleTest.java | 174 +++++++++++++++++ .../foundation/dynamic/DynamicallyMutableTest.java | 210 +++++++++++++++++++++ 4 files changed, 664 insertions(+) create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicObjectTest.java create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicUtilTest.java create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java (limited to 'israfil-foundation-dynamic/src/test/java') diff --git a/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicObjectTest.java b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicObjectTest.java new file mode 100644 index 0000000..a5b7a90 --- /dev/null +++ b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicObjectTest.java @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2003-2009 Israfil Consulting Services Corporation + * Copyright (c) 2003-2009 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: DynamicObjectTest.java 130 2006-12-31 23:22:17Z cgruber $ + */ + +package net.israfil.foundation.dynamic; + +import java.lang.reflect.Method; +import java.util.Date; + +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + + +@Test +public class DynamicObjectTest { + + private static final String TEST_STRING1 = "String1"; + private static final String TEST_STRING2 = "String2"; + + DynamicTestObject testDO; + + @BeforeMethod + protected void setUp() throws Exception { + testDO = new DynamicTestObject(); + } + + @AfterMethod + protected void tearDown() throws Exception { + testDO = null; + } + + public void testPerformMethods() { + Assert.assertTrue((Boolean)testDO.perform("action")); + Assert.assertEquals(TEST_STRING1,testDO.perform("action:java.lang.String",TEST_STRING1)); + Assert.assertEquals(TEST_STRING2,testDO.perform("action:java.lang.String:boolean", + new Object[] {TEST_STRING2,Boolean.TRUE})); + Assert.assertEquals(TEST_STRING2+TEST_STRING2,testDO.perform("action:java.lang.String:boolean",new Object[] {TEST_STRING2,Boolean.FALSE})); + Assert.assertNull(testDO.perform("action:java.util.Date",new Object[] {new Date()})); + } + + @Test(expectedExceptions={NoSuchMethodError.class}) + public void testPerformAgainstProtectedMethod() { + testDO.perform("action:boolean",new Object[] {Boolean.TRUE}); + } + + @Test(expectedExceptions={NoSuchMethodError.class}) + public void testPerformAgainstPackageFriendlyMethod() { + testDO.perform("action:java.lang.Float",new Object[] {1.5f}); + } + + @Test(expectedExceptions={NoSuchMethodError.class}) + public void testPerformAgainstPrivateMethod() { + testDO.perform("privateAction"); + } + + public void testRespondsTo() { + Assert.assertTrue(testDO.respondsTo("action")); + Assert.assertFalse(testDO.respondsTo("noAction")); + Assert.assertTrue(testDO.respondsTo("action:java.lang.String")); + Assert.assertFalse(testDO.respondsTo("action:java.lang.Integer")); + Assert.assertTrue(testDO.respondsTo("action:java.lang.String:"+boolean.class.getName())); + Assert.assertFalse(testDO.respondsTo("action:java.lang.Integer:java.lang.String")); + Assert.assertFalse(testDO.respondsTo("action:boolean")); + Assert.assertFalse(testDO.respondsTo("action:java.lang.Float")); + Assert.assertTrue(testDO.respondsTo("action:int")); + } + + public void testGetMethodForSelector() { + Method m = testDO.getMethodForSelector("action:java.lang.String"); + Assert.assertNotNull(m); + Assert.assertEquals("action",m.getName()); + Assert.assertEquals(String.class,m.getParameterTypes()[0]); + } + + public class DynamicTestObject extends DynamicObject { + public boolean action() { return !privateAction(); /* false */ } + public String action(String foo) { return foo; } + public String action(String foo, boolean bool) { + if (bool) return foo; + else return foo+foo; + } + public void action(Date foo) { if (foo==null);return; } + protected boolean action(boolean b) { return b; } + Float action(Float f) { return f; } + public int action(int i) { return i; } + private boolean privateAction() { return false; } + } +} diff --git a/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicUtilTest.java b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicUtilTest.java new file mode 100644 index 0000000..31d11a7 --- /dev/null +++ b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicUtilTest.java @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2003-2009 Israfil Consulting Services Corporation + * Copyright (c) 2003-2009 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: DynamicUtilTest.java 130 2006-12-31 23:22:17Z cgruber $ + */ +package net.israfil.foundation.dynamic; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import org.testng.Assert; +import org.testng.annotations.Test; + +/** + * + * @author Christian Edward Gruber + * @author Latest: $Author: cgruber $ + * @version $Revision: 130 $ + */ +@Test +public class DynamicUtilTest { + + public void testAddSuperinterfaces1() { + Class clz = IA.class; + Set> cSet = new HashSet>(); + DynamicUtil.addSuperInterfaces(cSet,clz); + Assert.assertEquals(0,cSet.size()); + } + public void testAddSuperinterfaces2() { + Class clz = IC.class; + Set> cSet = new HashSet>(); + DynamicUtil.addSuperInterfaces(cSet,clz); + Assert.assertTrue(cSet.contains(IA.class),"Should have type IA"); + Assert.assertEquals(1,cSet.size()); + } + public void testClassLookupForA() { + Class clz = A.class; + Set> cSet = DynamicUtil.getAllParentTypes(clz); + Assert.assertTrue(cSet.contains(IA.class),"Should have type IA"); + Assert.assertTrue(cSet.contains(Object.class),"Should have type Object"); + Assert.assertEquals(2,cSet.size()); + } + public void testClassLookupForB() { + Class clz = B.class; + Set> cSet = DynamicUtil.getAllParentTypes(clz); + Assert.assertTrue(cSet.contains(IA.class),"Should have type IA"); + Assert.assertTrue(cSet.contains(A.class),"Should have type A"); + Assert.assertTrue(cSet.contains(IB.class),"Should have type IB"); + Assert.assertTrue(cSet.contains(Object.class),"Should have type Object"); + Assert.assertEquals(4,cSet.size()); + } + public void testClassLookupForC() { + Class clz = C.class; + Set> cSet = DynamicUtil.getAllParentTypes(clz); + Assert.assertTrue(cSet.contains(IA.class),"Should have type IA"); + Assert.assertTrue(cSet.contains(IC.class),"Should have type IC"); + Assert.assertTrue(cSet.contains(Object.class),"Should have type Object"); + Assert.assertFalse(cSet.contains(A.class),"Should not have type A"); + Assert.assertEquals(3,cSet.size()); + } + + public void testRespondsTo() { + Object obj = new TestObject(); + Assert.assertTrue(DynamicUtil.respondsTo(obj,"action:java.lang.String")); + Assert.assertFalse(DynamicUtil.respondsTo(obj,"action")); + Assert.assertFalse(DynamicUtil.respondsTo(obj,"action:boolean")); + Assert.assertTrue(DynamicUtil.respondsTo(obj,"equals:java.lang.Object")); + } + + public void testHasPrimitiveTypeEquivalent() { + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Boolean.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Integer.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Long.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Short.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Byte.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Double.class)); + Assert.assertTrue(DynamicUtil.hasPrimitiveTypeEquivalent(Character.class)); + Assert.assertFalse(DynamicUtil.hasPrimitiveTypeEquivalent(String.class)); + } + + public void testGetMethodForSelectorObjectString() { + Method m = null; + Object obj = new TestObject(); + + m = DynamicUtil.getMethodForSelector(obj,"action:java.lang.String"); + Assert.assertNotNull(m); + + m = DynamicUtil.getMethodForSelector(obj,"action:boolean"); + Assert.assertNull(m); + + // force a test of getMethodForSelector(Object,String) with a class + m = DynamicUtil.getMethodForSelector((Object)obj.getClass(),"action:java.lang.String"); + // force a test of getMethodForSelector(Class,String) + m = DynamicUtil.getMethodForSelector((Class) obj.getClass(), + "action:java.lang.String"); + Assert.assertNotNull(m); + + } + + @SuppressWarnings("unchecked") + public void testConstructWithClass() { + ArrayList al = DynamicUtil.construct(ArrayList.class); + Assert.assertNotNull(al); + Assert.assertEquals(ArrayList.class,al.getClass()); + } + @SuppressWarnings("unchecked") + public void testConstructWithString() { + ArrayList al = (ArrayList)DynamicUtil.construct("java.util.ArrayList"); + Assert.assertNotNull(al); + Assert.assertEquals(ArrayList.class,al.getClass()); + } + + public void testGetMethodForSelectorClassString() { + Object obj = new TestObject(); + Assert.assertNotNull(DynamicUtil.getMethodForSelector(obj.getClass(),"action:java.lang.String")); + } + + public interface IA {} + public interface IB {} + public interface IC extends IA {} + + public class A implements IA {} + public class B extends A implements IB {} + public class C implements IC {} + + public class TestObject { + public void action(String s) {} + } + +} diff --git a/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java new file mode 100644 index 0000000..94c9edb --- /dev/null +++ b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2003-2009 Israfil Consulting Services Corporation + * Copyright (c) 2003-2009 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: DynamicallyAccessibleTest.java 130 2006-12-31 23:22:17Z cgruber $ + */ +package net.israfil.foundation.dynamic; + +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + + + +/** + * + * @author Christian Edward Gruber + * @author Latest: $Author: cgruber $ + * @version $Revision: 130 $ + */ +@Test +public class DynamicallyAccessibleTest { + + TestAccessibleObject testDBO; + String var1 = "value1"; + String var1Name = "publicVariable"; + String var2 = "value2"; + String var2Name = "publicVariableWithAccessor"; + String var3 = "value3"; + String var3Name = "privateVariable"; + boolean var4 = false; + String var4Name = "booleanVariable"; + int var5 = 5; + String var5Name = "intVariable"; + boolean var6 = true; + String var6Name = "isTrue"; + + @BeforeMethod + protected void setUp() { + testDBO = new TestAccessibleObject(var1,var2,var3,var4,var5,var6); + } + + @AfterMethod + protected void tearDown() throws Exception { + testDBO = null; + } + + public void testHasAccessor() { + Assert.assertFalse(testDBO.hasAccessor(var1Name)); + Assert.assertTrue(testDBO.hasAccessor(var2Name)); + Assert.assertTrue(testDBO.hasAccessor(var3Name)); + Assert.assertTrue(testDBO.hasAccessor(var4Name)); + Assert.assertTrue(testDBO.hasAccessor(var5Name)); + } + + public void testHasAttribute() { + Assert.assertTrue(testDBO.hasAttribute("publicVariable")); + Assert.assertTrue(testDBO.hasAttribute("publicVariableWithAccessor")); + Assert.assertTrue(testDBO.hasAttribute("privateVariable")); + Assert.assertTrue(testDBO.hasAttribute("booleanVariable")); + Assert.assertFalse(testDBO.hasAttribute("oddlyNamedIntVariable")); + Assert.assertTrue(testDBO.hasAttribute("aFinalStaticString")); + } + + public void testGet() { + Assert.assertEquals(var1,testDBO.get(var1Name)); + Assert.assertEquals(var2,testDBO.get(var2Name)); + Assert.assertEquals(var3,testDBO.get(var3Name)); + Assert.assertEquals(var4,testDBO.get(var4Name)); + Assert.assertEquals(var5,testDBO.get(var5Name)); + Assert.assertEquals(var6,testDBO.get(var6Name)); + } + + public void testHasAccessorStatic() { + Assert.assertFalse(DynamicallyAccessibleObject.hasAccessor(testDBO,var1Name)); + Assert.assertTrue(DynamicallyAccessibleObject.hasAccessor(testDBO,var2Name)); + Assert.assertTrue(DynamicallyAccessibleObject.hasAccessor(testDBO,var3Name)); + Assert.assertTrue(DynamicallyAccessibleObject.hasAccessor(testDBO,var4Name)); + Assert.assertTrue(DynamicallyAccessibleObject.hasAccessor(testDBO,var5Name)); + } + + public void testHasAttributeStatic() { + Assert.assertTrue(DynamicallyAccessibleObject.hasAttribute(testDBO,"publicVariable")); + Assert.assertTrue(DynamicallyAccessibleObject.hasAttribute(testDBO,"publicVariableWithAccessor")); + Assert.assertTrue(DynamicallyAccessibleObject.hasAttribute(testDBO,"privateVariable")); + Assert.assertTrue(DynamicallyAccessibleObject.hasAttribute(testDBO,"booleanVariable")); + Assert.assertFalse(DynamicallyAccessibleObject.hasAttribute(testDBO,"oddlyNamedIntVariable")); + Assert.assertTrue(DynamicallyAccessibleObject.hasAttribute(testDBO,"aFinalStaticString")); + } + + public void testGetStatic() { + Assert.assertEquals(var1,DynamicallyAccessibleObject.get(testDBO,var1Name)); + Assert.assertEquals(var2,DynamicallyAccessibleObject.get(testDBO,var2Name)); + Assert.assertEquals(var3,DynamicallyAccessibleObject.get(testDBO,var3Name)); + Assert.assertEquals(new Boolean(var4),DynamicallyAccessibleObject.get(testDBO,var4Name)); + Assert.assertEquals(new Integer(var5),DynamicallyAccessibleObject.get(testDBO,var5Name)); + } + + @Test(expectedExceptions={RuntimeException.class}) + public void testGetWithNoFieldOrAccessor() { + testDBO.get("nonExistantVariable"); + } + + + public static class TestAccessibleObject extends DynamicallyAccessibleObject { + + public String publicVariable; + public String publicVariableWithAccessor; + private String privateVariable; + private boolean booleanVariable; + private int oddlyNamedIntVariable; + public static final String aFinalStaticString = "foo"; + private boolean isTrue; + + public TestAccessibleObject() {} + + public TestAccessibleObject(String publicVar, + String publicVarWithAcc, + String privateVar, + boolean booleanVar, + int intVar, + boolean isTrue) { + this.publicVariable = publicVar; + this.publicVariableWithAccessor = publicVarWithAcc; + this.privateVariable = privateVar; + this.booleanVariable = booleanVar; + this.oddlyNamedIntVariable = intVar; + this.isTrue = isTrue; + } + + @Override + public void finalize() throws Throwable { + publicVariable = null; + publicVariableWithAccessor = null; + privateVariable = null; + super.finalize(); + } + public String getPublicVariableWithAccessor() + { return publicVariableWithAccessor;} + + public String getPrivateVariable() { return privateVariable; } + public boolean getBooleanVariable() { return booleanVariable; } + public int getIntVariable() { return oddlyNamedIntVariable; } + public boolean isTrue() { return isTrue; } + } +} diff --git a/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java new file mode 100644 index 0000000..9bc9103 --- /dev/null +++ b/israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java @@ -0,0 +1,210 @@ +/* + * Copyright © 2003-2009 Israfil Consulting Services Corporation + * Copyright © 2003-2009 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: DynamicallyMutableTest.java 130 2006-12-31 23:22:17Z cgruber $ + */ +package net.israfil.foundation.dynamic; + +import net.israfil.foundation.core.Strings; + +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + + + +/** + * + * @author Christian Edward Gruber + * @author Latest: $Author: cgruber $ + * @version $Revision: 130 $ + */ +@Test +public class DynamicallyMutableTest { + + MutableTestObject testMO; + String var1 = "value1"; + String var1Name = "publicVariable"; + String var2 = "value2"; + String var2Name = "publicVariableWithAccessor"; + String var3 = "value3"; + String var3Name = "privateVariable"; + Boolean var4 = false; + String var4Name = "booleanVariable"; + Integer var5 = 5; + String var5Name = "intVariable"; + boolean var6 = true; + String var6Name = "primitiveBoolean"; + int var7 = 9; + String var7Name = "primitiveInt"; + + MutableTestObject2 mto2; + + + @BeforeMethod + protected void setUp() throws Exception { + testMO = new MutableTestObject(); + mto2 = new MutableTestObject2(); + } + + @AfterMethod + protected void tearDown() throws Exception { + testMO = null; + mto2 = null; + } + + public void testHasMutator() { + Assert.assertFalse(testMO.hasMutator(var1Name,var1.getClass())); + Assert.assertTrue(testMO.hasMutator(var2Name,var2.getClass())); + Assert.assertTrue(testMO.hasMutator(var3Name,var3.getClass())); + Assert.assertTrue(testMO.hasMutator(var4Name,var4.getClass())); + Assert.assertTrue(testMO.hasMutator(var5Name,var5.getClass())); + Assert.assertTrue(testMO.hasMutator(var6Name,boolean.class)); + Assert.assertTrue(testMO.hasMutator(var7Name,int.class)); + + } + + public void testSet() { + testMO.set(var1Name,var1); + testMO.set(var2Name,var2); + testMO.set(var3Name,var3); + testMO.set(var4Name,var4); + testMO.set(var5Name,var5); + testMO.set(var6Name,var6); + testMO.set(var7Name,var7); + Assert.assertEquals(var1,testMO.get(var1Name)); + Assert.assertEquals(var2,testMO.get(var2Name)); + Assert.assertEquals(var3,testMO.get(var3Name)); + Assert.assertEquals(var4,testMO.get(var4Name)); + Assert.assertEquals(var5,testMO.get(var5Name)); + } + + @Test(expectedExceptions={RuntimeException.class}) + public void testSetWithNoFieldOrAccessor() { + testMO.set("nonExistantVariable","aString"); + } + + public void testCamel() { + Assert.assertEquals("BlahFoo",Strings.camel("blahFoo")); + Assert.assertEquals("FooBar",Strings.camel("FooBar")); + } + + @Test(expectedExceptions={IllegalArgumentException.class}) + public void testSetWithNullAndNoParameterSetMethod() { + mto2.set("a",null); + } + + @Test(expectedExceptions={IllegalArgumentException.class}) + public void testSetWithNullWithTooManySetMethods() { + mto2.set("b",null); + } + + @Test(expectedExceptions={IllegalArgumentException.class}) + public void testSetWithNullAndSolitarySinglePrimitiveParameter() { + mto2.set("c",null); + } + + public void testSetWithNullAndSolitarySingleNonPrimitiveParameter() { + mto2.set("d",null); + Assert.assertTrue(mto2.d_String_WasTouched); + } + + public void testSetNullWithTypeAndSolitarySingleNonPrimitiveParameter() { + mto2.setNull("b",Integer.class); + Assert.assertTrue(mto2.b_Integer_WasTouched); + mto2.setNull("b",String.class); + Assert.assertTrue(mto2.b_String_WasTouched); + } + + @Test(expectedExceptions={IllegalArgumentException.class}) + public void testSetNullWithTypeAndSolitarySinglePrimitiveParameter() { + mto2.setNull("b",boolean.class); + } + + public class MutableTestObject2 extends DynamicallyMutableObject { + + public boolean a_WasTouched = false; + public boolean b_Integer_WasTouched = false; + public boolean b_String_WasTouched = false; + public boolean b_boolean_WasTouched = false; + public boolean c_boolean_WasTouched = false; + public boolean d_String_WasTouched = false; + + public boolean c; + + public void setA() {a_WasTouched = true;} + + public void setB(String s) {b_String_WasTouched = true;} + public void setB(Integer i) {b_Integer_WasTouched = true;} + public void setB(boolean b) {b_boolean_WasTouched = true;} + + public void setC(boolean b) {c_boolean_WasTouched = true;} + + public void setD(String s) {d_String_WasTouched = true;} + + } + + public class MutableTestObject extends DynamicallyMutableObject { + + public String publicVariable; + public String publicVariableWithAccessor; + private String privateVariable; + private boolean booleanVariable; + private int oddlyNamedIntVariable; + + public MutableTestObject() { + } + + @Override + public void finalize() throws Throwable { + publicVariable = null; + publicVariableWithAccessor = null; + privateVariable = null; + super.finalize(); + } + + public void setPublicVariableWithAccessor(String s) + { publicVariableWithAccessor = s; } + + public void setPrivateVariable(String s) { privateVariable = s; } + public String getPrivateVariable() { return privateVariable; } + + public void setBooleanVariable(Boolean b) { booleanVariable = b; } + public boolean getBooleanVariable() { return booleanVariable; } + + public void setIntVariable(Integer i) { oddlyNamedIntVariable = i; } + public Integer getIntVariable() { return oddlyNamedIntVariable; } + + public void setPrimitiveInt(int i) {} + public void setPrimitiveBoolean(boolean b) {} + } +} -- cgit v1.2.3