Modified: xmlbeans/trunk/src/test/java/compile/scomp/som/checkin/PartialSOMCheckinTest.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/compile/scomp/som/checkin/PartialSOMCheckinTest.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/compile/scomp/som/checkin/PartialSOMCheckinTest.java (original) +++ xmlbeans/trunk/src/test/java/compile/scomp/som/checkin/PartialSOMCheckinTest.java Sun Feb 6 01:51:55 2022 @@ -20,19 +20,19 @@ import org.apache.xmlbeans.SchemaTypeSys import org.apache.xmlbeans.XmlBeans; import org.apache.xmlbeans.XmlError; import org.apache.xmlbeans.XmlOptions; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.ArrayList; import java.util.Date; import java.util.List; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; public class PartialSOMCheckinTest extends SomTestBase { - @Before + @BeforeEach public void setUp() { // initialize the built in schema type builtin = XmlBeans.getBuiltinTypeSystem(); @@ -57,13 +57,13 @@ public class PartialSOMCheckinTest exten } - @After + @AfterEach public void tearDown() { errors.clear(); } @Test - public void testAddAttributeAndElements() throws Exception { + void testAddAttributeAndElements() throws Exception { System.out.println("Inside test case testAddAttributeAndElements()"); // Step 1 : create a Schema Type System with the base 'bad' xsd and create the Schema Type System (STS) for it @@ -73,36 +73,29 @@ public class PartialSOMCheckinTest exten "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", - baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // the tests - Walk thro the SOM, save, validate against an xml instance inspectSOM(baseSTS, 1, 1, 1, 0); // test for recoverable errors - assertTrue("No Recovered Errors for Invalid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid Schema"); // Test for saving of the PSOM - should not be able to save - assertFalse("Partial SOM " + baseSTS.getName() + "Save successful - should fail!", - checkPSOMSave(baseSTS)); + assertFalse(checkPSOMSave(baseSTS), "Partial SOM " + baseSTS.getName() + "Save successful - should fail!"); // instance validation - should fail List<XmlError> errList = new ArrayList<>(); - assertFalse("Validation against instance Success - should fail ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS, errList)); + assertFalse(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS, errList), "Validation against instance Success - should fail "); assertEquals(3, errList.size()); assertTrue(errList.get(0).toString().contains("instance_elemattr_valid.xml:20:36: error: cvc-complex-type.3.2.1: Attribute not allowed (no wildcards allowed): testAttributeComplex in element TestRoot")); // additional validation - assertFalse("Attribute found but not expected - 'testAttributeComplex'", - lookForAttributeInSTS(baseSTS, - "testAttributeComplex")); - assertFalse("Element found but not expected 'ComplexTypeElem'", - lookForElemInSTS(baseSTS, - "ComplexTypeElem")); - assertFalse("Element found but not expected 'SimpleTypeElem'", - lookForElemInSTS(baseSTS, "SimpleTypeElem")); + assertFalse(lookForAttributeInSTS(baseSTS, + "testAttributeComplex"), "Attribute found but not expected - 'testAttributeComplex'"); + assertFalse(lookForElemInSTS(baseSTS, + "ComplexTypeElem"), "Element found but not expected 'ComplexTypeElem'"); + assertFalse(lookForElemInSTS(baseSTS, "SimpleTypeElem"), "Element found but not expected 'SimpleTypeElem'"); // Step 2: create a Schema Type System with the new xsd file that has additions to this schema @@ -111,30 +104,24 @@ public class PartialSOMCheckinTest exten "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", - modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // test the PSOM created : walk thro the PSOM, look for # of elements,attributes,types & attribute groups inspectSOM(modifiedSTS, 3, 2, 1, 0); // Test for successful saving of the PSOM - assertTrue("Valid Partial SOM " + modifiedSTS.getName() + "Save failed", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "Valid Partial SOM " + modifiedSTS.getName() + "Save failed"); // Look for added attribute(s)/Element(s) by name in the STS - assertTrue("Attribute expected, not found 'testAttributeComplex'", - lookForAttributeInSTS(modifiedSTS, - "testAttributeComplex")); - assertTrue("Element expected, not found 'ComplexTypeElem'", - lookForElemInSTS(modifiedSTS, - "ComplexTypeElem")); - assertTrue("Element expected, not found 'SimpleTypeElem'", - lookForElemInSTS(modifiedSTS, - "SimpleTypeElem")); + assertTrue(lookForAttributeInSTS(modifiedSTS, + "testAttributeComplex"), "Attribute expected, not found 'testAttributeComplex'"); + assertTrue(lookForElemInSTS(modifiedSTS, + "ComplexTypeElem"), "Element expected, not found 'ComplexTypeElem'"); + assertTrue(lookForElemInSTS(modifiedSTS, + "SimpleTypeElem"), "Element expected, not found 'SimpleTypeElem'"); // validate against an xml instance - assertTrue("Validation against instance failed ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS), "Validation against instance failed "); // Step 3: now creat the Schema Type System with the original XSD again SchemaTypeSystem finalSTS = createNewSTS("elemattr.xsd_", @@ -142,23 +129,21 @@ public class PartialSOMCheckinTest exten "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); //walk the SOM inspectSOM(finalSTS, 1, 1, 1, 0); // Test for saving of the PSOM - should not be able to save - assertFalse("Partial SOM " + finalSTS.getName() + "Save successful - should fail!", - checkPSOMSave(finalSTS)); + assertFalse(checkPSOMSave(finalSTS), "Partial SOM " + finalSTS.getName() + "Save successful - should fail!"); // instance validation - should fail - assertFalse("Validation against instance Success - should fail ", - validateInstance(getTestCaseFile("instance_elemattr.xml"), finalSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_elemattr.xml"), finalSTS), "Validation against instance Success - should fail "); } @Test - public void testModifyAttributeAndElements() throws Exception { + void testModifyAttributeAndElements() throws Exception { System.out.println("Inside test case testModifyAttributeAndElements()"); // Step 1 : create a Schema Type System with the base 'good' xsd and create the Schema Type System (STS) for it @@ -168,18 +153,16 @@ public class PartialSOMCheckinTest exten "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // the tests - Walk thro the SOM, save, validate against an xml instance inspectSOM(baseSTS, 3, 2, 1, 0); // validate successful save - assertTrue("Valid SOM " + baseSTS.getName() + "Save failed ", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "Valid SOM " + baseSTS.getName() + "Save failed "); // validate against instance successfully - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS), "Validation against instance Failed "); // Step 2: create a Schema Type System with the new xsd file with modifications to existing schema SchemaTypeSystem modifiedSTS = createNewSTS("elemattr_modified.xsd_", @@ -187,30 +170,24 @@ public class PartialSOMCheckinTest exten "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // test for recoverable errors - assertTrue("No Recovered Errors for Invalid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid Schema"); // test the PSOM created inspectSOM(modifiedSTS, 2, 2, 1, 0); // walk thro the PSOM, look for # of elements,attributes,types & attribute groups // Look for a modified attribute(s)/elements by name in the STS - assertTrue("Attribute expected, not found 'testAttributeComplex'", - lookForAttributeInSTS(modifiedSTS, "testAttributeComplex")); - assertTrue("Element expected, not found 'ComplexTypeElem'", - lookForElemInSTS(modifiedSTS, "ComplexTypeElem")); - assertFalse("Element expected, not found 'SimpleTypeElem'", - lookForElemInSTS(modifiedSTS, "SimpleTypeElem")); + assertTrue(lookForAttributeInSTS(modifiedSTS, "testAttributeComplex"), "Attribute expected, not found 'testAttributeComplex'"); + assertTrue(lookForElemInSTS(modifiedSTS, "ComplexTypeElem"), "Element expected, not found 'ComplexTypeElem'"); + assertFalse(lookForElemInSTS(modifiedSTS, "SimpleTypeElem"), "Element expected, not found 'SimpleTypeElem'"); // Test for saving of the PSOM - should not be able to save - assertFalse("Partial SOM " + modifiedSTS.getName() + " Save successful- should fail", - checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "Partial SOM " + modifiedSTS.getName() + " Save successful- should fail"); // validate against an xml instance - should fail - assertFalse("Validation against instance Success - should Fail", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS), "Validation against instance Success - should Fail"); // Step 3: now creat the Schema Type System with the original XSD again SchemaTypeSystem finalSTS = createNewSTS("elemattr_added.xsd_", @@ -218,25 +195,23 @@ public class PartialSOMCheckinTest exten "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // walk the PSOM inspectSOM(finalSTS, 3, 2, 1, 0); // should be able to save as its a valid SOM - assertTrue("Partial SOM " + finalSTS.getName() + "Save failed for complete SOM", - checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "Partial SOM " + finalSTS.getName() + "Save failed for complete SOM"); // validate against instance successfully - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), finalSTS), "Validation against instance Failed "); // compare this to the original schema here - the root dir names used to save the PSOMs are the same as the STS names assertTrue(compareSavedSOMs("BaseSchemaTS", "FinalSchemaTS")); } @Test - public void testDeleteAttributeAndElements() throws Exception { + void testDeleteAttributeAndElements() throws Exception { System.out.println("Inside test case testDeleteAttributeAndElements()"); // Step 1 : create a Schema Type System with the base 'good' xsd and create the Schema Type System (STS) for it @@ -246,18 +221,16 @@ public class PartialSOMCheckinTest exten "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // the tests - Walk thro the SOM, save, validate against an xml instance inspectSOM(baseSTS, 3, 2, 1, 0); // validate successful save - assertTrue("Valid SOM " + baseSTS.getName() + "Save failed ", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "Valid SOM " + baseSTS.getName() + "Save failed "); // validate against instance successfully - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), baseSTS), "Validation against instance Failed "); // Step 2: create a Schema Type System with the new xsd file that has deletions SchemaTypeSystem modifiedSTS = createNewSTS("elemattr.xsd_", @@ -265,30 +238,24 @@ public class PartialSOMCheckinTest exten "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // test for recoverable errors - assertTrue("No Recovered Errors for Invalid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid Schema"); // test the PSOM created inspectSOM(modifiedSTS, 1, 1, 1, 0); // walk thro the PSOM, look for # of elements,attributes,types & attribute groups // Test for saving of the PSOM - should not be able to save - assertFalse("Invalid PSOM " + modifiedSTS.getName() + " Save successful - Should fail", - checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "Invalid PSOM " + modifiedSTS.getName() + " Save successful - Should fail"); // verify types - assertFalse("Attribute found but not expected - 'testAttributeComplex'", - lookForAttributeInSTS(modifiedSTS, "testAttributeComplex")); - assertFalse("Element found but not expected 'ComplexTypeElem'", - lookForElemInSTS(modifiedSTS, "ComplexTypeElem")); - assertFalse("Element found but not expected 'SimpleTypeElem'", - lookForElemInSTS(modifiedSTS, "SimpleTypeElem")); + assertFalse(lookForAttributeInSTS(modifiedSTS, "testAttributeComplex"), "Attribute found but not expected - 'testAttributeComplex'"); + assertFalse(lookForElemInSTS(modifiedSTS, "ComplexTypeElem"), "Element found but not expected 'ComplexTypeElem'"); + assertFalse(lookForElemInSTS(modifiedSTS, "SimpleTypeElem"), "Element found but not expected 'SimpleTypeElem'"); // validate against an xml instance - should fail - assertFalse("Validation against success - should Fail ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), modifiedSTS), "Validation against success - should Fail "); // Step 3: now creat the Schema Type System with the original XSD again SchemaTypeSystem finalSTS = createNewSTS("elemattr_added.xsd_", @@ -296,18 +263,16 @@ public class PartialSOMCheckinTest exten "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // walk the SOM inspectSOM(finalSTS, 3, 2, 1, 0); // should be able to save as its a valid SOM - assertTrue("Partial SOM " + finalSTS.getName() + "Save failed for complete SOM", - checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "Partial SOM " + finalSTS.getName() + "Save failed for complete SOM"); // validate against instance - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_elemattr_valid.xml"), finalSTS), "Validation against instance Failed "); // compare this to the original schema here assertTrue(compareSavedSOMs("BaseSchemaTS", "FinalSchemaTS")); @@ -315,7 +280,7 @@ public class PartialSOMCheckinTest exten } @Test - public void testAddDataTypes() throws Exception { + void testAddDataTypes() throws Exception { System.out.println("Inside test case testAddDataTypes()"); // Step 1 : create a PSOM from an incomplete/invalid xsd (datatypes.xsd) with unresolved references to various types String sBaseSourceName = "testsourcename"; @@ -324,104 +289,63 @@ public class PartialSOMCheckinTest exten "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // recovearble errors should exist - assertTrue("No Recovered Errors for Invalid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid Schema"); // Walk thro the SOM (pass #Elems, #Attr, #Types, #AttrGroups) inspectSOM(baseSTS, 12, 1, 4, 1); // Test for saving of the PSOM - should not be able to save - assertFalse("Partial SOM " + baseSTS.getName() + "Save successful - should fail!", - checkPSOMSave(baseSTS)); + assertFalse(checkPSOMSave(baseSTS), "Partial SOM " + baseSTS.getName() + "Save successful - should fail!"); // instance validation - should fail - assertFalse("Validation against instance Success - should fail ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS), "Validation against instance Success - should fail "); // additional validation - check to see if the unresolved references to types are 'anyType' // validate unresolved types - assertEquals("Unresolved Simple Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testAtomicTypeElem")); - assertEquals("Unresolved Simple Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testUnionTypeElem")); + assertEquals(anyType, getElementType(baseSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'anyType'"); // moved to detailed PSOMDetailedTest class //Assert.assertEquals("Unresolved List Type should be 'anySimpleType'", anySimpleType, getElementType(baseSTS, "testListTypeElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testComplexTypeSimpleContentElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testComplexTypeElementOnlyContentElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testComplexTypeMixedElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testComplexTypeEmptyElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testChoiceGroupElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(baseSTS, "testAllGroupElem")); + assertEquals(anyType, getElementType(baseSTS, "testComplexTypeSimpleContentElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testComplexTypeElementOnlyContentElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testComplexTypeMixedElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testComplexTypeEmptyElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testChoiceGroupElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "testAllGroupElem"), "Unresolved Complex Type should be 'anyType'"); // Step 2 : create an incremental PSOM that is valid by loading datatypes_added.xsd SchemaTypeSystem modifiedSTS = createNewSTS("datatypes_added.xsd_", baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // no errors expected to be recovered - should be a valid SOM - assertFalse("Valid Schema Type System, Errors recovered", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Valid Schema Type System, Errors recovered"); // test the PSOM created : walk thro the PSOM, look for # of elements,attributes,types & attribute groups inspectSOM(modifiedSTS, 13, 1, 15, 1); // test successful save - assertTrue("Valid SOM " + modifiedSTS.getName() + " Save failed", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "Valid SOM " + modifiedSTS.getName() + " Save failed"); // validate against an xml valid instance - should succeed - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS), "Validation against instance Failed "); // validate against an xml invalid instance - should fail - assertFalse("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_simple_types_invalid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_simple_types_invalid.xml"), modifiedSTS), "Validation against instance Failed "); // additional validation - check to see if all types are resolved to their respective types - assertEquals("Unresolved Simple Type should be 'attachmentTypes'", - "attachmentTypes", - getElementType(modifiedSTS, "testAtomicTypeElem")); - assertEquals("Unresolved Simple Type should be 'union.attachmentUnionType'", - "union.attachmentUnionType", - getElementType(modifiedSTS, "testUnionTypeElem")); - assertEquals("Unresolved List Type should be 'attchmentExtensionListTypes'", - "attchmentExtensionListTypes", - getElementType(modifiedSTS, "testListTypeElem")); - assertEquals("Unresolved Complex Type should be 'headerType'", - "headerType", - getElementType(modifiedSTS, "testComplexTypeSimpleContentElem")); - assertEquals("Unresolved Complex Type should be 'mailsType'", - "mailsType", - getElementType(modifiedSTS, "testComplexTypeElementOnlyContentElem")); - assertEquals("Unresolved Complex Type should be 'mixedContentType'", - "mixedContentType", - getElementType(modifiedSTS, "testComplexTypeMixedElem")); - assertEquals("Unresolved Complex Type should be 'emptyContentType'", - "emptyContentType", - getElementType(modifiedSTS, "testComplexTypeEmptyElem")); - assertEquals("Unresolved Complex Type should be 'choiceGroupType'", - "choiceGroupType", - getElementType(modifiedSTS, "testChoiceGroupElem")); - assertEquals("Unresolved Complex Type should be 'allGroupType'", - "allGroupType", - getElementType(modifiedSTS, "testAllGroupElem")); + assertEquals("attachmentTypes", getElementType(modifiedSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'attachmentTypes'"); + assertEquals("union.attachmentUnionType", getElementType(modifiedSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'union.attachmentUnionType'"); + assertEquals("attchmentExtensionListTypes", getElementType(modifiedSTS, "testListTypeElem"), "Unresolved List Type should be 'attchmentExtensionListTypes'"); + assertEquals("headerType", getElementType(modifiedSTS, "testComplexTypeSimpleContentElem"), "Unresolved Complex Type should be 'headerType'"); + assertEquals("mailsType", getElementType(modifiedSTS, "testComplexTypeElementOnlyContentElem"), "Unresolved Complex Type should be 'mailsType'"); + assertEquals("mixedContentType", getElementType(modifiedSTS, "testComplexTypeMixedElem"), "Unresolved Complex Type should be 'mixedContentType'"); + assertEquals("emptyContentType", getElementType(modifiedSTS, "testComplexTypeEmptyElem"), "Unresolved Complex Type should be 'emptyContentType'"); + assertEquals("choiceGroupType", getElementType(modifiedSTS, "testChoiceGroupElem"), "Unresolved Complex Type should be 'choiceGroupType'"); + assertEquals("allGroupType", getElementType(modifiedSTS, "testAllGroupElem"), "Unresolved Complex Type should be 'allGroupType'"); // Step 3 : create an incremental STS with the file in step 1 @@ -430,23 +354,21 @@ public class PartialSOMCheckinTest exten "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // test the PSOM created : walk thro the PSOM, look for # of elements,attributes,types & attribute groups inspectSOM(finalSTS, 12, 1, 4, 1); // test save failure - assertFalse("Partial SOM " + finalSTS.getName() + "Save Success ", - checkPSOMSave(finalSTS)); + assertFalse(checkPSOMSave(finalSTS), "Partial SOM " + finalSTS.getName() + "Save Success "); // instance validation - should fail - assertFalse("Validation against instance Success - should fail ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS), "Validation against instance Success - should fail "); } @Test - public void testDeleteDataTypes() throws Exception { + void testDeleteDataTypes() throws Exception { System.out.println("Inside test case testDeleteDataTypes()"); // Step 1: read a clean XSD file to get a valid SOM @@ -456,50 +378,30 @@ public class PartialSOMCheckinTest exten "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the SOM, save, validate against an xml instance inspectSOM(baseSTS, 13, 1, 15, 1); // Recovered Errors, Test for saving of the PSOM - should go thro - assertTrue("SOM " + baseSTS.getName() + "Save failed!", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS), "Validation against instance failed"); // additional validation - check to see if all types are resolved to their respective types - assertEquals("Unresolved Simple Type should be 'attachmentTypes'", - "attachmentTypes", - getElementType(baseSTS, "testAtomicTypeElem")); - assertEquals("Unresolved Simple Type should be 'union.attachmentUnionType'", - "union.attachmentUnionType", - getElementType(baseSTS, "testUnionTypeElem")); - assertEquals("Unresolved List Type should be 'attchmentExtensionListTypes'", - "attchmentExtensionListTypes", - getElementType(baseSTS, "testListTypeElem")); - assertEquals("Unresolved Complex Type should be 'headerType'", - "headerType", - getElementType(baseSTS, "testComplexTypeSimpleContentElem")); - assertEquals("Unresolved Complex Type should be 'mailsType'", - "mailsType", - getElementType(baseSTS, "testComplexTypeElementOnlyContentElem")); - assertEquals("Unresolved Complex Type should be 'mixedContentType'", - "mixedContentType", - getElementType(baseSTS, "testComplexTypeMixedElem")); - assertEquals("Unresolved Complex Type should be 'emptyContentType'", - "emptyContentType", - getElementType(baseSTS, "testComplexTypeEmptyElem")); - assertEquals("Unresolved Complex Type should be 'choiceGroupType'", - "choiceGroupType", - getElementType(baseSTS, "testChoiceGroupElem")); - assertEquals("Unresolved Complex Type should be 'allGroupType'", - "allGroupType", - getElementType(baseSTS, "testAllGroupElem")); + assertEquals("attachmentTypes", getElementType(baseSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'attachmentTypes'"); + assertEquals("union.attachmentUnionType", getElementType(baseSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'union.attachmentUnionType'"); + assertEquals("attchmentExtensionListTypes", getElementType(baseSTS, "testListTypeElem"), "Unresolved List Type should be 'attchmentExtensionListTypes'"); + assertEquals("headerType", getElementType(baseSTS, "testComplexTypeSimpleContentElem"), "Unresolved Complex Type should be 'headerType'"); + assertEquals("mailsType", getElementType(baseSTS, "testComplexTypeElementOnlyContentElem"), "Unresolved Complex Type should be 'mailsType'"); + assertEquals("mixedContentType", getElementType(baseSTS, "testComplexTypeMixedElem"), "Unresolved Complex Type should be 'mixedContentType'"); + assertEquals("emptyContentType", getElementType(baseSTS, "testComplexTypeEmptyElem"), "Unresolved Complex Type should be 'emptyContentType'"); + assertEquals("choiceGroupType", getElementType(baseSTS, "testChoiceGroupElem"), "Unresolved Complex Type should be 'choiceGroupType'"); + assertEquals("allGroupType", getElementType(baseSTS, "testAllGroupElem"), "Unresolved Complex Type should be 'allGroupType'"); //Step 2 : delete/remove types from the schema - should result in STS with unresolved refs @@ -507,48 +409,31 @@ public class PartialSOMCheckinTest exten baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // PSOM - recovered errors are expected - assertTrue("Valid Schema Type System, Errors recovered", printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "Valid Schema Type System, Errors recovered"); // test the PSOM created : walk thro the PSOM, look for # of elements,attributes,types & attribute groups inspectSOM(modifiedSTS, 12, 1, 4, 1); // Test for saving of the PSOM - should not be able to save - assertFalse("PSOM " + modifiedSTS.getName() + " Save should fail", - checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "PSOM " + modifiedSTS.getName() + " Save should fail"); // validate unresolved types - assertEquals("Unresolved Simple Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testAtomicTypeElem")); - assertEquals("Unresolved Simple Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testUnionTypeElem")); + assertEquals(anyType, getElementType(modifiedSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'anyType'"); // moved to detailed PSOMDetailedTest class // Assert.assertEquals("Unresolved List Type should be 'anySimpleType'", anySimpleType, getElementType(modifiedSTS, "testListTypeElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testComplexTypeSimpleContentElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testComplexTypeElementOnlyContentElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testComplexTypeMixedElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testComplexTypeEmptyElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testChoiceGroupElem")); - assertEquals("Unresolved Complex Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testAllGroupElem")); + assertEquals(anyType, getElementType(modifiedSTS, "testComplexTypeSimpleContentElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testComplexTypeElementOnlyContentElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testComplexTypeMixedElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testComplexTypeEmptyElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testChoiceGroupElem"), "Unresolved Complex Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "testAllGroupElem"), "Unresolved Complex Type should be 'anyType'"); // validate against an xml valid instance - should fail - assertFalse("Validation against instance should Failed ", validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS), "Validation against instance should Failed "); // Step 3 : reaload the xsd in Step 1 SchemaTypeSystem finalSTS = createNewSTS("datatypes_added.xsd_", @@ -557,55 +442,35 @@ public class PartialSOMCheckinTest exten sBaseSourceName); // should be able to save as its a valid SOM - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // walk the PSOM inspectSOM(finalSTS, 13, 1, 15, 1); // should be able to save as its a valid SOM - assertTrue("SOM " + finalSTS.getName() + "Save failed", - checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "SOM " + finalSTS.getName() + "Save failed"); // instance validation - should be fine - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS), "Validation against instance Failed "); // compare this to the original schema here assertTrue(compareSavedSOMs("BaseSchemaTS", "FinalSchemaTS")); // additional validation - check to see if all types are resolved to their respective types - assertEquals("Unresolved Simple Type should be 'attachmentTypes'", - "attachmentTypes", - getElementType(baseSTS, "testAtomicTypeElem")); - assertEquals("Unresolved Simple Type should be 'union.attachmentUnionType'", - "union.attachmentUnionType", - getElementType(baseSTS, "testUnionTypeElem")); - assertEquals("Unresolved List Type should be 'attchmentExtensionListTypes'", - "attchmentExtensionListTypes", - getElementType(baseSTS, "testListTypeElem")); - assertEquals("Unresolved Complex Type should be 'headerType'", - "headerType", - getElementType(baseSTS, "testComplexTypeSimpleContentElem")); - assertEquals("Unresolved Complex Type should be 'mailsType'", - "mailsType", - getElementType(baseSTS, "testComplexTypeElementOnlyContentElem")); - assertEquals("Unresolved Complex Type should be 'mixedContentType'", - "mixedContentType", - getElementType(baseSTS, "testComplexTypeMixedElem")); - assertEquals("Unresolved Complex Type should be 'emptyContentType'", - "emptyContentType", - getElementType(baseSTS, "testComplexTypeEmptyElem")); - assertEquals("Unresolved Complex Type should be 'choiceGroupType'", - "choiceGroupType", - getElementType(baseSTS, "testChoiceGroupElem")); - assertEquals("Unresolved Complex Type should be 'allGroupType'", - "allGroupType", - getElementType(baseSTS, "testAllGroupElem")); + assertEquals("attachmentTypes", getElementType(baseSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'attachmentTypes'"); + assertEquals("union.attachmentUnionType", getElementType(baseSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'union.attachmentUnionType'"); + assertEquals("attchmentExtensionListTypes", getElementType(baseSTS, "testListTypeElem"), "Unresolved List Type should be 'attchmentExtensionListTypes'"); + assertEquals("headerType", getElementType(baseSTS, "testComplexTypeSimpleContentElem"), "Unresolved Complex Type should be 'headerType'"); + assertEquals("mailsType", getElementType(baseSTS, "testComplexTypeElementOnlyContentElem"), "Unresolved Complex Type should be 'mailsType'"); + assertEquals("mixedContentType", getElementType(baseSTS, "testComplexTypeMixedElem"), "Unresolved Complex Type should be 'mixedContentType'"); + assertEquals("emptyContentType", getElementType(baseSTS, "testComplexTypeEmptyElem"), "Unresolved Complex Type should be 'emptyContentType'"); + assertEquals("choiceGroupType", getElementType(baseSTS, "testChoiceGroupElem"), "Unresolved Complex Type should be 'choiceGroupType'"); + assertEquals("allGroupType", getElementType(baseSTS, "testAllGroupElem"), "Unresolved Complex Type should be 'allGroupType'"); } @Test - public void testModifyDataTypes() throws Exception { + void testModifyDataTypes() throws Exception { System.out.println("Inside test case testModifyDataTypes()"); // Step 1: read in a clean XSD datatypes_added.xsd, to create a base schema with no unresolved components @@ -614,33 +479,24 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 13, 1, 15, 1); // Recovered Errors, Test for saving of the SOM - should go thro - assertTrue("SOM " + baseSTS.getName() + "Save failed!", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), baseSTS), "Validation against instance failed"); // check types before modify - assertEquals("Unresolved Simple Type should be 'attachmentTypes'", - "attachmentTypes", - getElementType(baseSTS, "testAtomicTypeElem")); - assertEquals("Unresolved List Type should be 'attchmentExtensionListTypes'", - "attchmentExtensionListTypes", - getElementType(baseSTS, "testListTypeElem")); - assertEquals("Unresolved Simple Type should be 'union.attachmentUnionType", - "union.attachmentUnionType", - getElementType(baseSTS, "testUnionTypeElem")); + assertEquals("attachmentTypes", getElementType(baseSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'attachmentTypes'"); + assertEquals("attchmentExtensionListTypes", getElementType(baseSTS, "testListTypeElem"), "Unresolved List Type should be 'attchmentExtensionListTypes'"); + assertEquals("union.attachmentUnionType", getElementType(baseSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'union.attachmentUnionType"); //Step 2 : modify types from the schema - should result in STS with unresolved refs @@ -649,63 +505,51 @@ public class PartialSOMCheckinTest exten baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // test the PSOM created :walk thro the PSOM, look for # of elements,attributes,types & attribute groups inspectSOM(modifiedSTS, 13, 1, 13, 1); // Test for saving of the PSOM - should not be able to save - assertFalse("PSOM " + modifiedSTS.getName() + " Save should fail", - checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "PSOM " + modifiedSTS.getName() + " Save should fail"); // validate unresolved types - assertEquals("Unresolved Simple Type - Atomic should be 'anyType'", - anyType, - getElementType(modifiedSTS, "testAtomicTypeElem")); + assertEquals(anyType, getElementType(modifiedSTS, "testAtomicTypeElem"), "Unresolved Simple Type - Atomic should be 'anyType'"); // moved to detailed PSOMDetailedTest class //Assert.assertEquals("Unresolved List Type should be 'anySimpleType'", anySimpleType, getElementType(modifiedSTS, "testListTypeElem")); //Assert.assertEquals("Unresolved Simple Type - Union should be 'anySimpleType'", anySimpleType, getElementType(modifiedSTS, "testUnionTypeElem")); // validate against an xml valid instance - should fail - assertFalse("Validation against instance should Failed ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), modifiedSTS), "Validation against instance should Failed "); // step 3: reload the original STS SchemaTypeSystem finalSTS = createNewSTS("datatypes_added.xsd_", modifiedSTS, "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // walk the SOM inspectSOM(finalSTS, 13, 1, 15, 1); // validate successful save - assertTrue("SOM " + finalSTS.getName() + "Save failed", - checkPSOMSave(finalSTS)); // should be able to save as its a valid SOM + assertTrue(checkPSOMSave(finalSTS), "SOM " + finalSTS.getName() + "Save failed"); // should be able to save as its a valid SOM // validate instance - should validate - assertTrue("Validation against instance Failed ", - validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_datatypes_valid.xml"), finalSTS), "Validation against instance Failed "); // check types after modify - assertEquals("Unresolved Simple Type should be 'attachmentTypes'", - "attachmentTypes", - getElementType(finalSTS, "testAtomicTypeElem")); - assertEquals("Unresolved List Type should be 'attchmentExtensionListTypes'", - "attchmentExtensionListTypes", - getElementType(finalSTS, "testListTypeElem")); - assertEquals("Unresolved Simple Type should be 'union.attachmentUnionType", - "union.attachmentUnionType", - getElementType(finalSTS, "testUnionTypeElem")); + assertEquals("attachmentTypes", getElementType(finalSTS, "testAtomicTypeElem"), "Unresolved Simple Type should be 'attachmentTypes'"); + assertEquals("attchmentExtensionListTypes", getElementType(finalSTS, "testListTypeElem"), "Unresolved List Type should be 'attchmentExtensionListTypes'"); + assertEquals("union.attachmentUnionType", getElementType(finalSTS, "testUnionTypeElem"), "Unresolved Simple Type should be 'union.attachmentUnionType"); // compare this to the original schema here assertTrue(compareSavedSOMs("BaseSchemaTS", "FinalSchemaTS")); } @Test - public void testDeleteDerivedTypes() throws Exception { + void testDeleteDerivedTypes() throws Exception { System.out.println("Inside test case testDeleteDerivedTypes()"); // Step 1: read in a clean XSD derived_types_added.xsd with base and derived types to create a base schema with no unresolved components @@ -714,95 +558,64 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 13, 0, 14, 0); // Recovered Errors, Test for saving of the SOM - should go thro - assertTrue("Valid SOM " + baseSTS.getName() + "Save failed!", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "Valid SOM " + baseSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), baseSTS), "Validation against instance failed"); // check types before deletion of base types - assertEquals("Elem Type should be 'ExtensionBaseType' (base)", - "ExtensionBaseType", - getElementType(baseSTS, "ExtensionBaseTypeElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedComplexContentType", - getElementType(baseSTS, "ExtensionDerivedComplexContentTypeElem")); - - assertEquals("Elem Type should be 'ExtensionBaseMixedContentType' (base)", - "ExtensionBaseMixedContentType", - getElementType(baseSTS, "ExtensionBaseMixedContentTypElem")); - assertEquals("Elem Type should be 'ExtensionDerivedMixedContentType' (derived)", - "ExtensionDerivedMixedContentType", - getElementType(baseSTS, "ExtensionDerivedMixedContentTypeElem")); - - assertEquals("Elem Type should be 'RestrictionSimpleContentBaseType'", - "RestrictionSimpleContentBaseType", getElementType(baseSTS, "RestrictionSimpleContentBaseTypeElem")); - assertEquals("Elem Type should be 'RestrictionSimpleContentDerivedType'", - "RestrictionSimpleContentDerivedType", getElementType(baseSTS, "RestrictionSimpleContentDerivedTypeElem")); - - assertEquals("Elem Type should be 'RestrictionBaseComplexContentType'", - "RestrictionBaseComplexContentType", - getElementType(baseSTS, "RestrictionBaseComplexContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedComplexContentType'", - "RestrictionDerivedComplexContentType", - getElementType(baseSTS, "RestrictionDerivedComplexContentTypeElem")); - - assertEquals("Elem Type should be 'RestrictionBaseMixedContentType'", - "RestrictionBaseMixedContentType", getElementType(baseSTS, "RestrictionBaseMixedContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedMixedContentType'", - "RestrictionDerivedMixedContentType", getElementType(baseSTS, "RestrictionDerivedMixedContentTypeElem")); - - assertEquals("Elem Type should be 'RestrictionBaseEmptyContentType'", - "RestrictionBaseEmptyContentType", getElementType(baseSTS, "RestrictionBaseEmptyContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedEmptyContentType'", - "RestrictionDerivedEmptyContentType", getElementType(baseSTS, "RestrictionDerivedEmptyContentTypeElem")); + assertEquals("ExtensionBaseType", getElementType(baseSTS, "ExtensionBaseTypeElem"), "Elem Type should be 'ExtensionBaseType' (base)"); + assertEquals("ExtensionDerivedComplexContentType", getElementType(baseSTS, "ExtensionDerivedComplexContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); + + assertEquals("ExtensionBaseMixedContentType", getElementType(baseSTS, "ExtensionBaseMixedContentTypElem"), "Elem Type should be 'ExtensionBaseMixedContentType' (base)"); + assertEquals("ExtensionDerivedMixedContentType", getElementType(baseSTS, "ExtensionDerivedMixedContentTypeElem"), "Elem Type should be 'ExtensionDerivedMixedContentType' (derived)"); + + assertEquals("RestrictionSimpleContentBaseType", getElementType(baseSTS, "RestrictionSimpleContentBaseTypeElem"), "Elem Type should be 'RestrictionSimpleContentBaseType'"); + assertEquals("RestrictionSimpleContentDerivedType", getElementType(baseSTS, "RestrictionSimpleContentDerivedTypeElem"), "Elem Type should be 'RestrictionSimpleContentDerivedType'"); + + assertEquals("RestrictionBaseComplexContentType", getElementType(baseSTS, "RestrictionBaseComplexContentTypeElem"), "Elem Type should be 'RestrictionBaseComplexContentType'"); + assertEquals("RestrictionDerivedComplexContentType", getElementType(baseSTS, "RestrictionDerivedComplexContentTypeElem"), "Elem Type should be 'RestrictionDerivedComplexContentType'"); + + assertEquals("RestrictionBaseMixedContentType", getElementType(baseSTS, "RestrictionBaseMixedContentTypeElem"), "Elem Type should be 'RestrictionBaseMixedContentType'"); + assertEquals("RestrictionDerivedMixedContentType", getElementType(baseSTS, "RestrictionDerivedMixedContentTypeElem"), "Elem Type should be 'RestrictionDerivedMixedContentType'"); + + assertEquals("RestrictionBaseEmptyContentType", getElementType(baseSTS, "RestrictionBaseEmptyContentTypeElem"), "Elem Type should be 'RestrictionBaseEmptyContentType'"); + assertEquals("RestrictionDerivedEmptyContentType", getElementType(baseSTS, "RestrictionDerivedEmptyContentTypeElem"), "Elem Type should be 'RestrictionDerivedEmptyContentType'"); // Step 2: create invalid PSOM with base type removed SchemaTypeSystem modifiedSTS = createNewSTS("derived_types.xsd_", baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // recovearble errors - assertTrue("No Recovered Errors for Invalid PSOM", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid PSOM"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 13, 0, 9, 0); // Recovered Errors, Test for saving of the SOM - assertFalse("SOM " + modifiedSTS.getName() + "Save Success - should fail!", checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save Success - should fail!"); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), modifiedSTS), "Validation against instance failed"); // check types - base should be 'anyType' - assertEquals("Elem Type should be 'anyType' (base)", - anyType, - getElementType(modifiedSTS, "ExtensionBaseTypeElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedComplexContentType", - getElementType(modifiedSTS, "ExtensionDerivedComplexContentTypeElem")); - - assertEquals("Elem Type should be 'anyType' (base)", - anyType, - getElementType(modifiedSTS, "ExtensionBaseMixedContentTypElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedMixedContentType", - getElementType(modifiedSTS, "ExtensionDerivedMixedContentTypeElem")); + assertEquals(anyType, getElementType(modifiedSTS, "ExtensionBaseTypeElem"), "Elem Type should be 'anyType' (base)"); + assertEquals("ExtensionDerivedComplexContentType", getElementType(modifiedSTS, "ExtensionDerivedComplexContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); + + assertEquals(anyType, getElementType(modifiedSTS, "ExtensionBaseMixedContentTypElem"), "Elem Type should be 'anyType' (base)"); + assertEquals("ExtensionDerivedMixedContentType", getElementType(modifiedSTS, "ExtensionDerivedMixedContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); // Restriction Simple Content Base type commented does not result in recoverable SOM // moved to Detailed Test @@ -811,28 +624,16 @@ public class PartialSOMCheckinTest exten // getElementType(modifiedSTS, "RestrictionSimpleContentBaseTypeElem")); // - assertEquals("Elem Type should be 'RestrictionSimpleContentDerivedType'", - "RestrictionSimpleContentDerivedType", - getElementType(modifiedSTS, "RestrictionSimpleContentDerivedTypeElem")); - - assertEquals("Elem Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "RestrictionBaseComplexContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedComplexContentType'", - "RestrictionDerivedComplexContentType", - getElementType(modifiedSTS, "RestrictionDerivedComplexContentTypeElem")); - - assertEquals("Elem Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "RestrictionBaseMixedContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedMixedContentType'", - "RestrictionDerivedMixedContentType", - getElementType(modifiedSTS, "RestrictionDerivedMixedContentTypeElem")); - - assertEquals("Elem Type should be 'anyType'", anyType, - getElementType(modifiedSTS, "RestrictionBaseEmptyContentTypeElem")); - assertEquals("Elem Type should be 'RestrictionDerivedEmptyContentType'", - "RestrictionDerivedEmptyContentType", getElementType(modifiedSTS, "RestrictionDerivedEmptyContentTypeElem")); + assertEquals("RestrictionSimpleContentDerivedType", getElementType(modifiedSTS, "RestrictionSimpleContentDerivedTypeElem"), "Elem Type should be 'RestrictionSimpleContentDerivedType'"); + + assertEquals(anyType, getElementType(modifiedSTS, "RestrictionBaseComplexContentTypeElem"), "Elem Type should be 'anyType'"); + assertEquals("RestrictionDerivedComplexContentType", getElementType(modifiedSTS, "RestrictionDerivedComplexContentTypeElem"), "Elem Type should be 'RestrictionDerivedComplexContentType'"); + + assertEquals(anyType, getElementType(modifiedSTS, "RestrictionBaseMixedContentTypeElem"), "Elem Type should be 'anyType'"); + assertEquals("RestrictionDerivedMixedContentType", getElementType(modifiedSTS, "RestrictionDerivedMixedContentTypeElem"), "Elem Type should be 'RestrictionDerivedMixedContentType'"); + + assertEquals(anyType, getElementType(modifiedSTS, "RestrictionBaseEmptyContentTypeElem"), "Elem Type should be 'anyType'"); + assertEquals("RestrictionDerivedEmptyContentType", getElementType(modifiedSTS, "RestrictionDerivedEmptyContentTypeElem"), "Elem Type should be 'RestrictionDerivedEmptyContentType'"); // step 3: reload the original STS @@ -840,29 +641,26 @@ public class PartialSOMCheckinTest exten modifiedSTS, "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(finalSTS, 13, 0, 14, 0); // Recovered Errors, Test for saving of the SOM - should go thro - assertTrue("SOM " + finalSTS.getName() + "Save failed!", - checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "SOM " + finalSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), finalSTS), "Validation against instance failed"); // compare this to the original schema here assertTrue(compareSavedSOMs("BaseSchemaTS", "FinalSchemaTS")); } @Test - public void testAddDerivedTypes() throws Exception { + void testAddDerivedTypes() throws Exception { System.out.println("Inside test case testAddDerivedTypes()"); // Step 1: start with invalid SOM - one that has derived types but the base types are not defined @@ -871,72 +669,50 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); - assertTrue("No Recovered Errors for Invalid PSOM", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for Invalid PSOM"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 13, 0, 9, 0); // Recovered Errors, Test for saving of the SOM - assertFalse("SOM " + baseSTS.getName() + "Save Success - should fail!", - checkPSOMSave(baseSTS)); + assertFalse(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save Success - should fail!"); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), baseSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), baseSTS), "Validation against instance failed"); // check types - base should be 'anyType' - assertEquals("Elem Type should be 'anyType' (base)", - anyType, - getElementType(baseSTS, "ExtensionBaseTypeElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedComplexContentType", - getElementType(baseSTS, "ExtensionDerivedComplexContentTypeElem")); - - assertEquals("Elem Type should be 'anyType' (base)", - anyType, - getElementType(baseSTS, "ExtensionBaseMixedContentTypElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedMixedContentType", - getElementType(baseSTS, "ExtensionDerivedMixedContentTypeElem")); + assertEquals(anyType, getElementType(baseSTS, "ExtensionBaseTypeElem"), "Elem Type should be 'anyType' (base)"); + assertEquals("ExtensionDerivedComplexContentType", getElementType(baseSTS, "ExtensionDerivedComplexContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); + + assertEquals(anyType, getElementType(baseSTS, "ExtensionBaseMixedContentTypElem"), "Elem Type should be 'anyType' (base)"); + assertEquals("ExtensionDerivedMixedContentType", getElementType(baseSTS, "ExtensionDerivedMixedContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); // Step 2: create valid PSOM now from xsd with base types defined SchemaTypeSystem modifiedSTS = createNewSTS("derived_types_added.xsd_", baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 13, 0, 14, 0); // Recovered Errors, Test for saving of the SOM - should go thro - assertTrue("SOM " + modifiedSTS.getName() + "Save failed!", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), modifiedSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_derived_types_valid.xml"), modifiedSTS), "Validation against instance failed"); // check types before deletion of base types - assertEquals("Elem Type should be 'ExtensionBaseType' (base)", - "ExtensionBaseType", - getElementType(modifiedSTS, "ExtensionBaseTypeElem")); - assertEquals("Elem Type should be 'ExtensionDerivedComplexContentType' (derived)", - "ExtensionDerivedComplexContentType", - getElementType(modifiedSTS, "ExtensionDerivedComplexContentTypeElem")); - assertEquals("Elem Type should be 'ExtensionBaseMixedContentType' (base)", - "ExtensionBaseMixedContentType", - getElementType(modifiedSTS, "ExtensionBaseMixedContentTypElem")); - assertEquals("Elem Type should be 'ExtensionDerivedMixedContentType' (derived)", - "ExtensionDerivedMixedContentType", - getElementType(modifiedSTS, "ExtensionDerivedMixedContentTypeElem")); + assertEquals("ExtensionBaseType", getElementType(modifiedSTS, "ExtensionBaseTypeElem"), "Elem Type should be 'ExtensionBaseType' (base)"); + assertEquals("ExtensionDerivedComplexContentType", getElementType(modifiedSTS, "ExtensionDerivedComplexContentTypeElem"), "Elem Type should be 'ExtensionDerivedComplexContentType' (derived)"); + assertEquals("ExtensionBaseMixedContentType", getElementType(modifiedSTS, "ExtensionBaseMixedContentTypElem"), "Elem Type should be 'ExtensionBaseMixedContentType' (base)"); + assertEquals("ExtensionDerivedMixedContentType", getElementType(modifiedSTS, "ExtensionDerivedMixedContentTypeElem"), "Elem Type should be 'ExtensionDerivedMixedContentType' (derived)"); } @@ -945,7 +721,7 @@ public class PartialSOMCheckinTest exten //{} //public void testModifyReusableGroups() throws Exception @Test - public void testAddReusableGroups() throws Exception { + void testAddReusableGroups() throws Exception { System.out.println("Inside test case testAddReusableGroups()"); // Step 1: read in invalid XSD groups.xsd @@ -954,65 +730,53 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // recovearble errors - assertTrue("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 7, 0, 4, 1); // Recovered Errors, Test for saving of the SOM - should fail - assertFalse("Partial SOM " + baseSTS.getName() + "Save successful - should failed!", - checkPSOMSave(baseSTS)); + assertFalse(checkPSOMSave(baseSTS), "Partial SOM " + baseSTS.getName() + "Save successful - should failed!"); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS), "Validation against instance failed"); // verify types // named model groups - assertEquals("Elem Type should be 'ModelGrpType'", - "ModelGrpType", - getElementType(baseSTS, "ModelGrpTypeElem")); - assertTrue("Elem Type should be 'AttributeGroup'", - getAttributeGroup(baseSTS, "AttributeGroup")); + assertEquals("ModelGrpType", getElementType(baseSTS, "ModelGrpTypeElem"), "Elem Type should be 'ModelGrpType'"); + assertTrue(getAttributeGroup(baseSTS, "AttributeGroup"), "Elem Type should be 'AttributeGroup'"); // Step 2: create a SOM with valid xsd SchemaTypeSystem modifiedSTS = createNewSTS("groups_added.xsd_", baseSTS, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 7, 0, 5, 2); // Test for saving of the SOM - should go thro - assertTrue("SOM " + modifiedSTS.getName() + "Save failed!", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS), "Validation against instance failed"); // verify named model groups - assertEquals("Elem Type should be 'ModelGrpType'", - "ModelGrpType", - getElementType(modifiedSTS, "ModelGrpTypeElem")); - assertTrue("Elem Type should be 'AttributeGroup'", - getAttributeGroup(modifiedSTS, "AttributeGroup")); + assertEquals("ModelGrpType", getElementType(modifiedSTS, "ModelGrpTypeElem"), "Elem Type should be 'ModelGrpType'"); + assertTrue(getAttributeGroup(modifiedSTS, "AttributeGroup"), "Elem Type should be 'AttributeGroup'"); } @Test - public void testAddSubstitutionGroups() throws Exception { + void testAddSubstitutionGroups() throws Exception { System.out.println("Inside test case testAddSubstitutionGroups()"); // step1: load an invalid PSOM by with incomplete/missing Subst Grp head elem definition @@ -1021,73 +785,52 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // errors recovered - assertTrue("No Recovered Errors for recovered PSOM", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "No Recovered Errors for recovered PSOM"); // Recovered Errors, Test for saving of the SOM - assertFalse("SOM " + baseSTS.getName() + "Save Success - should fail!", - checkPSOMSave(baseSTS)); + assertFalse(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save Success - should fail!"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 7, 0, 4, 1); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS), "Validation against instance failed"); // verify types - assertEquals("Elem Type should be 'anyType'", - anyType, - getElementType(baseSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'anyType' (Member of Sub. Group)", - anyType, - getElementType(baseSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(baseSTS, "SubGrpMemberElem2")); + assertEquals(anyType, getElementType(baseSTS, "SubGrpHeadElem"), "Elem Type should be 'anyType'"); + assertEquals(anyType, getElementType(baseSTS, "SubGrpMemberElem1"), "Elem Type should be 'anyType' (Member of Sub. Group)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(baseSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // named model groups - assertEquals("Elem Type should be 'ModelGrpType'", - "ModelGrpType", - getElementType(baseSTS, "ModelGrpTypeElem")); - assertTrue("Elem Type should be 'AttributeGroup'", - getAttributeGroup(baseSTS, "AttributeGroup")); + assertEquals("ModelGrpType", getElementType(baseSTS, "ModelGrpTypeElem"), "Elem Type should be 'ModelGrpType'"); + assertTrue(getAttributeGroup(baseSTS, "AttributeGroup"), "Elem Type should be 'AttributeGroup'"); // Step 2: create a valid SOM and add to these SchemaTypeSystem modifiedSTS = createNewSTS("groups_added.xsd_", baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 7, 0, 5, 2); // Test for saving of the SOM - should go thro - assertTrue("SOM " + modifiedSTS.getName() + "Save failed!", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS), "Validation against instance failed"); // verify types - substitution groups - assertEquals("Elem Type should be 'SubGrpHeadElemType' (base)", - "SubGrpHeadElemType", - getElementType(modifiedSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'SubGrpHeadElemType' (derived)", - "SubGrpHeadElemType", - getElementType(modifiedSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(modifiedSTS, "SubGrpMemberElem2")); + assertEquals("SubGrpHeadElemType", getElementType(modifiedSTS, "SubGrpHeadElem"), "Elem Type should be 'SubGrpHeadElemType' (base)"); + assertEquals("SubGrpHeadElemType", getElementType(modifiedSTS, "SubGrpMemberElem1"), "Elem Type should be 'SubGrpHeadElemType' (derived)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(modifiedSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // named model groups - moved to check in test //Assert.assertEquals("Elem Type should be 'ModelGrpType'", "ModelGrpType", getElementType(baseSTS, "ModelGrpTypeElem")); @@ -1095,7 +838,7 @@ public class PartialSOMCheckinTest exten } @Test - public void testDeleteSubstitutionGroups() throws Exception { + void testDeleteSubstitutionGroups() throws Exception { System.out.println("Inside test case testDeleteSubstitutionGroups()"); // Step 1: read in a clean XSD groups_added.xsd @@ -1104,33 +847,24 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 7, 0, 5, 2); // Test for saving of the SOM - should go thro - assertTrue("SOM " + baseSTS.getName() + "Save failed!", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS), "Validation against instance failed"); // verify types - substitution groups - assertEquals("Elem Type should be 'SubGrpHeadElemType' (base)", - "SubGrpHeadElemType", - getElementType(baseSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'SubGrpHeadElemType' (derived)", - "SubGrpHeadElemType", - getElementType(baseSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(baseSTS, "SubGrpMemberElem2")); + assertEquals("SubGrpHeadElemType", getElementType(baseSTS, "SubGrpHeadElem"), "Elem Type should be 'SubGrpHeadElemType' (base)"); + assertEquals("SubGrpHeadElemType", getElementType(baseSTS, "SubGrpMemberElem1"), "Elem Type should be 'SubGrpHeadElemType' (derived)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(baseSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // named model groups //Assert.assertEquals("Elem Type should be 'ModelGrpType'", "ModelGrpType", getElementType(baseSTS, "ModelGrpTypeElem")); @@ -1141,64 +875,45 @@ public class PartialSOMCheckinTest exten baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); - assertTrue("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertTrue(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // Recovered Errors, Test for saving of the SOM - assertFalse("SOM " + modifiedSTS.getName() + "Save Success - should fail!", - checkPSOMSave(modifiedSTS)); + assertFalse(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save Success - should fail!"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 7, 0, 4, 1); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS), "Validation against instance failed"); // verify types - assertEquals("Elem Type should be 'anyType'", - anyType, - getElementType(modifiedSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'anyType' (Member of Sub. Group)", - anyType, - getElementType(modifiedSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(modifiedSTS, "SubGrpMemberElem2")); + assertEquals(anyType, getElementType(modifiedSTS, "SubGrpHeadElem"), "Elem Type should be 'anyType'"); + assertEquals(anyType, getElementType(modifiedSTS, "SubGrpMemberElem1"), "Elem Type should be 'anyType' (Member of Sub. Group)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(modifiedSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // named model groups - assertEquals("Elem Type should be 'ModelGrpType'", - "ModelGrpType", - getElementType(modifiedSTS, "ModelGrpTypeElem")); - assertTrue("Elem Type should be 'AttributeGroup'", - getAttributeGroup(modifiedSTS, "AttributeGroup")); + assertEquals("ModelGrpType", getElementType(modifiedSTS, "ModelGrpTypeElem"), "Elem Type should be 'ModelGrpType'"); + assertTrue(getAttributeGroup(modifiedSTS, "AttributeGroup"), "Elem Type should be 'AttributeGroup'"); // step 3: create a PSOM with the original xsd SchemaTypeSystem finalSTS = createNewSTS("groups_added.xsd_", modifiedSTS, "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // Test for saving of the SOM - should go thro - assertTrue("SOM " + finalSTS.getName() + "Save failed!", checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "SOM " + finalSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), finalSTS), "Validation against instance failed"); // verify types - assertEquals("Elem Type should be 'SubGrpHeadElemType' (base)", - "SubGrpHeadElemType", - getElementType(finalSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'SubGrpHeadElemType' (derived)", - "SubGrpHeadElemType", - getElementType(finalSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(finalSTS, "SubGrpMemberElem2")); + assertEquals("SubGrpHeadElemType", getElementType(finalSTS, "SubGrpHeadElem"), "Elem Type should be 'SubGrpHeadElemType' (base)"); + assertEquals("SubGrpHeadElemType", getElementType(finalSTS, "SubGrpMemberElem1"), "Elem Type should be 'SubGrpHeadElemType' (derived)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(finalSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // named model groups //Assert.assertEquals("Elem Type should be 'ModelGrpType'", "ModelGrpType", getElementType(baseSTS, "ModelGrpTypeElem")); @@ -1209,7 +924,7 @@ public class PartialSOMCheckinTest exten } @Test - public void testModifySubstitutionGroups() throws Exception { + void testModifySubstitutionGroups() throws Exception { System.out.println("Inside test case testModifySubstitutionGroups()"); // Step 1: read in a clean XSD groups_added.xsd @@ -1218,97 +933,73 @@ public class PartialSOMCheckinTest exten null, "BaseSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", baseSTS); + assertNotNull(baseSTS, "Schema Type System created is Null."); // there should be NO recovearble errors - assertFalse("Recovered Errors for Valid Schema", - printRecoveredErrors()); + assertFalse(printRecoveredErrors(), "Recovered Errors for Valid Schema"); // the tests - Walk thro the valid SOM inspectSOM(baseSTS, 7, 0, 5, 2); // Test for saving of the SOM - should go thro - assertTrue("SOM " + baseSTS.getName() + "Save failed!", - checkPSOMSave(baseSTS)); + assertTrue(checkPSOMSave(baseSTS), "SOM " + baseSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), baseSTS), "Validation against instance failed"); // verify types - assertEquals("Elem Type should be 'SubGrpHeadElemType' (base)", - "SubGrpHeadElemType", - getElementType(baseSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'SubGrpHeadElemType' (derived)", - "SubGrpHeadElemType", - getElementType(baseSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(baseSTS, "SubGrpMemberElem2")); + assertEquals("SubGrpHeadElemType", getElementType(baseSTS, "SubGrpHeadElem"), "Elem Type should be 'SubGrpHeadElemType' (base)"); + assertEquals("SubGrpHeadElemType", getElementType(baseSTS, "SubGrpMemberElem1"), "Elem Type should be 'SubGrpHeadElemType' (derived)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(baseSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // step2: load a modified xsd with type of head elem in subs grp changed SchemaTypeSystem modifiedSTS = createNewSTS("groups_modified.xsd_", baseSTS, "ModifiedSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", modifiedSTS); + assertNotNull(modifiedSTS, "Schema Type System created is Null."); // Recovered Errors, Test for saving of the SOM - still a valid PSOM - assertTrue("SOM " + modifiedSTS.getName() + "Save Success - should fail!", - checkPSOMSave(modifiedSTS)); + assertTrue(checkPSOMSave(modifiedSTS), "SOM " + modifiedSTS.getName() + "Save Success - should fail!"); // the tests - Walk thro the valid SOM inspectSOM(modifiedSTS, 5, 0, 3, 0); // instance validation - should fail - assertFalse("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS)); + assertFalse(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), modifiedSTS), "Validation against instance failed"); // verify types - assertEquals("Elem Type should be 'SubGrpHeadElemType2'", - "SubGrpHeadElemType2", - getElementType(modifiedSTS, "SubGrpHeadElem")); - assertEquals("Elem Type should be 'SubGrpHeadElemType2' (derived)", - "SubGrpHeadElemType2", - getElementType(modifiedSTS, "SubGrpMemberElem1")); - assertEquals("Elem Type should be 'ExtensionSubGrpHeadElemType' (base)", - "ExtensionSubGrpHeadElemType", - getElementType(modifiedSTS, "SubGrpMemberElem2")); + assertEquals("SubGrpHeadElemType2", getElementType(modifiedSTS, "SubGrpHeadElem"), "Elem Type should be 'SubGrpHeadElemType2'"); + assertEquals("SubGrpHeadElemType2", getElementType(modifiedSTS, "SubGrpMemberElem1"), "Elem Type should be 'SubGrpHeadElemType2' (derived)"); + assertEquals("ExtensionSubGrpHeadElemType", getElementType(modifiedSTS, "SubGrpMemberElem2"), "Elem Type should be 'ExtensionSubGrpHeadElemType' (base)"); // step3 : reload the original xsd SchemaTypeSystem finalSTS = createNewSTS("groups_added.xsd_", modifiedSTS, "FinalSchemaTS", sBaseSourceName); - assertNotNull("Schema Type System created is Null.", finalSTS); + assertNotNull(finalSTS, "Schema Type System created is Null."); // Test for saving of the SOM - should go thro - assertTrue("SOM " + finalSTS.getName() + "Save failed!", - checkPSOMSave(finalSTS)); + assertTrue(checkPSOMSave(finalSTS), "SOM " + finalSTS.getName() + "Save failed!"); // instance validation - should be ok - assertTrue("Validation against instance failed", - validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), finalSTS)); + assertTrue(validateInstance(getTestCaseFile("instance_subst_grps_valid.xml"), finalSTS), "Validation against instance failed"); // the tests - Walk thro the valid SOM inspectSOM(finalSTS, 7, 0, 5, 2);
[... 125 lines stripped ...] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
