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/DynamicallyMutableTest.java | 210 +++++++++++++++++++++ 1 file changed, 210 insertions(+) create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java (limited to 'israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyMutableTest.java') 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