| /******************************************************************************* |
| * Copyright (c) 2003, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.wst.common.frameworks.datamodel.tests; |
| |
| import java.util.Collection; |
| |
| import junit.framework.Assert; |
| import junit.framework.TestCase; |
| |
| import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory; |
| import org.eclipse.wst.common.frameworks.datamodel.IDataModel; |
| import org.eclipse.wst.common.frameworks.internal.WTPResourceHandler; |
| |
| /** |
| * @author jsholl |
| * |
| * TODO To change the template for this generated type comment go to Window - Preferences - Java - |
| * Code Style - Code Templates |
| */ |
| public class NestingTest extends TestCase { |
| |
| private IDataModel a; |
| private IDataModel b; |
| private IDataModel c; |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| a = DataModelFactory.createDataModel(new A()); |
| b = DataModelFactory.createDataModel(new B()); |
| c = DataModelFactory.createDataModel(new C()); |
| } |
| |
| protected void tearDown() throws Exception { |
| if (null != a) { |
| a.dispose(); |
| a = null; |
| } |
| if (null != b) { |
| b.dispose(); |
| b = null; |
| } |
| |
| if (null != c) { |
| c.dispose(); |
| c = null; |
| } |
| } |
| |
| public void testInvalidNestedModel() { |
| String NESTED_MODEL_NOT_LOCATED = WTPResourceHandler.getString("21"); //$NON-NLS-1$ |
| Exception ex = null; |
| try { |
| a.getNestedModel("foo"); |
| } catch (RuntimeException e) { |
| ex = e; |
| } |
| Assert.assertNotNull(ex); |
| Assert.assertTrue(ex.getMessage().startsWith(NESTED_MODEL_NOT_LOCATED)); |
| ex = null; |
| try { |
| a.getNestedModel(null); |
| } catch (RuntimeException e) { |
| ex = e; |
| } |
| Assert.assertNotNull(ex); |
| Assert.assertTrue(ex.getMessage().startsWith(NESTED_MODEL_NOT_LOCATED)); |
| |
| a.addNestedModel("b", b); |
| ex = null; |
| try { |
| a.getNestedModel(null); |
| } catch (RuntimeException e) { |
| ex = e; |
| } |
| Assert.assertNotNull(ex); |
| Assert.assertTrue(ex.getMessage().startsWith(NESTED_MODEL_NOT_LOCATED)); |
| |
| } |
| |
| public void testIsNestedModel() { |
| Assert.assertFalse(a.isNestedModel("")); |
| Assert.assertFalse(a.isNestedModel(null)); |
| a.addNestedModel("b", b); |
| Assert.assertTrue(a.isNestedModel("b")); |
| Assert.assertFalse(a.isNestedModel("c")); |
| a.addNestedModel("c", c); |
| Assert.assertTrue(a.isNestedModel("c")); |
| } |
| |
| public void testRemoveNonExistentModels() { |
| Assert.assertNull(a.removeNestedModel("a")); |
| Assert.assertNull(a.removeNestedModel(null)); |
| } |
| |
| public void testGetNestedAndGetNesting() { |
| Assert.assertEquals(0, a.getNestedModels().size()); |
| Assert.assertEquals(0, b.getNestingModels().size()); |
| |
| Assert.assertTrue(a.addNestedModel("b", b)); |
| Assert.assertEquals(1, a.getNestedModels().size()); |
| Assert.assertTrue(a.getNestedModels().contains(b)); |
| Assert.assertEquals(b, a.getNestedModel("b")); |
| Assert.assertEquals(1, b.getNestingModels().size()); |
| Assert.assertTrue(b.getNestingModels().contains(a)); |
| |
| Assert.assertTrue(a.addNestedModel("c", c)); |
| Assert.assertEquals(2, a.getNestedModels().size()); |
| Assert.assertTrue(a.getNestedModels().contains(c)); |
| Assert.assertEquals(c, a.getNestedModel("c")); |
| Assert.assertEquals(1, c.getNestingModels().size()); |
| Assert.assertTrue(c.getNestingModels().contains(a)); |
| |
| Assert.assertTrue(b.addNestedModel("c", c)); |
| Assert.assertEquals(1, b.getNestedModels().size()); |
| Assert.assertTrue(b.getNestedModels().contains(c)); |
| Assert.assertEquals(2, c.getNestingModels().size()); |
| Assert.assertTrue(c.getNestingModels().contains(b)); |
| |
| Assert.assertEquals(b, a.removeNestedModel("b")); |
| Assert.assertEquals(1, a.getNestedModels().size()); |
| Assert.assertEquals(0, b.getNestingModels().size()); |
| |
| Assert.assertEquals(c, a.removeNestedModel("c")); |
| Assert.assertEquals(0, a.getNestedModels().size()); |
| Assert.assertEquals(1, c.getNestingModels().size()); |
| Assert.assertTrue(c.getNestingModels().contains(b)); |
| |
| Assert.assertEquals(c, b.removeNestedModel("c")); |
| Assert.assertEquals(0, b.getNestedModels().size()); |
| Assert.assertEquals(0, c.getNestingModels().size()); |
| } |
| |
| public void testSelfNest() { |
| Assert.assertFalse(a.addNestedModel("a", a)); |
| Assert.assertEquals(0, a.getNestedModels().size()); |
| } |
| |
| public void testDuplicateNest() { |
| Assert.assertTrue(a.addNestedModel("b1", b)); |
| Assert.assertEquals(b, a.getNestedModel("b1")); |
| Assert.assertFalse(a.addNestedModel("b2", b)); |
| Assert.assertEquals(b, a.getNestedModel("b1")); |
| Assert.assertFalse(a.isNestedModel("b2")); |
| } |
| |
| |
| /** |
| * <code> |
| * 1 2 3 4 5 6 |
| * A | A | A | A | A | A |
| * B | | B | B | B | B |
| * C | | C |
| * </code> |
| */ |
| public void testIsPropertySimpleNesting0() { |
| a.addNestedModel("b", b); // 1 |
| Assert.assertFalse(a.isBaseProperty(B.P)); |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isNestedProperty(B.P)); |
| |
| a.removeNestedModel("b"); // 2 |
| Assert.assertFalse(a.isBaseProperty(B.P)); |
| Assert.assertFalse(a.isProperty(B.P)); |
| Assert.assertFalse(a.isNestedProperty(B.P)); |
| |
| a.addNestedModel("b", b); // 3 |
| Assert.assertFalse(a.isBaseProperty(B.P)); |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isNestedProperty(B.P)); |
| |
| b.addNestedModel("c", c); // 4 |
| Assert.assertFalse(a.isBaseProperty(C.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertTrue(a.isNestedProperty(C.P)); |
| |
| b.removeNestedModel("c"); // 5 |
| Assert.assertFalse(a.isBaseProperty(C.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| Assert.assertFalse(a.isNestedProperty(C.P)); |
| |
| b.addNestedModel("c", c); // 6 |
| Assert.assertFalse(a.isBaseProperty(C.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertTrue(a.isNestedProperty(C.P)); |
| } |
| |
| /** |
| * <code> |
| * 1 2 3 4 |
| * A | A | A | A |
| * B | B | B | |
| * C | | |
| * </code> |
| */ |
| public void testIsPropertySimpleNesting1() { |
| a.addNestedModel("b", b); // 1 |
| Assert.assertFalse(a.isBaseProperty(B.P)); |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isNestedProperty(B.P)); |
| // check a's nested |
| Assert.assertTrue(b == a.getNestedModel("b")); |
| Collection nestedModelNames = a.getNestedModelNames(); |
| Assert.assertEquals(1, nestedModelNames.size()); |
| Assert.assertTrue(nestedModelNames.contains("b")); |
| Collection baseProperties = a.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(A.P)); |
| Collection nestedProperties = a.getNestedProperties(); |
| Assert.assertEquals(3, nestedProperties.size()); |
| Assert.assertTrue(nestedProperties.contains(B.P)); |
| Collection allProperties = a.getAllProperties(); |
| Assert.assertEquals(4, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(A.P)); |
| Assert.assertTrue(allProperties.contains(B.P)); |
| |
| |
| b.addNestedModel("c", c); // 2 |
| Assert.assertFalse(a.isBaseProperty(C.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertTrue(a.isNestedProperty(C.P)); |
| Assert.assertFalse(b.isBaseProperty(C.P)); |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertTrue(b.isNestedProperty(C.P)); |
| // check a's nested |
| Assert.assertTrue(b == a.getNestedModel("b")); |
| nestedModelNames = a.getNestedModelNames(); |
| Assert.assertEquals(1, nestedModelNames.size()); |
| Assert.assertTrue(nestedModelNames.contains("b")); |
| baseProperties = a.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(A.P)); |
| nestedProperties = a.getNestedProperties(); |
| Assert.assertEquals(4, nestedProperties.size()); |
| Assert.assertTrue(nestedProperties.contains(B.P)); |
| Assert.assertTrue(nestedProperties.contains(C.P)); |
| allProperties = a.getAllProperties(); |
| Assert.assertEquals(5, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(A.P)); |
| Assert.assertTrue(allProperties.contains(B.P)); |
| Assert.assertTrue(allProperties.contains(C.P)); |
| // check b's nested |
| Assert.assertTrue(c == b.getNestedModel("c")); |
| nestedModelNames = b.getNestedModelNames(); |
| Assert.assertEquals(1, nestedModelNames.size()); |
| Assert.assertTrue(nestedModelNames.contains("c")); |
| baseProperties = b.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(B.P)); |
| nestedProperties = b.getNestedProperties(); |
| Assert.assertEquals(3, nestedProperties.size()); |
| Assert.assertTrue(nestedProperties.contains(C.P)); |
| allProperties = b.getAllProperties(); |
| Assert.assertEquals(4, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(B.P)); |
| Assert.assertTrue(allProperties.contains(C.P)); |
| |
| b.removeNestedModel("c"); // 3 |
| Assert.assertFalse(a.isBaseProperty(C.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| Assert.assertFalse(a.isNestedProperty(C.P)); |
| Assert.assertFalse(b.isBaseProperty(C.P)); |
| Assert.assertFalse(b.isProperty(C.P)); |
| Assert.assertFalse(b.isNestedProperty(C.P)); |
| // check a's nested |
| Assert.assertTrue(b == a.getNestedModel("b")); |
| nestedModelNames = a.getNestedModelNames(); |
| Assert.assertEquals(1, nestedModelNames.size()); |
| Assert.assertTrue(nestedModelNames.contains("b")); |
| baseProperties = a.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(A.P)); |
| nestedProperties = a.getNestedProperties(); |
| Assert.assertEquals(3, nestedProperties.size()); |
| Assert.assertTrue(nestedProperties.contains(B.P)); |
| allProperties = a.getAllProperties(); |
| Assert.assertEquals(4, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(A.P)); |
| Assert.assertTrue(allProperties.contains(B.P)); |
| // check b's nested |
| nestedModelNames = b.getNestedModelNames(); |
| Assert.assertEquals(0, nestedModelNames.size()); |
| baseProperties = b.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(B.P)); |
| nestedProperties = b.getNestedProperties(); |
| Assert.assertEquals(2, nestedProperties.size()); |
| allProperties = b.getAllProperties(); |
| Assert.assertEquals(3, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(B.P)); |
| |
| a.removeNestedModel("b"); // 4 |
| Assert.assertFalse(a.isBaseProperty(B.P)); |
| Assert.assertFalse(a.isProperty(B.P)); |
| Assert.assertFalse(a.isNestedProperty(B.P)); |
| // check a's nested |
| nestedModelNames = a.getNestedModelNames(); |
| Assert.assertEquals(0, nestedModelNames.size()); |
| baseProperties = a.getBaseProperties(); |
| Assert.assertEquals(3, baseProperties.size()); |
| Assert.assertTrue(baseProperties.contains(A.P)); |
| nestedProperties = a.getNestedProperties(); |
| Assert.assertEquals(2, nestedProperties.size()); |
| allProperties = a.getAllProperties(); |
| Assert.assertEquals(3, allProperties.size()); |
| Assert.assertTrue(allProperties.contains(A.P)); |
| } |
| |
| /** |
| * <code> |
| * 1 2 3 4 |
| * A | A | A | A |
| * | B | | |
| * B | C | B | B |
| * C | | C | |
| * | | C |
| * </code> |
| */ |
| public void testIsPropertySimpleNesting2() { |
| b.addNestedModel("c", c); // 1 |
| Assert.assertTrue(b.isProperty(C.P)); |
| |
| a.addNestedModel("b", b); // 2 |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| |
| a.removeNestedModel("b"); // 3 |
| Assert.assertFalse(a.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| |
| b.removeNestedModel("c"); // 4 |
| Assert.assertFalse(b.isProperty(C.P)); |
| } |
| |
| /** |
| * <code> |
| * 1 2 3 4 5 |
| * A | A | A | A | A |
| * B | B | B | B | B |
| * C | C | C | |
| * | C2 | |
| * </code> |
| */ |
| public void testIsPropertyComplexNesting1() { |
| a.addNestedModel("b", b); // 1 |
| b.addNestedModel("c", c); // 2 |
| Assert.assertTrue(a.isProperty(C.P)); |
| IDataModel c2 = DataModelFactory.createDataModel(new C()); |
| b.addNestedModel("c2", c2); // 3 |
| b.removeNestedModel("c2"); // 4 |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| b.removeNestedModel("c"); // 5 |
| Assert.assertFalse(b.isProperty(C.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| } |
| |
| /** |
| * <code> |
| * 1 2 3 4 5 6 7 |
| * A | A | A | A | A | A | A |
| * B | B | B | B | B | B | B |
| * C | C | C | C | C2 | |
| * C2 | C2 | |
| * </code> |
| */ |
| public void testIsPropertyComplexNesting2() { |
| a.addNestedModel("b", b); // 1 |
| b.addNestedModel("c", c); // 2 |
| Assert.assertTrue(a.isProperty(C.P)); |
| IDataModel c2 = DataModelFactory.createDataModel(new C()); |
| a.addNestedModel("c2", c2); // 3 |
| a.removeNestedModel("c2"); // 4 |
| Assert.assertTrue(a.isProperty(C.P)); |
| b.addNestedModel("c2", c2); // 5 |
| Assert.assertTrue(a.isProperty(C.P)); |
| b.removeNestedModel("c"); // 6 |
| Assert.assertTrue(a.isProperty(C.P)); |
| b.removeNestedModel("c2"); // 7 |
| Assert.assertFalse(a.isProperty(C.P)); |
| } |
| |
| /** |
| * <code> |
| * 1 2 3 4 5 6 |
| * A | A | B | A | C | A |
| * B | B | C | B | A | B |
| * C | C | A | C | B | C |
| * A (loop) | | A(loop) |
| * </code> |
| */ |
| public void testIsPropertyComplexNesting3() { |
| a.addNestedModel("b", b); |
| b.addNestedModel("c", c); // 1 |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertFalse(b.isProperty(A.P)); |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertFalse(c.isProperty(A.P)); |
| Assert.assertFalse(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| c.addNestedModel("a", a); // 2 |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertTrue(b.isProperty(A.P)); |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertTrue(c.isProperty(A.P)); |
| Assert.assertTrue(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| a.removeNestedModel("b"); // 3 |
| Assert.assertFalse(a.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| Assert.assertTrue(b.isProperty(A.P)); |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertTrue(c.isProperty(A.P)); |
| Assert.assertFalse(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| a.addNestedModel("b", b); // 4 |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertTrue(a.isProperty(C.P)); |
| Assert.assertTrue(b.isProperty(A.P)); |
| Assert.assertTrue(b.isProperty(C.P)); |
| Assert.assertTrue(c.isProperty(A.P)); |
| Assert.assertTrue(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| b.removeNestedModel("c"); // 5 |
| Assert.assertTrue(a.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| Assert.assertFalse(b.isProperty(A.P)); |
| Assert.assertFalse(b.isProperty(C.P)); |
| Assert.assertTrue(c.isProperty(A.P)); |
| Assert.assertTrue(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| c.removeNestedModel("a"); |
| a.removeNestedModel("b"); |
| Assert.assertFalse(a.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty(C.P)); |
| Assert.assertFalse(b.isProperty(A.P)); |
| Assert.assertFalse(b.isProperty(C.P)); |
| Assert.assertFalse(c.isProperty(A.P)); |
| Assert.assertFalse(c.isProperty(B.P)); |
| Assert.assertFalse(a.isProperty("foo")); |
| Assert.assertFalse(b.isProperty("foo")); |
| Assert.assertFalse(c.isProperty("foo")); |
| } |
| |
| public void testSetGetProperty1() { |
| // cylical |
| a.addNestedModel("b", b); |
| b.addNestedModel("c", c); |
| c.addNestedModel("a", a); |
| |
| a.setProperty(A.P, "a"); |
| a.setProperty(B.P, "b"); |
| a.setProperty(C.P, "c"); |
| assertEquals("a", a.getProperty(A.P)); |
| assertEquals("a", b.getProperty(A.P)); |
| assertEquals("a", c.getProperty(A.P)); |
| assertEquals("b", a.getProperty(B.P)); |
| assertEquals("b", b.getProperty(B.P)); |
| assertEquals("b", c.getProperty(B.P)); |
| assertEquals("c", a.getProperty(C.P)); |
| assertEquals("c", b.getProperty(C.P)); |
| assertEquals("c", c.getProperty(C.P)); |
| |
| b.setProperty(A.P, "aa"); |
| b.setProperty(B.P, "bb"); |
| b.setProperty(C.P, "cc"); |
| assertEquals("aa", a.getProperty(A.P)); |
| assertEquals("aa", b.getProperty(A.P)); |
| assertEquals("aa", c.getProperty(A.P)); |
| assertEquals("bb", a.getProperty(B.P)); |
| assertEquals("bb", b.getProperty(B.P)); |
| assertEquals("bb", c.getProperty(B.P)); |
| assertEquals("cc", a.getProperty(C.P)); |
| assertEquals("cc", b.getProperty(C.P)); |
| assertEquals("cc", c.getProperty(C.P)); |
| |
| c.setProperty(A.P, "aaa"); |
| c.setProperty(B.P, "bbb"); |
| c.setProperty(C.P, "ccc"); |
| assertEquals("aaa", a.getProperty(A.P)); |
| assertEquals("aaa", b.getProperty(A.P)); |
| assertEquals("aaa", c.getProperty(A.P)); |
| assertEquals("bbb", a.getProperty(B.P)); |
| assertEquals("bbb", b.getProperty(B.P)); |
| assertEquals("bbb", c.getProperty(B.P)); |
| assertEquals("ccc", a.getProperty(C.P)); |
| assertEquals("ccc", b.getProperty(C.P)); |
| assertEquals("ccc", c.getProperty(C.P)); |
| } |
| |
| |
| } |