From 7c279747beb43c7e88633a6228a155a30e6834f7 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 27 May 2024 11:38:33 -0400 Subject: Initial import --- .../dynamic/DynamicallyAccessibleTest.java | 174 +++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java (limited to 'israfil-foundation-dynamic/src/test/java/net/israfil/foundation/dynamic/DynamicallyAccessibleTest.java') 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; } + } +} -- cgit v1.2.3