Update of /cvsroot/jaxme/JaxMe2/src/net/sf/jaxme/junit
In directory sc8-pr-cvs1:/tmp/cvs-serv30228/src/net/sf/jaxme/junit
Modified Files:
ParserTest.java MarshallerTest.java
Log Message:
Added types: NmTokens, NonNegativeIntegerType. (Marty Kube)
Work on the documentation. (Thalia Rubio)
Work on the references. (Jochen Wiedmann)
Index: ParserTest.java
===================================================================
RCS file: /cvsroot/jaxme/JaxMe2/src/net/sf/jaxme/junit/ParserTest.java,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- ParserTest.java 20 Feb 2003 21:02:00 -0000 1.13
+++ ParserTest.java 6 Mar 2003 20:51:03 -0000 1.14
@@ -36,6 +36,7 @@
import net.sf.jaxme.generator.types.UnionType;
import net.sf.jaxme.generator.types.impl.NegativeIntegerType;
import net.sf.jaxme.generator.types.impl.NonPositiveIntegerType;
+import net.sf.jaxme.generator.types.impl.NonNegativeIntegerType;
import net.sf.jaxme.generator.types.impl.IntegerType;
import net.sf.jaxme.generator.util.QNameComparator;
import net.sf.jaxme.javasource.JavaQName;
@@ -890,7 +891,7 @@
isource.setSystemId("testNonPositiveInteger.xsd");
JAXBSchema jschema = (JAXBSchema) r.parse(isource);
- // simple, atomic, with restriction and maxInclusive
+ // simple, atomic, with restriction and maxExclusive and maxInclusive
SchemaType npi = jschema.getSchemaElements()[0].getSchemaType();
assertTrue(npi.getQName().getLocalPart().equals("nonPositiveInteger"));
assertTrue(!npi.isComplex());
@@ -936,7 +937,7 @@
isource.setSystemId("testNegativeInteger.xsd");
JAXBSchema jschema = (JAXBSchema) r.parse(isource);
- // simple, atomic, with restrictions on and maxInclusive
+ // simple, atomic, with restrictions on maxInclusive and MaxExclusive
SchemaType ni = jschema.getSchemaElements()[0].getSchemaType();
assertTrue(ni.getQName().getLocalPart().equals("negativeInteger"));
assertTrue(!ni.isComplex());
@@ -968,6 +969,94 @@
log.debug(mName + ": <-");
}
+ public void testNonNegativeIntegerType() throws Exception {
+ final String mName = "testNonNegativeIntegerType";
+ log.debug(mName + ": ->");
+ final String schema =
+ "<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'> \n" +
+ " <xsd:element name='non-negative-integer' type='xsd:nonNegativeInteger'/> \n"
+
+ "</xsd:schema> \n";
+
+ JAXBSchemaReader r = new JAXBSchemaReader();
+ InputSource isource = new InputSource(new StringReader(schema));
+ isource.setSystemId("testNonNegativeIntegerType.xsd");
+ JAXBSchema jschema = (JAXBSchema) r.parse(isource);
+
+ // simple, atomic, with restriction on minInclusive and minExclusive
+ SchemaType nni = jschema.getSchemaElements()[0].getSchemaType();
+ assertTrue(nni.getQName().getLocalPart().equals("nonNegativeInteger"));
+ assertTrue(!nni.isComplex());
+ SchemaSimpleType nnis = (SchemaSimpleType) nni;
+ assertTrue(nnis.isAtomic());
+ assertTrue(!nnis.isList());
+ assertTrue(!nnis.isUnion());
+ AtomicType nnisa = (AtomicType) nnis;
+ assertEquals(-1, nnisa.getMinExclusive().intValue());
+ assertEquals(0, nnisa.getMinInclusive().intValue());
+
+ // check setters that should throw range exceptions
+ NonNegativeIntegerType nnit = new NonNegativeIntegerType();
+ boolean didThrow = false;
+ try {
+ nnit.setMinInclusive(new Integer(-1));
+ } catch (IllegalArgumentException e) {
+ didThrow = true;
+ }
+ assertTrue(didThrow);
+ didThrow = false;
+ try {
+ nnit.setMinExclusive(new Integer(-2));
+ } catch (IllegalArgumentException e) {
+ didThrow = true;
+ }
+ assertTrue(didThrow);
+ log.debug(mName + ": <-");
+ }
+
+ public void testPositiveIntegerType() throws Exception {
+ final String mName = "testPositiveIntegerType";
+ log.debug(mName + ": ->");
+ final String schema =
+ "<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'> \n" +
+ " <xsd:element name='positive-integer' type='xsd:positiveInteger'/> \n" +
+ "</xsd:schema> \n";
+
+ JAXBSchemaReader r = new JAXBSchemaReader();
+ InputSource isource = new InputSource(new StringReader(schema));
+ isource.setSystemId("testPositiveIntegerType.xsd");
+ JAXBSchema jschema = (JAXBSchema) r.parse(isource);
+
+ // simple, atomic, with restriction on minInclusive and minExclusive
+ SchemaType pi = jschema.getSchemaElements()[0].getSchemaType();
+ assertTrue(pi.getQName().getLocalPart().equals("positiveInteger"));
+ assertTrue(!pi.isComplex());
+ SchemaSimpleType pis = (SchemaSimpleType) pi;
+ assertTrue(pis.isAtomic());
+ assertTrue(!pis.isList());
+ assertTrue(!pis.isUnion());
+ AtomicType pisa = (AtomicType) pis;
+ assertEquals(0, pisa.getMinExclusive().intValue());
+ assertEquals(1, pisa.getMinInclusive().intValue());
+
+ // check setters that should throw range exceptions
+ NonNegativeIntegerType pit = new NonNegativeIntegerType();
+ boolean didThrow = false;
+ try {
+ pit.setMinInclusive(new Integer(0));
+ } catch (IllegalArgumentException e) {
+ didThrow = true;
+ }
+ assertTrue(didThrow);
+ didThrow = false;
+ try {
+ pit.setMinExclusive(new Integer(-1));
+ } catch (IllegalArgumentException e) {
+ didThrow = true;
+ }
+ assertTrue(didThrow);
+ log.debug(mName + ": <-");
+ }
+
/** Test some basic functionality of the builtin datatype integer. */
public void testIntegerType() throws Exception {
final String mName = "testIntegerType";
@@ -1004,4 +1093,31 @@
assertTrue(didThrow);
log.debug(mName + ": <-");
}
+
+ /** Test built-in type NMTOKENS. */
+ public void testNmTokensType() throws Exception {
+ final String mName = "testNmTokensType";
+ log.debug(mName + ": ->");
+ final String schema =
+ "<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'> \n" +
+ " <xsd:element name='some-nmtokens' type='xsd:NMTOKENS'/> \n" +
+ "</xsd:schema> \n";
+
+ JAXBSchemaReader r = new JAXBSchemaReader();
+ InputSource isource = new InputSource(new StringReader(schema));
+ isource.setSystemId("testNmTokensType.xsd");
+ JAXBSchema jschema = (JAXBSchema) r.parse(isource);
+
+ // list of one or more nmtoken's
+ SchemaType nmts = jschema.getSchemaElements()[0].getSchemaType();
+ assertTrue(nmts.getQName().getLocalPart().equals("NMTOKENS"));
+ assertTrue(!nmts.isComplex());
+ SchemaSimpleType nmtss = (SchemaSimpleType) nmts;
+ assertTrue(!nmtss.isAtomic());
+ assertTrue(nmtss.isList());
+ assertTrue(!nmtss.isUnion());
+ ListType mntsl = (ListType) nmtss;
+ assertEquals(1, mntsl.getMinLength().intValue());
+ assertTrue(mntsl.getItemType().getQName().getLocalPart().equals("NMTOKEN"));
+ }
}
Index: MarshallerTest.java
===================================================================
RCS file: /cvsroot/jaxme/JaxMe2/src/net/sf/jaxme/junit/MarshallerTest.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- MarshallerTest.java 20 Feb 2003 21:01:59 -0000 1.7
+++ MarshallerTest.java 6 Mar 2003 20:51:05 -0000 1.8
@@ -105,9 +105,14 @@
element.setDurationElem(getDuration());
element.setHexBinaryElem(getHexBytes());
element.setBase64BinaryElem(getHexBytes());
- element.setNmTokenElem("these are some nm tokens");
+ element.setNmTokenElem("a-name-token");
+ List nmTokens = new ArrayList();
+ nmTokens.add("a-name-token");
+ nmTokens.add("another:name-token");
+ element.setNmTokensElem(nmTokens);
element.setDecimalElem(new BigDecimal("6.023e23"));
element.setIntegerElem(new BigDecimal("-6023e20"));
+ element.setNonNegativeIntegerElem(new BigDecimal("101"));
element.setPositiveIntegerElem(new BigDecimal("+6023e20"));
element.setNonPositiveIntegerElem(new BigDecimal("-21714"));
element.setNegativeIntegerElem(new BigDecimal("-21714"));
@@ -141,9 +146,11 @@
"<ex:DurationElem>P1Y2M3DT4H5M" + NumberFormat.getInstance().format(6.7) +
"S</ex:DurationElem>" +
"<ex:HexBinaryElem>0111234E739DBBFF</ex:HexBinaryElem>" +
"<ex:Base64BinaryElem>AREjTnOdu/8=</ex:Base64BinaryElem>" +
- "<ex:NmTokenElem>these are some nm tokens</ex:NmTokenElem>" +
+ "<ex:NmTokenElem>a-name-token</ex:NmTokenElem>" +
+ "<ex:NmTokensElem>a-name-token another:name-token</ex:NmTokensElem>" +
"<ex:DecimalElem>602300000000000000000000</ex:DecimalElem>" +
"<ex:IntegerElem>-602300000000000000000000</ex:IntegerElem>" +
+ "<ex:NonNegativeIntegerElem>101</ex:NonNegativeIntegerElem>" +
"<ex:PositiveIntegerElem>602300000000000000000000</ex:PositiveIntegerElem>" +
"<ex:NonPositiveIntegerElem>-21714</ex:NonPositiveIntegerElem>" +
"<ex:NegativeIntegerElem>-21714</ex:NegativeIntegerElem>" +
@@ -166,9 +173,11 @@
" <ex:DurationElem>P1Y2M3DT4H5M" + NumberFormat.getInstance().format(6.7) +
"S</ex:DurationElem>\n" +
" <ex:HexBinaryElem>0111234E739DBBFF</ex:HexBinaryElem>\n" +
" <ex:Base64BinaryElem>AREjTnOdu/8=</ex:Base64BinaryElem>\n" +
- " <ex:NmTokenElem>these are some nm tokens</ex:NmTokenElem>\n" +
+ " <ex:NmTokenElem>a-name-token</ex:NmTokenElem>\n" +
+ " <ex:NmTokensElem>a-name-token another:name-token</ex:NmTokensElem>\n" +
" <ex:DecimalElem>602300000000000000000000</ex:DecimalElem>\n" +
" <ex:IntegerElem>-602300000000000000000000</ex:IntegerElem>\n" +
+ " <ex:NonNegativeIntegerElem>101</ex:NonNegativeIntegerElem>\n" +
"
<ex:PositiveIntegerElem>602300000000000000000000</ex:PositiveIntegerElem>\n" +
" <ex:NonPositiveIntegerElem>-21714</ex:NonPositiveIntegerElem>\n" +
" <ex:NegativeIntegerElem>-21714</ex:NegativeIntegerElem>\n" +
@@ -209,6 +218,8 @@
assertEquals(getDuration(), pElement.getDurationElem());
assertEquals(getHexBytes(), pElement.getHexBinaryElem());
assertEquals(getHexBytes(), pElement.getBase64BinaryElem());
+ assertEquals(new BigDecimal(101), pElement.getNonNegativeIntegerElem());
+ // marty - a little more here
}
public void verifyAllTypesElement(AllTypesElement pElement) {
-------------------------------------------------------
This SF.net email is sponsored by: Etnus, makers of TotalView, The debugger
for complex code. Debugging C/C++ programs can leave you feeling lost and
disoriented. TotalView can help you find your way. Available on major UNIX
and Linux platforms. Try it free. www.etnus.com
_______________________________________________
Jaxme-jaxb-dev mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/jaxme-jaxb-dev
