Modified: xmlbeans/trunk/src/test/java/scomp/namespace/detailed/AttributeWC.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/namespace/detailed/AttributeWC.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/namespace/detailed/AttributeWC.java (original) +++ xmlbeans/trunk/src/test/java/scomp/namespace/detailed/AttributeWC.java Sun Feb 6 01:51:55 2022 @@ -16,385 +16,318 @@ package scomp.namespace.detailed; import org.apache.xmlbeans.XmlErrorCodes; -import org.junit.Ignore; -import org.junit.Test; -import scomp.common.BaseCase; +import org.apache.xmlbeans.XmlException; +import org.apache.xmlbeans.XmlOptions; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; import xbean.scomp.namespace.attributeWC.*; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.*; +import static scomp.common.BaseCase.createOptions; +import static scomp.common.BaseCase.getErrorCodes; -public class AttributeWC extends BaseCase { +public class AttributeWC { @Test - public void testAnyLaxLegal() throws Throwable { - AnyLaxDocument doc = AnyLaxDocument.Factory.parse("<AnyLax xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "attr1=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testAnyLaxLegal() throws XmlException { + AnyLaxDocument doc = AnyLaxDocument.Factory.parse( + "<AnyLax xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; attr1=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testAnyLaxIllegal() throws Throwable { - AnyLaxDocument doc = AnyLaxDocument.Factory.parse("<AnyLax xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "attr1=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testAnyLaxIllegal() throws XmlException { + AnyLaxDocument doc = AnyLaxDocument.Factory.parse( + "<AnyLax xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; attr1=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testAnySkipLegal() throws Throwable { - AnySkipDocument doc = AnySkipDocument.Factory.parse("<AnySkip xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "attr1=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testAnySkipLegal() throws XmlException { + AnySkipDocument doc = AnySkipDocument.Factory.parse( + "<AnySkip xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; attr1=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } /** * Everything is legal here - * public void testAnySkipIllegal() throws Throwable { + * public void testAnySkipIllegal() throws XmlException { * } */ //no NS is legal too @Test - public void testAnyStrictLegal() throws Throwable { - AnyStrictDocument doc = AnyStrictDocument.Factory - .parse("<ns:AnyStrict" + - " xmlns:ns=\"http://xbean/scomp/namespace/AttributeWC\"; " + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\"; " + - "at:testattribute=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testAnyStrictLegal() throws XmlException { + AnyStrictDocument doc = AnyStrictDocument.Factory.parse( + "<ns:AnyStrict" + + " xmlns:ns=\"http://xbean/scomp/namespace/AttributeWC\"; " + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\"; " + + "at:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testAnyStrictIllegal() throws Throwable { - AnyStrictDocument doc = AnyStrictDocument.Factory.parse("<AnyStrict xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "attr1=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testAnyStrictIllegal() throws XmlException { + AnyStrictDocument doc = AnyStrictDocument.Factory.parse( + "<AnyStrict xmlns=\"http://xbean/scomp/namespace/AttributeWC\"; attr1=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testOtherLaxLegal() throws Throwable { - OtherLaxDocument doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax " + - "xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "xmlns:foobar=\"http:apache.org\" " + - "foobar:attr1=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testOtherLaxLegal() throws XmlException { + OtherLaxDocument doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax " + + "xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + + "xmlns:foobar=\"http:apache.org\" " + + "foobar:attr1=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } //can not be in target NS //cannot be in noNS @Test - public void testOtherLaxIllegal() throws Throwable { - OtherLaxDocument doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + - " foo:attr1=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - - doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "attr1=\"val1\"/>"); - clearErrors(); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testOtherLaxIllegal() throws XmlException { + OtherLaxDocument doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:attr1=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); + + doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; attr1=\"val1\"/>"); + validateOptions.getErrorListener().clear(); + assertFalse(doc.validate(validateOptions)); + errExpected = new String[]{XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testOtherSkipLegal() throws Throwable { - OtherSkipDocument doc = OtherSkipDocument.Factory - .parse("<foo:OtherSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + - "xmlns:foobar=\"http:apache.org\" " + - "foobar:attr1=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testOtherSkipLegal() throws XmlException { + OtherSkipDocument doc = OtherSkipDocument.Factory.parse( + "<foo:OtherSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + + "xmlns:foobar=\"http:apache.org\" " + + "foobar:attr1=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } //ns not allowed by the wc @Test - public void testOtherSkipIllegal() throws Throwable { - OtherSkipDocument doc = OtherSkipDocument.Factory - .parse("<foo:OtherSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; " + - " foo:attr1=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testOtherSkipIllegal() throws XmlException { + OtherSkipDocument doc = OtherSkipDocument.Factory.parse( + "<foo:OtherSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:attr1=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testOtherStrictLegal() throws Throwable { - OtherStrictDocument doc = OtherStrictDocument.Factory - .parse("<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + - " at:testattribute=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testOtherStrictLegal() throws XmlException { + OtherStrictDocument doc = OtherStrictDocument.Factory.parse( + "<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + + " at:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testOtherStrictIllegal() throws Throwable { - OtherStrictDocument doc = OtherStrictDocument.Factory - .parse("<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + - " at:test=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testOtherStrictIllegal() throws XmlException { + OtherStrictDocument doc = OtherStrictDocument.Factory.parse( + "<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + + " at:test=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } //no declaration for this attr, no error on Lax @Test - public void testListLaxLegal() throws Throwable { - ListLaxDocument doc = ListLaxDocument.Factory - .parse("<foo:ListLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://apache.org\""; + - " at:testattribute=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testListLaxLegal() throws XmlException { + ListLaxDocument doc = ListLaxDocument.Factory.parse( + "<foo:ListLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://apache.org\""; + + " at:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testListLaxIllegal() throws Throwable { - ListLaxDocument doc = ListLaxDocument.Factory.parse("<foo:ListLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + - " at:test=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testListLaxIllegal() throws XmlException { + ListLaxDocument doc = ListLaxDocument.Factory.parse( + "<foo:ListLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + + " at:test=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testListSkipLegal() throws Throwable { - ListSkipDocument doc = ListSkipDocument.Factory - .parse("<foo:ListSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://apache.org\""; + - " at:testattribute=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testListSkipLegal() throws XmlException { + ListSkipDocument doc = ListSkipDocument.Factory.parse( + "<foo:ListSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://apache.org\""; + + " at:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testListSkipIllegal() throws Throwable { - ListSkipDocument doc = ListSkipDocument.Factory - .parse("<foo:ListSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://apache_org.org\""; + - " at:testattribute=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testListSkipIllegal() throws XmlException { + ListSkipDocument doc = ListSkipDocument.Factory.parse( + "<foo:ListSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://apache_org.org\""; + + " at:testattribute=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } // " xmlns:pre=\"http://xbean/scomp/attribute/GlobalAttrDefault\"; @Test - public void testListStrictLegal() throws Throwable { - ListStrictDocument doc = ListStrictDocument.Factory - .parse("<foo:ListStrict " + - " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + - " at:testattribute=\"val1\"/>"); - if (!doc.validate(validateOptions)) { - showErrors(); - fail("testFailed"); - } - + void testListStrictLegal() throws XmlException { + ListStrictDocument doc = ListStrictDocument.Factory.parse( + "<foo:ListStrict " + + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + + " at:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testListStrictIllegal() throws Throwable { - ListStrictDocument doc = ListStrictDocument.Factory - .parse("<foo:ListStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://apache.org\""; + - " at:testattribute=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testListStrictIllegal() throws XmlException { + ListStrictDocument doc = ListStrictDocument.Factory.parse( + "<foo:ListStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://apache.org\""; + + " at:testattribute=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testTargetLaxLegal() throws Throwable { - TargetLaxDocument doc = TargetLaxDocument.Factory - .parse("<foo:TargetLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:testattribute=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testTargetLaxLegal() throws XmlException { + TargetLaxDocument doc = TargetLaxDocument.Factory.parse( + "<foo:TargetLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:testattribute=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testTargetLaxIllegal() throws Throwable { - TargetLaxDocument doc = TargetLaxDocument.Factory - .parse("<foo:TargetLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + - " at:testattributeInt=\"foo\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testTargetLaxIllegal() throws XmlException { + TargetLaxDocument doc = TargetLaxDocument.Factory.parse( + "<foo:TargetLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\""; + + " at:testattributeInt=\"foo\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testTargetSkipLegal() throws Throwable { - TargetSkipDocument doc = TargetSkipDocument.Factory - .parse("<foo:TargetSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:undeclAttr=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testTargetSkipLegal() throws XmlException { + TargetSkipDocument doc = TargetSkipDocument.Factory.parse( + "<foo:TargetSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:undeclAttr=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } /** * can a test ever be illegal here? - */ - @Ignore + */ + @Disabled @Test - public void testTargetSkipIllegal() throws Throwable { - TargetSkipDocument doc = TargetSkipDocument.Factory - .parse("<foo:TargetSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:undeclAttr=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{"cvc-attribute"}; - assertTrue(compareErrorCodes(errExpected)); - + void testTargetSkipIllegal() throws XmlException { + TargetSkipDocument doc = TargetSkipDocument.Factory.parse( + "<foo:TargetSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:undeclAttr=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ATTR_LOCALLY_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testTargetStrictLegal() throws Throwable { - TargetStrictDocument doc = TargetStrictDocument.Factory - .parse("<foo:TargetStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:LocalAttr=\"3\"/>"); - assertTrue(doc.validate(validateOptions)); + void testTargetStrictLegal() throws XmlException { + TargetStrictDocument doc = TargetStrictDocument.Factory.parse( + "<foo:TargetStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:LocalAttr=\"3\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testTargetStrictIllegal() throws Throwable { - TargetStrictDocument doc = TargetStrictDocument.Factory - .parse("<foo:TargetStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:LocalAttr=\"foo\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.DECIMAL - }; - assertTrue(compareErrorCodes(errExpected)); - + void testTargetStrictIllegal() throws XmlException { + TargetStrictDocument doc = TargetStrictDocument.Factory.parse( + "<foo:TargetStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:LocalAttr=\"foo\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.DECIMAL}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalLaxLegal() throws Throwable { - LocalLaxDocument doc = LocalLaxDocument.Factory - .parse("<foo:LocalLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " undeclAttr=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testLocalLaxLegal() throws XmlException { + LocalLaxDocument doc = LocalLaxDocument.Factory.parse( + "<foo:LocalLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; undeclAttr=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testLocalLaxIllegal() throws Throwable { - LocalLaxDocument doc = LocalLaxDocument.Factory - .parse("<foo:LocalLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " foo:undeclAttr=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID - }; - assertTrue(compareErrorCodes(errExpected)); - + void testLocalLaxIllegal() throws XmlException { + LocalLaxDocument doc = LocalLaxDocument.Factory.parse( + "<foo:LocalLax xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; foo:undeclAttr=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalSkipLegal() throws Throwable { - LocalSkipDocument doc = LocalSkipDocument.Factory - .parse("<foo:LocalSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " undeclAttr=\"val1\"/>"); - assertTrue(doc.validate(validateOptions)); + void testLocalSkipLegal() throws XmlException { + LocalSkipDocument doc = LocalSkipDocument.Factory.parse( + "<foo:LocalSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; undeclAttr=\"val1\"/>"); + assertTrue(doc.validate(createOptions())); } /** * can a test ever be illegal here? - */ - @Ignore + */ + @Disabled @Test - public void testLocalSkipIllegal() throws Throwable { - LocalSkipDocument doc = LocalSkipDocument.Factory - .parse("<foo:LocalSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " undeclAttr=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{"cvc-attribute"}; - assertTrue(compareErrorCodes(errExpected)); - + void testLocalSkipIllegal() throws XmlException { + LocalSkipDocument doc = LocalSkipDocument.Factory.parse( + "<foo:LocalSkip xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; undeclAttr=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ATTR_LOCALLY_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalStrictIllegal() throws Throwable { - LocalStrictDocument doc = LocalStrictDocument.Factory - .parse("<foo:LocalStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " undeclAttr=\"val1\"/>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testLocalStrictIllegal() throws XmlException { + LocalStrictDocument doc = LocalStrictDocument.Factory.parse( + "<foo:LocalStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; undeclAttr=\"val1\"/>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalStrictLegal() throws Throwable { - LocalStrictDocument doc = LocalStrictDocument.Factory - .parse("<foo:LocalStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\""; + - " NoNSAttr=\"2\"/>"); - if (!doc.validate(validateOptions)) { - showErrors(); - fail("test failed"); - } + void testLocalStrictLegal() throws XmlException { + LocalStrictDocument doc = LocalStrictDocument.Factory.parse( + "<foo:LocalStrict xmlns:foo=\"http://xbean/scomp/namespace/AttributeWC\"; NoNSAttr=\"2\"/>"); + assertTrue(doc.validate(createOptions())); } }
Modified: xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementFormDefault.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementFormDefault.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementFormDefault.java (original) +++ xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementFormDefault.java Sun Feb 6 01:51:55 2022 @@ -16,50 +16,43 @@ package scomp.namespace.detailed; -import org.junit.Test; -import scomp.common.BaseCase; -import xbean.scomp.namespace.elementFormDefault.ElementFormDefaultEltDocument; -import xbean.scomp.namespace.elementFormDefault.ElementT; -import org.apache.xmlbeans.XmlAnySimpleType; -import org.apache.xmlbeans.XmlObject; import org.apache.xmlbeans.XmlErrorCodes; +import org.apache.xmlbeans.XmlOptions; +import org.junit.jupiter.api.Test; +import xbean.scomp.namespace.elementFormDefault.ElementFormDefaultEltDocument; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static scomp.common.BaseCase.createOptions; +import static scomp.common.BaseCase.getErrorCodes; -public class ElementFormDefault extends BaseCase { +public class ElementFormDefault { @Test - public void testValid() throws Throwable { - ElementFormDefaultEltDocument doc = - ElementFormDefaultEltDocument.Factory.parse("<ns:ElementFormDefaultElt " + - "xmlns:ns=\"http://xbean/scomp/namespace/ElementFormDefault\";>" + - "<ns:childElt>foobar</ns:childElt>" + - " </ns:ElementFormDefaultElt>"); - - try { - doc.validate(validateOptions); - } - catch (Throwable t) { - showErrors(); - throw t; - } + void testValid() throws Throwable { + ElementFormDefaultEltDocument doc = ElementFormDefaultEltDocument.Factory.parse( + "<ns:ElementFormDefaultElt " + + "xmlns:ns=\"http://xbean/scomp/namespace/ElementFormDefault\";>" + + "<ns:childElt>foobar</ns:childElt>" + + " </ns:ElementFormDefaultElt>"); + + doc.validate(createOptions()); } @Test - public void testInvalid() throws Throwable { - ElementFormDefaultEltDocument doc = - ElementFormDefaultEltDocument.Factory.parse("<ns:ElementFormDefaultElt " + - "xmlns:ns=\"http://xbean/scomp/namespace/ElementFormDefault\";>" + - "<childElt>foobar</childElt>" + - " </ns:ElementFormDefaultElt>"); - - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ + void testInvalid() throws Throwable { + ElementFormDefaultEltDocument doc = ElementFormDefaultEltDocument.Factory.parse( + "<ns:ElementFormDefaultElt " + + "xmlns:ns=\"http://xbean/scomp/namespace/ElementFormDefault\";>" + + "<childElt>foobar</childElt>" + + " </ns:ElementFormDefaultElt>"); + + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = { XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_DIFFERENT_ELEMENT, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); - + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } } Modified: xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementWC.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementWC.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementWC.java (original) +++ xmlbeans/trunk/src/test/java/scomp/namespace/detailed/ElementWC.java Sun Feb 6 01:51:55 2022 @@ -15,421 +15,379 @@ package scomp.namespace.detailed; -import org.apache.xmlbeans.XmlErrorCodes; -import org.apache.xmlbeans.XmlInt; -import org.apache.xmlbeans.XmlObject; -import org.apache.xmlbeans.XmlString; -import org.junit.Ignore; -import org.junit.Test; -import scomp.common.BaseCase; +import org.apache.xmlbeans.*; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; import xbean.scomp.namespace.elementWC.*; import javax.xml.namespace.QName; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import static scomp.common.BaseCase.createOptions; +import static scomp.common.BaseCase.getErrorCodes; -/** - */ //TODO: no test on minOccurs maxOccurs here -public class ElementWC extends BaseCase { +public class ElementWC { @Test - public void testAnyLaxLegal() throws Throwable { - AnyLaxDocument doc = AnyLaxDocument.Factory - .parse("<AnyLax " + - "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + - "xmlns:foobar=\"http://foo\";>" + - "<foobar:child/></AnyLax>"); - assertTrue(doc.validate(validateOptions)); + void testAnyLaxLegal() throws XmlException { + AnyLaxDocument doc = AnyLaxDocument.Factory.parse( + "<AnyLax " + + "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + + "xmlns:foobar=\"http://foo\";>" + + "<foobar:child/></AnyLax>"); + assertTrue(doc.validate(createOptions())); } /** * Is it possible to have an illegal LAX/Any--think not */ - @Ignore + @Disabled @Test - public void testAnyLaxIllegal() throws Throwable { - AnyLaxDocument doc = AnyLaxDocument.Factory - .parse("<AnyLax " + - "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; >" + - "<child/></AnyLax>"); - assertTrue(!doc.validate(validateOptions)); - String[] errExpected = new String[]{"cvc-attribute"}; - assertTrue(compareErrorCodes(errExpected)); - + void testAnyLaxIllegal() throws XmlException { + AnyLaxDocument doc = AnyLaxDocument.Factory.parse( + "<AnyLax " + + "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; >" + + "<child/></AnyLax>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = new String[]{XmlErrorCodes.ATTR_LOCALLY_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testAnySkipLegal() throws Throwable { - AnySkipDocument doc = AnySkipDocument.Factory - .parse("<AnySkip " + - "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + - "xmlns:foobar=\"http://foo\";>" + - "<foobar:child/></AnySkip>"); - assertTrue(doc.validate(validateOptions)); + void testAnySkipLegal() throws XmlException { + AnySkipDocument doc = AnySkipDocument.Factory.parse( + "<AnySkip " + + "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + + "xmlns:foobar=\"http://foo\";>" + + "<foobar:child/></AnySkip>"); + assertTrue(doc.validate(createOptions())); } /** * Everything is legal here - * public void testAnySkipIllegal() throws Throwable { + * public void testAnySkipIllegal() throws XmlException { * } */ //no NS is legal too @Test - public void testAnyStrictLegal() throws Throwable { - AnyStrictDocument doc = AnyStrictDocument.Factory - .parse("<ns:AnyStrict" + - " xmlns:ns=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + - " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\""; + - // " xsi:schemaLocation=\"http://xbean/scomp/element/GlobalEltDefault " + - // "GlobalEltDefault.xsd\" - "> " + - "<elt:GlobalEltDefaultStr/></ns:AnyStrict>"); - if (!doc.validate(validateOptions)) - showErrors(); - assertTrue(doc.validate(validateOptions)); - XmlObject[] arr=doc.getAnyStrict() - .selectChildren(new QName( - "http://xbean/scomp/element/GlobalEltDefault";, - "GlobalEltDefaultStr","elt")); - assertEquals(arr[0].schemaType(),XmlString.type); + void testAnyStrictLegal() throws XmlException { + AnyStrictDocument doc = AnyStrictDocument.Factory.parse( + "<ns:AnyStrict" + + " xmlns:ns=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + + " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\""; + + // " xsi:schemaLocation=\"http://xbean/scomp/element/GlobalEltDefault " + + // "GlobalEltDefault.xsd\" + "> " + + "<elt:GlobalEltDefaultStr/></ns:AnyStrict>"); + XmlOptions validateOptions = createOptions(); + assertTrue(doc.validate(validateOptions)); + XmlObject[] arr = doc.getAnyStrict().selectChildren( + new QName("http://xbean/scomp/element/GlobalEltDefault";, "GlobalEltDefaultStr", "elt")); + assertEquals(XmlString.type, arr[0].schemaType()); } @Test - public void testAnyStrictIllegal() throws Throwable { - AnyStrictDocument doc = AnyStrictDocument.Factory - .parse("<AnyStrict " + - "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + - "xmlns:foobar=\"http://foo\";>" + - "<foobar:child/></AnyStrict>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testAnyStrictIllegal() throws XmlException { + AnyStrictDocument doc = AnyStrictDocument.Factory.parse( + "<AnyStrict " + + "xmlns=\"http://xbean/scomp/namespace/ElementWC\"; " + + "xmlns:foobar=\"http://foo\";>" + + "<foobar:child/></AnyStrict>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testOtherLaxLegal() throws Throwable { - OtherLaxDocument doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\"; " + - "xmlns:foobar=\"http:apache.org\" >" + - "<foobar:child/></foo:OtherLax>"); - assertTrue(doc.validate(validateOptions)); + void testOtherLaxLegal() throws XmlException { + OtherLaxDocument doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\"; " + + "xmlns:foobar=\"http:apache.org\" >" + + "<foobar:child/></foo:OtherLax>"); + assertTrue(doc.validate(createOptions())); } //can not be in target NS //cannot be in noNS @Test - public void testOtherLaxIllegal() throws Throwable { - OtherLaxDocument doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";> " + - "<foo:child/></foo:OtherLax>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - doc = OtherLaxDocument.Factory - .parse("<foo:OtherLax " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";> " + - "<child/></foo:OtherLax>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testOtherLaxIllegal() throws XmlException { + OtherLaxDocument doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";> " + + "<foo:child/></foo:OtherLax>"); + assertFalse(doc.validate(createOptions())); + doc = OtherLaxDocument.Factory.parse( + "<foo:OtherLax " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";> " + + "<child/></foo:OtherLax>"); + assertFalse(doc.validate(createOptions())); } @Test - public void testOtherSkipLegal() throws Throwable { - OtherSkipDocument doc = OtherSkipDocument.Factory - .parse("<foo:OtherSkip " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:elt=\"http://xbean/scomp/attribute/GlobalEltDefault\";>" + - "<elt:child/></foo:OtherSkip>"); - assertTrue(doc.validate(validateOptions)); + void testOtherSkipLegal() throws XmlException { + OtherSkipDocument doc = OtherSkipDocument.Factory.parse( + "<foo:OtherSkip " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:elt=\"http://xbean/scomp/attribute/GlobalEltDefault\";>" + + "<elt:child/></foo:OtherSkip>"); + assertTrue(doc.validate(createOptions())); } //no ns not allowed by the wc @Test - public void testOtherSkipIllegal() throws Throwable { - OtherSkipDocument doc = OtherSkipDocument.Factory - .parse("<foo:OtherSkip " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\"; >" + - "<child/></foo:OtherSkip>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testOtherSkipIllegal() throws XmlException { + OtherSkipDocument doc = OtherSkipDocument.Factory.parse( + "<foo:OtherSkip " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\"; >" + + "<child/></foo:OtherSkip>"); + assertFalse(doc.validate(createOptions())); } + //"http://xbean/scomp/element/GlobalEltDefault"; @Test - public void testOtherStrictLegal() throws Throwable { - OtherStrictDocument doc = OtherStrictDocument.Factory - .parse("<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\";>" + - "<elt:GlobalEltDefaultStr/></foo:OtherStrict>"); - if (!doc.validate(validateOptions)) - showErrors(); - assertTrue(doc.validate(validateOptions)); - + void testOtherStrictLegal() throws XmlException { + OtherStrictDocument doc = OtherStrictDocument.Factory.parse( + "<foo:OtherStrict xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\";>" + + "<elt:GlobalEltDefaultStr/></foo:OtherStrict>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testOtherStrictIllegal() throws Throwable { - OtherStrictDocument doc = OtherStrictDocument.Factory - .parse("<foo:OtherStrict " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + - " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\""; + - " xsi:schemaLocation=\"http://xbean/scomp/element/GlobalEltDefault.xsd\";> " + - "<elt:GlobalEltDefaultInt> foo " + - "</elt:GlobalEltDefaultInt>" + - "</foo:OtherStrict>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testOtherStrictIllegal() throws XmlException { + OtherStrictDocument doc = OtherStrictDocument.Factory.parse( + "<foo:OtherStrict " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"; " + + " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\""; + + " xsi:schemaLocation=\"http://xbean/scomp/element/GlobalEltDefault.xsd\";> " + + "<elt:GlobalEltDefaultInt> foo " + + "</elt:GlobalEltDefaultInt>" + + "</foo:OtherStrict>"); + assertFalse(doc.validate(createOptions())); } //no declaration for this attr, no error on Lax @Test - public void testListLaxLegal() throws Throwable { - ListLaxDocument doc = ListLaxDocument.Factory - .parse("<foo:ListLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://apache.org\";>" + - " <at:child/></foo:ListLax>"); - assertTrue(doc.validate(validateOptions)); + void testListLaxLegal() throws XmlException { + ListLaxDocument doc = ListLaxDocument.Factory.parse( + "<foo:ListLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://apache.org\";>" + + " <at:child/></foo:ListLax>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testListLaxIllegal() throws Throwable { - ListLaxDocument doc = ListLaxDocument.Factory - .parse("<foo:ListLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\";>" + - " <at:child/></foo:ListLax>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testListLaxIllegal() throws XmlException { + ListLaxDocument doc = ListLaxDocument.Factory.parse( + "<foo:ListLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\";>" + + " <at:child/></foo:ListLax>"); + assertFalse(doc.validate(createOptions())); } @Test - public void testListSkipLegal() throws Throwable { - ListSkipDocument doc = ListSkipDocument.Factory - .parse("<foo:ListSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://apache.org\";>" + - " <at:child/></foo:ListSkip>"); - assertTrue(doc.validate(validateOptions)); + void testListSkipLegal() throws XmlException { + ListSkipDocument doc = ListSkipDocument.Factory.parse( + "<foo:ListSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://apache.org\";>" + + " <at:child/></foo:ListSkip>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testListSkipIllegal() throws Throwable { - ListSkipDocument doc = ListSkipDocument.Factory - .parse("<foo:ListSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://apache_org.org\";>" + - " <at:child/></foo:ListSkip>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testListSkipIllegal() throws XmlException { + ListSkipDocument doc = ListSkipDocument.Factory.parse( + "<foo:ListSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://apache_org.org\";>" + + " <at:child/></foo:ListSkip>"); + assertFalse(doc.validate(createOptions())); } @Test - public void testListStrictLegal() throws Throwable { - ListStrictDocument doc = ListStrictDocument.Factory - .parse("<foo:ListStrict " + - "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\";>" + - " <elt:GlobalEltDefaultInt/>" + - "</foo:ListStrict>"); - if (!doc.validate(validateOptions)) { - showErrors(); - fail("testFailed"); - } - + void testListStrictLegal() throws XmlException { + ListStrictDocument doc = ListStrictDocument.Factory.parse( + "<foo:ListStrict " + + "xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:elt=\"http://xbean/scomp/element/GlobalEltDefault\";>" + + " <elt:GlobalEltDefaultInt/>" + + "</foo:ListStrict>"); + assertTrue(doc.validate(createOptions())); } //element will not be found @Test - public void testListStrictIllegal() throws Throwable { - ListStrictDocument doc = ListStrictDocument.Factory - .parse("<foo:ListStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://apache.org\";>" + - " <at:child/></foo:ListStrict>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ + void testListStrictIllegal() throws XmlException { + ListStrictDocument doc = ListStrictDocument.Factory.parse( + "<foo:ListStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://apache.org\";>" + + " <at:child/></foo:ListStrict>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = { XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); - + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } //replacement elements MUST be in the // current target NS @Test - public void testTargetLaxLegal() throws Throwable { - TargetLaxDocument doc = TargetLaxDocument.Factory - .parse("<foo:TargetLax" + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - "<foo:LocalElt>2</foo:LocalElt></foo:TargetLax>"); - if (!doc.validate(validateOptions)) - showErrors(); - assertTrue(doc.validate(validateOptions)); - XmlObject[] arr=doc.getTargetLax().selectChildren("http://xbean/scomp/namespace/ElementWC","LocalElt";); - assertEquals(arr[0].schemaType(),XmlInt.type); + void testTargetLaxLegal() throws XmlException { + TargetLaxDocument doc = TargetLaxDocument.Factory.parse( + "<foo:TargetLax" + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + "<foo:LocalElt>2</foo:LocalElt></foo:TargetLax>"); + assertTrue(doc.validate(createOptions())); + XmlObject[] arr = doc.getTargetLax().selectChildren("http://xbean/scomp/namespace/ElementWC";, "LocalElt"); + assertEquals(XmlInt.type, arr[0].schemaType()); } //no such element in the NS @Test - public void testTargetLaxIllegal() throws Throwable { - TargetLaxDocument doc = TargetLaxDocument.Factory - .parse("<foo:TargetLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + - " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\";>" + - " <at:child/></foo:TargetLax>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, + void testTargetLaxIllegal() throws XmlException { + TargetLaxDocument doc = TargetLaxDocument.Factory.parse( + "<foo:TargetLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\""; + + " xmlns:at=\"http://xbean/scomp/attribute/GlobalAttrDefault\";>" + + " <at:child/></foo:TargetLax>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = { + XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); - + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testTargetSkipLegal() throws Throwable { - TargetSkipDocument doc = TargetSkipDocument.Factory - .parse("<foo:TargetSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <foo:child/></foo:TargetSkip>"); - assertTrue(doc.validate(validateOptions)); + void testTargetSkipLegal() throws XmlException { + TargetSkipDocument doc = TargetSkipDocument.Factory.parse( + "<foo:TargetSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <foo:child/></foo:TargetSkip>"); + assertTrue(doc.validate(createOptions())); } /** * can a test ever be illegal here? */ @Test - public void testTargetSkipIllegal() throws Throwable { - TargetSkipDocument doc = TargetSkipDocument.Factory - .parse("<foo:TargetSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <child/></foo:TargetSkip>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ + void testTargetSkipIllegal() throws XmlException { + TargetSkipDocument doc = TargetSkipDocument.Factory.parse( + "<foo:TargetSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <child/></foo:TargetSkip>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = { XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testTargetStrictLegal() throws Throwable { - TargetStrictDocument doc = TargetStrictDocument.Factory - .parse("<foo:TargetStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - "<foo:LocalElt>2</foo:LocalElt></foo:TargetStrict>"); - try{ - assertTrue(doc.validate(validateOptions)); - }catch(Throwable t){ - showErrors(); - throw t; - } + void testTargetStrictLegal() throws XmlException { + TargetStrictDocument doc = TargetStrictDocument.Factory.parse( + "<foo:TargetStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + "<foo:LocalElt>2</foo:LocalElt></foo:TargetStrict>"); + assertTrue(doc.validate(createOptions())); } @Test - public void testTargetStrictIllegal() throws Throwable { - TargetStrictDocument doc = TargetStrictDocument.Factory - .parse("<foo:TargetStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <foo:child/></foo:TargetStrict>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testTargetStrictIllegal() throws XmlException { + TargetStrictDocument doc = TargetStrictDocument.Factory.parse( + "<foo:TargetStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <foo:child/></foo:TargetStrict>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalLaxLegal() throws Throwable { - LocalLaxDocument doc = LocalLaxDocument.Factory - .parse("<foo:LocalLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <child/></foo:LocalLax>"); - assertTrue(doc.validate(validateOptions)); + void testLocalLaxLegal() throws XmlException { + LocalLaxDocument doc = LocalLaxDocument.Factory.parse( + "<foo:LocalLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <child/></foo:LocalLax>"); + assertTrue(doc.validate(createOptions())); } //no such child in current NS @Test - public void testLocalLaxIllegal() throws Throwable { - LocalLaxDocument doc = LocalLaxDocument.Factory - .parse("<foo:LocalLax " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <foo:child/></foo:LocalLax>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); + void testLocalLaxIllegal() throws XmlException { + LocalLaxDocument doc = LocalLaxDocument.Factory.parse( + "<foo:LocalLax " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <foo:child/></foo:LocalLax>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); String[] errExpected = new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, + XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); - + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalSkipLegal() throws Throwable { - LocalSkipDocument doc = LocalSkipDocument.Factory - .parse("<foo:LocalSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <child/></foo:LocalSkip>"); - assertTrue(doc.validate(validateOptions)); + void testLocalSkipLegal() throws XmlException { + LocalSkipDocument doc = LocalSkipDocument.Factory.parse( + "<foo:LocalSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <child/></foo:LocalSkip>"); + assertTrue(doc.validate(createOptions())); } /** * can a test ever be illegal here? */ - @Ignore + @Disabled @Test - public void testLocalSkipIllegal() throws Throwable { - LocalSkipDocument doc = LocalSkipDocument.Factory - .parse("<foo:LocalSkip " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <child/></foo:LocalSkip>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{"cvc-attribute"}; - assertTrue(compareErrorCodes(errExpected)); - + void testLocalSkipIllegal() throws XmlException { + LocalSkipDocument doc = LocalSkipDocument.Factory.parse( + "<foo:LocalSkip " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <child/></foo:LocalSkip>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ATTR_LOCALLY_VALID}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalStrictIllegal() throws Throwable { - LocalStrictDocument doc = LocalStrictDocument.Factory - .parse("<foo:LocalStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - " <child/></foo:LocalStrict>"); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ - XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED - }; - assertTrue(compareErrorCodes(errExpected)); - + void testLocalStrictIllegal() throws XmlException { + LocalStrictDocument doc = LocalStrictDocument.Factory.parse( + "<foo:LocalStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + " <child/></foo:LocalStrict>"); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } @Test - public void testLocalStrictLegal() throws Throwable { - LocalStrictDocument doc = LocalStrictDocument.Factory - .parse("<foo:LocalStrict " + - " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + - "<NoNSElt>2</NoNSElt></foo:LocalStrict>"); - if (!doc.validate(validateOptions)) { - showErrors(); - fail("test failed"); - } + void testLocalStrictLegal() throws XmlException { + LocalStrictDocument doc = LocalStrictDocument.Factory.parse( + "<foo:LocalStrict " + + " xmlns:foo=\"http://xbean/scomp/namespace/ElementWC\";>" + + "<NoNSElt>2</NoNSElt></foo:LocalStrict>"); + assertTrue(doc.validate(createOptions())); } } Modified: xmlbeans/trunk/src/test/java/scomp/redefine/detailed/AttrGroupRedefine.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/redefine/detailed/AttrGroupRedefine.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/redefine/detailed/AttrGroupRedefine.java (original) +++ xmlbeans/trunk/src/test/java/scomp/redefine/detailed/AttrGroupRedefine.java Sun Feb 6 01:51:55 2022 @@ -14,34 +14,34 @@ */ package scomp.redefine.detailed; -import org.junit.Test; -import scomp.common.BaseCase; +import org.junit.jupiter.api.Test; import xbean.scomp.redefine.attrGroupRedefine.AttrGroupEltDocument; import java.lang.reflect.Method; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; -public class AttrGroupRedefine extends BaseCase{ +public class AttrGroupRedefine { /** * test that fields from the old type def are not * visible anymore */ + @SuppressWarnings("ResultOfMethodCallIgnored") @Test - public void testCodeGeneration() throws NoSuchMethodException { + void testCodeGeneration() throws NoSuchMethodException { AttrGroupEltDocument doc = AttrGroupEltDocument.Factory.newInstance(); AttrGroupEltDocument.AttrGroupElt elt = doc.addNewAttrGroupElt(); - assertThrows( "field should be redefined", NoSuchFieldException.class, - () -> elt.getClass().getDeclaredField("attr2")); + assertThrows( NoSuchFieldException.class, () -> elt.getClass().getDeclaredField("attr2"), + "field should be redefined"); elt.getClass().getDeclaredMethod("getAttr1"); elt.getClass().getDeclaredMethod("getAttr2A"); Method m = elt.getClass().getDeclaredMethod("getAttr3A"); - assertEquals(m.getReturnType(), java.lang.Integer.TYPE); + assertEquals(Integer.TYPE, m.getReturnType()); } } Modified: xmlbeans/trunk/src/test/java/scomp/redefine/detailed/MultipleRedefines.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/redefine/detailed/MultipleRedefines.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/redefine/detailed/MultipleRedefines.java (original) +++ xmlbeans/trunk/src/test/java/scomp/redefine/detailed/MultipleRedefines.java Sun Feb 6 01:51:55 2022 @@ -16,16 +16,14 @@ package scomp.redefine.detailed; import org.apache.xmlbeans.*; import org.apache.xmlbeans.impl.xb.xsdschema.SchemaDocument; -import org.junit.Assert; -import org.junit.Test; -import scomp.common.BaseCase; +import org.junit.jupiter.api.Test; import javax.xml.namespace.QName; -import java.util.Iterator; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; +import static scomp.common.BaseCase.createOptions; -public class MultipleRedefines extends BaseCase { +public class MultipleRedefines { private static final String[] MULTIPLE_SCHEMAS = { "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\";>" + " <xs:complexType name=\"T\">" + @@ -166,17 +164,15 @@ public class MultipleRedefines extends B "A.xsd", "B.xsd", "C.xsd", "D.xsd"}; @Test - public void testMultipleRedefines() throws Exception { + void testMultipleRedefines() throws Exception { int N = MULTIPLE_SCHEMAS.length; SchemaDocument[] sdocs = new SchemaDocument[N]; - for (int i = 0; i < N; i++) - { + for (int i = 0; i < N; i++) { sdocs[i] = SchemaDocument.Factory.parse(MULTIPLE_SCHEMAS[i]); sdocs[i].documentProperties().setSourceName(MULTIPLE_SCHEMAS_NAME[i]); } - SchemaTypeSystem ts = XmlBeans.compileXsd(sdocs, - XmlBeans.getBuiltinTypeSystem(), validateOptions); + SchemaTypeSystem ts = XmlBeans.compileXsd(sdocs, XmlBeans.getBuiltinTypeSystem(), createOptions()); assertNotNull(ts); SchemaType t = ts.findType(new QName("", "T")); @@ -187,8 +183,9 @@ public class MultipleRedefines extends B assertEquals(p.getParticleType(), SchemaParticle.SEQUENCE); SchemaParticle[] elts = p.getParticleChildren(); assertEquals(elts.length, 4); - for (int i = 0; i < elts.length; i++) - assertEquals(elts[i].getParticleType(), SchemaParticle.ELEMENT); + for (SchemaParticle elt : elts) { + assertEquals(elt.getParticleType(), SchemaParticle.ELEMENT); + } assertEquals("A", elts[0].getName().getLocalPart()); assertEquals("B", elts[1].getName().getLocalPart()); @@ -197,34 +194,19 @@ public class MultipleRedefines extends B } @Test - public void testCircularRedefines() throws Exception - { + void testCircularRedefines() throws Exception { int N =CIRCULAR_SCHEMAS.length; SchemaDocument[] sdocs = new SchemaDocument[N]; - for (int i = 0; i < N; i++) - { + for (int i = 0; i < N; i++) { sdocs[i] = SchemaDocument.Factory.parse(CIRCULAR_SCHEMAS[i]); sdocs[i].documentProperties().setSourceName(CIRCULAR_SCHEMAS_NAME[i]); } - setUp(); - boolean caught = false; - try - { - SchemaTypeSystem ts = XmlBeans.compileXsd(sdocs, - XmlBeans.getBuiltinTypeSystem(), validateOptions); - } - catch (XmlException e) - { - caught = true; - Iterator it = errorList.iterator(); - XmlError err = (XmlError) it.next(); - Assert.assertFalse(it.hasNext()); - String message = err.getMessage(); - // TODO check an error code instead - assertTrue(message.toLowerCase().indexOf("circular") >= 0); - } - clearErrors(); - assertTrue("Compilation should fail", caught); + XmlOptions validateOptions = createOptions(); + XmlException e = assertThrows(XmlException.class, () -> + XmlBeans.compileXsd(sdocs, XmlBeans.getBuiltinTypeSystem(), validateOptions)); + + XmlError xe = validateOptions.getErrorListener().iterator().next(); + assertTrue(xe.getMessage().contains("circular")); } } Modified: xmlbeans/trunk/src/test/java/scomp/redefine/detailed/SimpleRedefine.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/redefine/detailed/SimpleRedefine.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/redefine/detailed/SimpleRedefine.java (original) +++ xmlbeans/trunk/src/test/java/scomp/redefine/detailed/SimpleRedefine.java Sun Feb 6 01:51:55 2022 @@ -14,51 +14,37 @@ */ package scomp.redefine.detailed; -import org.junit.Test; -import scomp.common.BaseCase; +import org.junit.jupiter.api.Test; import xbean.scomp.redefine.simpleRedefined.NewSizeEltDocument; import xbean.scomp.redefine.simpleRedefined.OldColorEltDocument; import xbean.scomp.redefine.simpleRedefined.OldSizeEltDocument; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static scomp.common.BaseCase.createOptions; -public class SimpleRedefine extends BaseCase { +public class SimpleRedefine { /** * test that fields from the old type def are not * visible anymore: only valid range for sizeT should be 3-20 */ @Test - public void testCodeGeneration() throws Throwable{ - NewSizeEltDocument doc = NewSizeEltDocument.Factory.newInstance(); - OldColorEltDocument doc1 = OldColorEltDocument.Factory.newInstance(); - OldSizeEltDocument doc2 = OldSizeEltDocument.Factory.newInstance(); - - doc.setNewSizeElt(3); - - try { - assertTrue(doc.validate(validateOptions)); - } catch (Throwable t) { - showErrors(); - throw t; - } - doc.setNewSizeElt(21); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - clearErrors(); - - doc2.setOldSizeElt(21); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - clearErrors(); - - doc1.setOldColorElt("white"); - - try { - assertTrue(doc1.validate(validateOptions)); - } catch (Throwable t) { - showErrors(); - throw t; - } + void testCodeGeneration() throws Throwable { + NewSizeEltDocument doc = NewSizeEltDocument.Factory.newInstance(); + OldColorEltDocument doc1 = OldColorEltDocument.Factory.newInstance(); + OldSizeEltDocument doc2 = OldSizeEltDocument.Factory.newInstance(); + + doc.setNewSizeElt(3); + assertTrue(doc.validate(createOptions())); + + doc.setNewSizeElt(21); + assertFalse(doc.validate(createOptions())); + + doc2.setOldSizeElt(21); + assertFalse(doc.validate(createOptions())); + + doc1.setOldColorElt("white"); + assertTrue(doc1.validate(createOptions())); } } Modified: xmlbeans/trunk/src/test/java/scomp/simple/SimplePersonTest.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/simple/SimplePersonTest.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/simple/SimplePersonTest.java (original) +++ xmlbeans/trunk/src/test/java/scomp/simple/SimplePersonTest.java Sun Feb 6 01:51:55 2022 @@ -16,18 +16,18 @@ package scomp.simple; import common.Common; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.openuri.mytest.CustomerDocument; import org.openuri.mytest.Person; import java.util.Calendar; import static java.nio.charset.StandardCharsets.UTF_8; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public class SimplePersonTest { @Test - public void test() throws Exception { + void test() throws Exception { CustomerDocument doc = CustomerDocument.Factory.parse( Common.xbeanCase("xbean/simple/person/person.xml"), null); @@ -67,43 +67,5 @@ public class SimplePersonTest { person.setBase64("base64 encoded".getBytes()); assertEquals("base64 encoded", new String(person.getBase64(), UTF_8)); - - //person.setHexAtt("hex encoding in attributes".getBytes()); - //Assert.assertEquals("hex encoding in attributes", - // new String(person.getHexAtt())); - - //person.setBase64Att("base64 encoded in attributes".getBytes()); - //Assert.assertEquals("base64 encoded in attributes", - // new String(person.getBase64Att())); -// -// XmlCursor cp = person.newXmlCursor(); -// Root.dump( cp ); - -// XmlCursor c = person.xgetBirthdayArray(0).newXmlCursor(); - -// Root.dump( c ); - -// person.setBirthday(0,new Date("Tue Aug 25 16:00:00 PDT 2001")); - -// Root.dump( c ); - -// c.toNextToken(); - -// System.out.println( "---" + c.getText() + "---" ); - -// Root.dump( c ); - -// Assert.assertEquals(person.getBirthdayArray(0), new Date("Tue Aug 25 16:00:00 PDT 2002")); -// -// person.setFirstname("George"); -// Assert.assertEquals(person.getFirstname(), "George"); -// -// person.addNumber( (short) 69 ); -// Assert.assertEquals(person.countNumber(), 5); -// Assert.assertEquals(person.getNumberArray(4), 69); -// -// -// while ( c.hasNextToken() ) -// c.toNextToken(); } } Modified: xmlbeans/trunk/src/test/java/scomp/substGroup/detailed/Deep.java URL: http://svn.apache.org/viewvc/xmlbeans/trunk/src/test/java/scomp/substGroup/detailed/Deep.java?rev=1897795&r1=1897794&r2=1897795&view=diff ============================================================================== --- xmlbeans/trunk/src/test/java/scomp/substGroup/detailed/Deep.java (original) +++ xmlbeans/trunk/src/test/java/scomp/substGroup/detailed/Deep.java Sun Feb 6 01:51:55 2022 @@ -14,119 +14,113 @@ */ package scomp.substGroup.detailed; +import org.apache.xmlbeans.XmlErrorCodes; +import org.apache.xmlbeans.XmlException; +import org.apache.xmlbeans.XmlOptions; +import org.junit.jupiter.api.Test; import xbean.scomp.substGroup.deep.*; import java.math.BigInteger; -import scomp.common.BaseCase; -import org.apache.xmlbeans.XmlException; -import org.apache.xmlbeans.XmlErrorCodes; - -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.*; +import static scomp.common.BaseCase.createOptions; +import static scomp.common.BaseCase.getErrorCodes; /** + * */ -public class Deep extends BaseCase { +public class Deep { /** * QName for casualBShirt is incorrect: * err. message seems bad to me * TODO: seems like the first err is enuf */ - public void testErrorMessage() throws XmlException { + @Test + void testErrorMessage() throws XmlException { String input = - "<pre:items xmlns:pre=\"http://xbean/scomp/substGroup/Deep\";>" + - "<casualBShirt>" + - " <number>SKU25</number>" + - " <name>Oxford Shirt</name>" + - " <size>12</size>" + - " <color>blue</color>" + - "<pokadotColor>yellow</pokadotColor>" + - "</casualBShirt>" + - "</pre:items>"; + "<pre:items xmlns:pre=\"http://xbean/scomp/substGroup/Deep\";>" + + "<casualBShirt>" + + " <number>SKU25</number>" + + " <name>Oxford Shirt</name>" + + " <size>12</size>" + + " <color>blue</color>" + + "<pokadotColor>yellow</pokadotColor>" + + "</casualBShirt>" + + "</pre:items>"; ItemsDocument doc = ItemsDocument.Factory.parse(input); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] errExpected = new String[]{ + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = { XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_DIFFERENT_ELEMENT, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_ELEMENT }; - assertTrue(compareErrorCodes(errExpected)); - + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } - - public void testValidSubstParse() throws Throwable { + @Test + void testValidSubstParse() throws Throwable { String input = - "<pre:items xmlns:pre=\"http://xbean/scomp/substGroup/Deep\";>" + - "<pre:casualBShirt>" + - " <number>SKU25</number>" + - " <name>Oxford Shirt</name>" + - " <size>12</size>" + - " <color>blue</color>" + - "<pokadotColor>yellow</pokadotColor>" + - "</pre:casualBShirt>" + - "<pre:product>" + - " <number>SKU45</number>" + - " <name>Accessory</name>" + - "</pre:product>" + - "<pre:umbrella>" + - " <number>SKU15</number>" + - " <name>Umbrella</name>" + - "</pre:umbrella>" + - "</pre:items>"; + "<pre:items xmlns:pre=\"http://xbean/scomp/substGroup/Deep\";>" + + "<pre:casualBShirt>" + + " <number>SKU25</number>" + + " <name>Oxford Shirt</name>" + + " <size>12</size>" + + " <color>blue</color>" + + "<pokadotColor>yellow</pokadotColor>" + + "</pre:casualBShirt>" + + "<pre:product>" + + " <number>SKU45</number>" + + " <name>Accessory</name>" + + "</pre:product>" + + "<pre:umbrella>" + + " <number>SKU15</number>" + + " <name>Umbrella</name>" + + "</pre:umbrella>" + + "</pre:items>"; ItemsDocument doc = ItemsDocument.Factory.parse(input); - try { - assertTrue(doc.validate(validateOptions)); - } - catch (Throwable t) { - showErrors(); - throw t; - } - + assertTrue(doc.validate(createOptions())); } /** * Test error message. 1 product too many - * - * @throws Throwable */ - public void testValidSubstParseInvalid() throws Throwable { + @Test + void testValidSubstParseInvalid() throws Throwable { String input = - "<root:items xmlns:root=\"http://xbean/scomp/substGroup/Deep\";>" + - "<root:shirt>" + - " <number>SKU25</number>" + - " <name>Oxford Shirt</name>" + - " <size>12</size>" + - " <color>blue</color>" + - "</root:shirt>" + - "<root:product>" + - " <number>SKU45</number>" + - " <name>Accessory</name>" + - "</root:product>" + - "<root:umbrella>" + - " <number>SKU15</number>" + - " <name>Umbrella</name>" + - "</root:umbrella>" + - "<root:casualBShirt>" + - " <number>SKU25</number>" + - " <name>Oxford Shirt</name>" + - " <size>12</size>" + - " <color>blue</color>" + - "<pokadotColor>yellow</pokadotColor>" + - "</root:casualBShirt>" + - "</root:items>"; + "<root:items xmlns:root=\"http://xbean/scomp/substGroup/Deep\";>" + + "<root:shirt>" + + " <number>SKU25</number>" + + " <name>Oxford Shirt</name>" + + " <size>12</size>" + + " <color>blue</color>" + + "</root:shirt>" + + "<root:product>" + + " <number>SKU45</number>" + + " <name>Accessory</name>" + + "</root:product>" + + "<root:umbrella>" + + " <number>SKU15</number>" + + " <name>Umbrella</name>" + + "</root:umbrella>" + + "<root:casualBShirt>" + + " <number>SKU25</number>" + + " <name>Oxford Shirt</name>" + + " <size>12</size>" + + " <color>blue</color>" + + "<pokadotColor>yellow</pokadotColor>" + + "</root:casualBShirt>" + + "</root:items>"; ItemsDocument doc = ItemsDocument.Factory.parse(input); - assertTrue(!doc.validate(validateOptions)); - showErrors(); - String[] expErrors=new String[]{ - XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED - }; - assertTrue(compareErrorCodes(expErrors)); + XmlOptions validateOptions = createOptions(); + assertFalse(doc.validate(validateOptions)); + String[] errExpected = {XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED}; + assertArrayEquals(errExpected, getErrorCodes(validateOptions)); } - public void testValidSubstBuild() throws Throwable { + @Test + void testValidSubstBuild() throws Throwable { ItemsDocument doc = ItemsDocument.Factory.newInstance(); ItemType items = doc.addNewItems(); BusinessCasualShirtType bShirt = BusinessCasualShirtType.Factory.newInstance(); @@ -135,11 +129,12 @@ public class Deep extends BaseCase { bShirt.setSize(new BigInteger("10")); bShirt.setPokadotColor("yellow"); bShirt.setColor("blue"); -/* This doesn't work -ProductType hat = elt.addNewProduct(); -((HatType)hat).setNumber(3); -ShirtType shirt = (ShirtType) elt.addNewProduct(); -*/ + + // This doesn't work + // ProductType hat = elt.addNewProduct(); + // ((HatType)hat).setNumber(3); + // ShirtType shirt = (ShirtType) elt.addNewProduct(); + ShirtType shirt = ShirtType.Factory.newInstance(); shirt.setName("Funny Shirt"); shirt.setNumber("SKU54"); @@ -150,14 +145,6 @@ ShirtType shirt = (ShirtType) elt.addNew genericProd.setNumber("32"); items.setProductArray(new ProductType[]{bShirt, shirt, genericProd}); - try { - assertTrue(doc.validate(validateOptions)); - } - catch (Throwable t) { - showErrors(); - throw t; - } - -//TODO: what to do with the umbrella here??? + assertTrue(doc.validate(createOptions())); } } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
