diff options
Diffstat (limited to 'java/sdo-cts/sdo2.1/src/main/java/test/sdo21/tests/api/DataObject/DataObjectConsistencyBase.java')
| -rw-r--r-- | java/sdo-cts/sdo2.1/src/main/java/test/sdo21/tests/api/DataObject/DataObjectConsistencyBase.java | 739 |
1 files changed, 0 insertions, 739 deletions
diff --git a/java/sdo-cts/sdo2.1/src/main/java/test/sdo21/tests/api/DataObject/DataObjectConsistencyBase.java b/java/sdo-cts/sdo2.1/src/main/java/test/sdo21/tests/api/DataObject/DataObjectConsistencyBase.java deleted file mode 100644 index 0654a7dc99..0000000000 --- a/java/sdo-cts/sdo2.1/src/main/java/test/sdo21/tests/api/DataObject/DataObjectConsistencyBase.java +++ /dev/null @@ -1,739 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * - * $Rev$ $Date$ - */ -package test.sdo21.tests.api.DataObject; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -import java.util.ArrayList; -import java.util.List; - -import org.junit.Test; - -import test.sdo21.tests.TestData.StandardFactory; -import test.sdo21.tests.api.CTSConsistencyBase; - -import commonj.sdo.DataObject; -import commonj.sdo.Property; -import commonj.sdo.Sequence; -import commonj.sdo.Type; -import commonj.sdo.helper.DataFactory; - -/** - * Tests for proper updates to DataObject and their value changes due to the - * updates. - */ -public abstract class DataObjectConsistencyBase extends CTSConsistencyBase { - - - /** - * testActiveUpdatingList verifies that updates made to a List returned from - * a DataObject are reflected in the DataObject and vice versa. - * @throws Exception - */ - @Test - public void testActiveUpdatingList() throws Exception { - DataObject root = factory.createTestData(getScope(), StandardFactory.API_TYPE); - DataObject child1 = factory.createTestData(getScope(), StandardFactory.API_TYPE); - DataObject child2 = factory.createTestData(getScope(), StandardFactory.API_TYPE); - DataObject child3 = factory.createTestData(getScope(), StandardFactory.API_TYPE); - - List addList = new ArrayList(); - List returnedList; - - addList.add(child1); - - root.setList("containMany", addList); - - // Verify the pre-condition. The List initially has a size of 1. - assertEquals("The List returned by getList was not of the expected size.", 1, root.getList("containMany").size()); - - returnedList = root.getList("containMany"); - - /** - * Add a member to the returned List and verify that it is reflected in - * the DataObject. - */ - - returnedList.add(child2); - - assertEquals("Update to returned List did not affect DataObject correctly. Size of children is not 2", - 2, root.getList("containMany").size()); - assertEquals("Update to returned List did not affect DataObject correctly. child1's container is not equal to root", - root, child1.getContainer()); - assertEquals("Update to returned List did not affect DataObject correctly. child2's container is not equal to root", - root, child2.getContainer()); - - /** - * Delete a child and verify that the returned List is automatically - * affected. - */ - - child1.delete(); - assertEquals("Deleting a DataObject did not affect the returned List.", 1, returnedList.size()); - - /** - * Verify that the DataObject delete did not affect the original List - * used in the DataObject.setList(). - */ - - assertEquals("Deleting a DataObject should not affect a List unassociated with the DataObject.", - 1, - addList.size()); - - /** - * Call DataObject.setList() and verify that the previously returned - * List reflects the new List. - */ - - addList.add(child2); - addList.add(child3); - root.setList("containMany", addList); - - assertEquals("The List returned by DataObject.getList() was not affected by a subsequent DataObject.setList().", - 3, - returnedList.size()); - /** - * Call List.remove() on the returned List and verify that the - * DataObject is affected. - */ - - DataObject child = (DataObject)returnedList.get(1); - - // Verify the precondition. The child should have root as its container. - assertEquals("List.setList() did not cause the expected containment relationship.", root, child.getContainer()); - - returnedList.remove(1); - - assertEquals("List.remove() did not have the expected effect on the DataObject. There are more than 2 children", - 2, root.getList("containMany").size()); - assertNull("List.remove() did not have the expected effect on the DataObject. child container is not null", - child.getContainer()); - - /** - * Call List.clear() and veirfy that the DataObject is affected. - */ - returnedList.clear(); - - assertEquals("List.clear() on the returned List did not have the expected effect on the DataObject. The size of the list of children is not 0", - 0,root.getList("containMany").size()); - assertNull("List.clear() on the returned List did not have the expected effect on the DataObject. child1.getContainer is not null", - child1.getContainer()); - assertNull("List.clear() on the returned List did not have the expected effect on the DataObject. child2.getContainer is not null", - child2.getContainer()); - - } - - /** - * testActiveUpdatingSequence verifies that updates made to a Sequence - * returned from a DataObject are reflected in the DataObject and vice - * versa. - * @throws Exception - */ - @Test - public void testActiveUpdatingSequence() throws Exception { - - DataObject sequenceDO = factory.createTestData(getScope(), StandardFactory.SEQ_TYPE); - Sequence sequence = sequenceDO.getSequence(); - List letterList = sequenceDO.getList("Letters"); - List numberList = sequenceDO.getList("Numbers"); - - assertTrue("The Type of sequencedElem is not sequenced. testActiveUpdatingSequence may not proceed", - sequenceDO.getType().isSequenced()); - - letterList.clear(); - numberList.clear(); - - // Verify the precondition. The Sequence should be empty. - assertEquals("The Sequence should initially be empty.", 0, sequence.size()); - - /** - * Add values to the DataObject and verify that the Sequence is - * affected. - */ - - letterList.add("A"); - letterList.add("B"); - numberList.add(Integer.valueOf(8)); - - // The expected arrangement of sequence is as follows - // {<Letters, "A">, <Letters, "B">, <Numbers, 8>} - - assertEquals("Adding values to the DataObject did not affect the returned Sequence. Sequence size is not 3", - 3, sequence.size()); - assertEquals("Adding values to the DataObject did not affect the returned Sequence. getValue[0] is not A", - "A", sequence.getValue(0)); - assertEquals("Adding values to the DataObject did not affect the returned Sequence. getValue[1] is not B", - "B", sequence.getValue(1) - ); - assertEquals("Adding values to the DataObject did not affect the returned Sequence. getValue[2] is not equal to 8", - sequence.getValue(2), - Integer.valueOf(8)); - - /** - * Remove a value from the DataObject and verify that the Sequence is - * affected. - */ - - letterList.remove(1); - - // The expected arrangement of sequence is as follows: {<Letters, "A">, - // <Numbers, 8>} - assertEquals("Removing a value from the DataObject did not affect the returned Sequence.", sequence.size(), 2); - assertEquals("Removing a value from the DataObject did not affect the returned Sequence.", - "A", sequence.getValue(0) - ); - assertEquals("Removing a value from the DataObject did not affect the returned Sequence.", - Integer.valueOf(8), - sequence.getValue(1)); - - /** - * Remove a value from the Sequence and verify that the DataObject is - * affected. - */ - - sequence.remove(1); - - // The expected arrangement of sequence is as follows: {<Letters, "A">} - - assertEquals("Removing a value from the Sequence did not affect the DataObject. Size of List for numbers is not 0", - 0, sequenceDO.getList("Numbers").size()); - - /** - * Add a value to the Sequence and verify that the DataObject is - * affected. - */ - sequence.add("Numbers", Integer.valueOf(16)); - - // The expected arrangement of sequence is as follows: {<Letters, "A">, - // <Numbers, 16>} - - assertEquals("Adding a value to the Sequence did not have the expected effect on the DataObject.", sequenceDO - .getList("Numbers").size(), 1); - assertEquals("Adding a value to the Sequence did not have the expected effect on the DataObject.", sequenceDO - .getList("Numbers").get(0), Integer.valueOf(16)); - - // Add several values to the Sequence (via the DataObject) to make - // Sequence.move() meaningful. - - letterList.add("C"); - numberList.add(Integer.valueOf(15)); - numberList.add(Integer.valueOf(4)); - letterList.add("K"); - letterList.add("M"); - numberList.add(Integer.valueOf(-10)); - - // The expected arrangement of sequence is as follows - // {<Letters, "A">, <Numbers, 16>, <Letters, "C">, <Numbers, 15>, - // <Numbers, 4>, <Letters, "K">, <Letters, "M">, <Numbers, -10>} - - /** - * Use Sequence.move() and verify that the changes are reflected in the - * DataObject. - */ - - sequence.move(1, 5); - sequence.move(4, 2); - - // The expected arrangement of sequence is as follows - // {<Letters, "A">, <Letters, "K">, <Letters, "C">, <Numbers, 15>, - // <Numbers, 16>, <Numbers, 4>, <Letters, "M">, <Numbers, -10>} - - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - 4, - letterList.size()); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - "A", - letterList.get(0)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - "K", - letterList.get(1)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - "C", - letterList.get(2)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - "M", - letterList.get(3)); - - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - 4, - numberList.size()); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - Integer.valueOf(15), - numberList.get(0)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - Integer.valueOf(16), - numberList.get(1)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - Integer.valueOf(4), - numberList.get(2)); - assertEquals("Sequence.move() did not have the expected effect on the DataObject represented by the Sequence.", - Integer.valueOf(-10), - numberList.get(3)); - - // TODO: Add a value to a specific location within the Sequence and - // veirfy the effect on the DataObject. Awaiting Tuscany-931 - } - - /** - * Verfies that the Property being tested throughout these tests is a - * contaiment Property - */ - @Test - public void verifyIsContainment() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - assertTrue("Property.isContainment() returned an unexpected value.", containmentProp.isContainment()); - } - - /** - * Verifies that the initial state after clearContainer is a state in which - * the DataObject does not have a container. - */ - @Test - public void verifyNullContainer() { - assertNull("DataObject.getContainer() returned an unexpected value.", testDO.getContainer()); - } - - /** - * Verfiies that the containerless DataObject returns null for - * getContainmentProperty - */ - @Test - public void verifyNullContainmentProperty() { - assertNull("DataObject.getContainmentProprety() returned an unexpected value.", testDO.getContainmentProperty()); - } - - /** - * Assign both dataObj1 and dataObj2 to testDO container, then verify - * DataObject.getContainer() for dataObj1 and dataObj2 - */ - @Test - public void verifyGetContainer() { - List addList = new ArrayList(); - Type type = testDO.getType(); - Property containmentProp = testDO.getInstanceProperty("containMany"); - - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // Ensure that any previous containment relationships are broken. - - addList.clear(); - testDO.setList("containMany", addList); - testDO.detach(); - addList.clear(); - - addList.add(dataObj1); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - // Verify containment of dataObj1 and dataObj2 by testDO - - assertEquals("DataObject.getContainer() did not return the appropriate DataObject.", testDO, dataObj1 - .getContainer()); - - assertEquals("DataObject.getContainer() did not return the appropriate DataObject.", testDO, dataObj2 - .getContainer()); - } - - /** - * Assign both dataObj1 and dataObj2 to testDO container, then verify - * DataObject.getContainmentProperty for dataObj1 and dataObj2 - */ - @Test - public void verifyGetContainmentProperty() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - addList.add(dataObj1); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - assertEquals("DataObject.getContainmentProperty() did not return the appropriate Property.", - containmentProp, - dataObj1.getContainmentProperty()); - - assertEquals("DataObject.getContainmentProperty() did not return the appropriate Property.", - containmentProp, - dataObj2.getContainmentProperty()); - } - - /** - * Assign both dataObj1 and dataObj2 to testDO container, then verify the - * contents of the containing property in testDO - */ - @Test - public void verifyContainmentContents() { - assertNull("testDO container != null", testDO.getContainer()); - assertEquals("testDO.containMany != 0", 0, testDO.getList("containMany").size()); - - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - addList.add(dataObj1); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - List returnedList = testDO.getList(containmentProp); - - assertEquals("DataObject.getList() size is incorrect", 2, returnedList.size()); - assertEquals("DataObject.getList() did not return the List specified in DataObject.setList()", - dataObj1, - returnedList.get(0)); - assertEquals("DataObject.getList() did not return the List specified in DataObject.setList()", - dataObj2, - returnedList.get(1)); - } - - /** - * Assign both dataObj1 and dataObj2 to testDO container, then Assign - * dataObj2 to dataObj1 container. Verify dataObj2 is automatically removed - * from testDO container - */ - @Test - public void verifyAutomaticRemoval() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - addList.add(dataObj1); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - // Verify the precondition - - assertEquals("DataObject.getContainer() did not return the appropriate DataObject.", testDO, dataObj1 - .getContainer()); - - assertEquals("DataObject.getContainer() did not return the appropriate DataObject.", testDO, dataObj2 - .getContainer()); - - // After the following section, it should be true that: testDO contains - // dataObj1 contains dataObj2 - - addList.clear(); - addList.add(dataObj2); - dataObj1.setList(containmentProp, addList); - - // Verify automatic removal of dataObj2 from testDO container - - List returnedList = testDO.getList(containmentProp); - assertEquals("Once placed in a new container, the DataObject should no longer appear in the former container.", - 1, - returnedList.size()); - assertEquals("Once placed in a new container, the DataObject should no longer appear in the former container.", - dataObj1, - returnedList.get(0)); - } - - /** - * Assign both dataObj1 and dataObj2 to testDO container, then Assign - * dataObj2 to dataObj1 container. Verify dataObj2 is contained by dataObj1 - */ - @Test - public void verifyNewContainer() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - addList.add(dataObj1); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - // After the following section, it should be true that: testDO contains - // dataObj1 contains dataObj2 - - addList.clear(); - addList.add(dataObj2); - dataObj1.setList(containmentProp, addList); - - // Verify that dataObj2 was correctly added to dataObj1 container - - List returnedList = dataObj1.getList(containmentProp); - assertEquals("Once assigned to a new container, the DataObject should appear in the new container.", - 1, - returnedList.size()); - assertEquals("Once assigned to a new container, the DataObject should appear in the new container.", - dataObj2, - returnedList.get(0)); - assertEquals("DataObject.getContainer() did not return the appropriate DataObject.", dataObj1, dataObj2 - .getContainer()); - } - - /** - * Verify that detach() removes the object from its container. - */ - @Test - public void verifyDetachRemoval() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - addList.clear(); - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - - testDO.detach(); - - List returnedList = dataObj1.getList(containmentProp); - assertEquals("Detaching the contained object did not remove it from container", 0, returnedList.size()); - - assertNull("DataObject.getContainer() did not return null as expected for a detached DataObject.", testDO - .getContainer()); - } - - /** - * Verify that DataObject.detach() does not affect objects contained by the - * detached DataObject - */ - @Test - public void verifyDetachContainer() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.detach(); - - List returnedList = testDO.getList(containmentProp); - - assertEquals("Detaching a DataObject should not detach its contained DataObjects.", 1, returnedList.size()); - assertEquals("Detaching a DataObject should not affect it as a container.", dataObj2, returnedList.get(0)); - } - - /** - * Verify that DataObject.detach() does not affect objects contained by the - * detached DataObject - */ - @Test - public void verifyDetachContainedDOs() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.detach(); - - assertEquals("Detaching a DataObject should not affect contained DataObjects.", testDO, dataObj2.getContainer()); - } - - /** - * Verify that DataObject.delete() removes the object from its container. - */ - @Test - public void verifyDeleteRemoval() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.delete(); - - assertEquals("Deleting the DataObject did not remove it from its container.", 0, dataObj1 - .getList(containmentProp).size()); - } - - /** - * Verify that DataObject.delete() removes the containment reflected by the - * deleted DataObject - */ - @Test - public void verifyDeleteResultsOnDeleted() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.delete(); - - assertNotNull("A deleted DataObject should remain programatically accessible.", testDO); - assertNull("Deleting the DataObject did not affect its view of its container.", testDO.getContainer()); - } - - /** - * Verify that DataObject.delete() removes its contents as a container. - */ - @Test - public void verifyDeleteAsContainer() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.delete(); - - assertNotNull("A deleted DataObject should remain programatically accessible.", testDO); - assertEquals("Deleting the DataObject did not empty it as a container.", 0, testDO.getList(containmentProp) - .size()); - } - - /** - * Verify that DataObject.delete() affects contained DataObjects. - */ - @Test - public void verifyDeleteAffectOnContained() { - Property containmentProp = testDO.getInstanceProperty("containMany"); - List addList = new ArrayList(); - Type type = testDO.getType(); - DataObject dataObj1 = getScope().getDataFactory().create(type); - DataObject dataObj2 = getScope().getDataFactory().create(type); - - // After the following section, it should be true that: dataObj1 - // contains testDO contains dataObj2 - - addList.add(testDO); - dataObj1.setList(containmentProp, addList); - addList.clear(); - addList.add(dataObj2); - testDO.setList(containmentProp, addList); - - testDO.delete(); - - assertNull("Deleting the containing DataObject was not reflected in the contained DataObject.", dataObj2 - .getContainer()); - } - - /** - * testRecursiveDeletion verifies that when a DataObject is deleted, all - * (recursively) contained DataObjects are also deleted. - */ - @Test - public void testRecursiveDeletion() { - Type type = testDO.getType(); - Property containmentProp = type.getProperty("containMany"); - - assertTrue("Cannot continue with test because Property.isContainment() is false.", containmentProp - .isContainment()); - - DataFactory df = getScope().getDataFactory(); - DataObject child1 = df.create(type); - DataObject child2 = df.create(type); - DataObject child3 = df.create(type); - - List addList = new ArrayList(); - - /** - * Establish a series of containment relationships - */ - - addList.add(child1); - testDO.setList(containmentProp, addList); - - addList.clear(); - addList.add(child2); - child1.setList(containmentProp, addList); - - addList.clear(); - addList.add(child3); - child2.setList(containmentProp, addList); - - /** - * Verify that containment has been established correctly. - */ - - assertEquals("The expected containment relationships were not correctly formed.", child3.getContainer(), child2); - assertEquals("The expected containment relationships were not correctly formed.", child2.getContainer(), child1); - assertEquals("The expected containment relationships were not correctly formed.", child1.getContainer(), testDO); - - /** - * Delete the root DataObject and verify that contained DataObjects are - * recursively affected. - */ - - testDO.delete(); - - assertEquals("DataObject.delete() did not recursively affect contained DataObjects.", testDO - .getList(containmentProp).size(), 0); - assertNull("DataObject.delete() did not recursively affect contained DataObjects.", child1.getContainer()); - assertNull("DataObject.delete() did not recursively affect contained DataObjects.", child2.getContainer()); - assertNull("DataObject.delete() did not recursively affect contained DataObjects.", child3.getContainer()); - - } -} |