You are viewing a plain text version of this content. The canonical link for it is here.
Posted to jaxme-dev@ws.apache.org by jo...@apache.org on 2004/08/20 14:23:08 UTC

cvs commit: ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit WildcardTest.java PrinterCreatorTest.java EnumerationTest.java MarshallerTest.java ParserTest.java BaseTestCase.java

jochen      2004/08/20 05:23:08

  Modified:    src/jaxme/org/apache/ws/jaxme/junit WildcardTest.java
                        PrinterCreatorTest.java EnumerationTest.java
                        MarshallerTest.java ParserTest.java
                        BaseTestCase.java
  Log:
  Made test suite run on JDK 1.5, which has got a different format for BigDecimal.toString()
  
  Revision  Changes    Path
  1.3       +3 -3      ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/WildcardTest.java
  
  Index: WildcardTest.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/WildcardTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- WildcardTest.java	16 Feb 2004 23:39:54 -0000	1.2
  +++ WildcardTest.java	20 Aug 2004 12:23:08 -0000	1.3
  @@ -86,7 +86,7 @@
       public void testMarshalAnyAttribute() throws Exception {
           String expect = "<ex:AnyAttribute p:bar=\"value 1\" baz=\"value 2\" xmlns:ex=\"http://ws.apache.org/jaxme/test/misc/wildcards\" xmlns:p=\"foo\"/>";
           String got = getMarshalledAnyAttribute();
  -        assertStringEquals(expect, got);
  +        assertEquals(expect, got);
       }
   
       protected void assertEquals(WildcardAttribute[] pExpect, WildcardAttribute[] pGot) {
  @@ -121,7 +121,7 @@
       public void testMarshalListAttribute() throws Exception {
           String expect = "<ex:ListAttribute p:foo=\"value 1\" ex:bar=\"value 2\" xmlns:ex=\"http://ws.apache.org/jaxme/test/misc/wildcards\" xmlns:p=\"http://ws.apache.org/jaxme/test/misc/wildcards/2\"/>";
           String got = getMarshalledListAttribute();
  -        assertStringEquals(expect, got);
  +        assertEquals(expect, got);
       }
   
       public void testUnmarshalListAttribute() throws Exception {
  @@ -136,7 +136,7 @@
       public void testMarshalOtherAttribute() throws Exception {
           String expect = "<ex:OtherAttribute p:bar=\"value 1\" baz=\"value 2\" xmlns:ex=\"http://ws.apache.org/jaxme/test/misc/wildcards\" xmlns:p=\"foo\"/>";
           String got = getMarshalledOtherAttribute();
  -        assertStringEquals(expect, got);
  +        assertEquals(expect, got);
       }
   
       public void testUnmarshalOtherAttribute() throws Exception {
  
  
  
  1.5       +2 -2      ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/PrinterCreatorTest.java
  
  Index: PrinterCreatorTest.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/PrinterCreatorTest.java,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- PrinterCreatorTest.java	16 Feb 2004 23:39:54 -0000	1.4
  +++ PrinterCreatorTest.java	20 Aug 2004 12:23:08 -0000	1.5
  @@ -108,7 +108,7 @@
                       "  </EmailDetails>\n" +
                       "</Address>";
       String got = sw.toString();
  -    assertStringEquals(expect, got);
  +    assertEquals(expect, got);
     }
   
     public void testPrint() throws Exception {
  @@ -121,6 +121,6 @@
       context.createMarshaller().marshal(addr, sw);
       sw.close();
       String got = sw.toString();
  -    assertStringEquals(address, got);
  +    assertEquals(address, got);
     }
   }
  
  
  
  1.6       +16 -16    ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/EnumerationTest.java
  
  Index: EnumerationTest.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/EnumerationTest.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- EnumerationTest.java	16 Feb 2004 23:39:54 -0000	1.5
  +++ EnumerationTest.java	20 Aug 2004 12:23:08 -0000	1.6
  @@ -158,28 +158,28 @@
   
     public void verifyAllSimpleTypesElement(AllSimpleTypes pElement) {
       assertEquals(MyStringTypeClass.FOO, pElement.getStringElem());
  -    assertStringEquals("FOO", pElement.getStringElem().getValue());
  -    assertStringEquals("FOO", pElement.getStringElem().toString());
  +    assertEquals("FOO", pElement.getStringElem().getValue());
  +    assertEquals("FOO", pElement.getStringElem().toString());
       assertEquals(MyIntTypeClass.INT3, pElement.getIntElem());
       assertEquals(3, pElement.getIntElem().getValue());
  -    assertStringEquals("INT3", pElement.getIntElem().getName());
  -    assertStringEquals("3", pElement.getIntElem().toString());
  +    assertEquals("INT3", pElement.getIntElem().getName());
  +    assertEquals("3", pElement.getIntElem().toString());
       assertEquals(MyLongTypeClass.LONG_NEGATIVE, pElement.getLongElem());
       assertEquals(-23987982739273989L, pElement.getLongElem().getValue());
  -    assertStringEquals("LONG_NEGATIVE", pElement.getLongElem().getName());
  -    assertStringEquals("-23987982739273989", pElement.getLongElem().toString());
  +    assertEquals("LONG_NEGATIVE", pElement.getLongElem().getName());
  +    assertEquals("-23987982739273989", pElement.getLongElem().toString());
       assertEquals(MyShortTypeClass.SHORT_POSITIVE, pElement.getShortElem());
       assertEquals(3468, pElement.getShortElem().getValue());
  -    assertStringEquals("SHORT_POSITIVE", pElement.getShortElem().getName());
  -    assertStringEquals("3468", pElement.getShortElem().toString());
  +    assertEquals("SHORT_POSITIVE", pElement.getShortElem().getName());
  +    assertEquals("3468", pElement.getShortElem().toString());
       assertEquals(MyDoubleTypeClass.DOUBLE_POSITIVE, pElement.getDoubleElem());
       assertTrue(3249239847982.234 == pElement.getDoubleElem().getValue());
  -    assertStringEquals("DOUBLE_POSITIVE", pElement.getDoubleElem().getName());
  -    assertStringEquals("3249239847982.234", pElement.getDoubleElem().toString());
  +    assertEquals("DOUBLE_POSITIVE", pElement.getDoubleElem().getName());
  +    assertEquals("3249239847982.234", pElement.getDoubleElem().toString());
       assertEquals(MyFloatTypeClass.FLOAT_NEGATIVE, pElement.getFloatElem());
       assertTrue(Float.parseFloat("-24234.234") == pElement.getFloatElem().getValue());
  -    assertStringEquals("FLOAT_NEGATIVE", pElement.getFloatElem().getName());
  -    assertStringEquals("-24234.234", pElement.getFloatElem().toString());
  +    assertEquals("FLOAT_NEGATIVE", pElement.getFloatElem().getName());
  +    assertEquals("-24234.234", pElement.getFloatElem().toString());
     }
   
     public void verifyAllTypesElement(AllTypesElement pElement) {
  @@ -218,7 +218,7 @@
                          getAllSimpleTypesElement());
       String expected = getAllSimpleTypesElementString();
       String got = sw.toString();
  -    assertStringEquals(expected, got);
  +    assertEquals(expected, got);
     }
   
     public void testMarshalComplexElements() throws Exception {
  @@ -228,13 +228,13 @@
       JMElement jmElement = (JMElement) getAllTypesElement();
       assertNotNull(jmElement.getQName());
       marshaller.marshal(jmElement, sw);
  -    assertStringEquals(getAllTypesElementString(), sw.toString());
  +    assertEquals(getAllTypesElementString(), sw.toString());
     }
   
     public void testPrefixes() throws Exception {
       AllTypesElementImpl el = new AllTypesElementImpl();
       JMXmlSerializer ser = new AllTypesElementTypeSerializer();
  -    assertStringEquals("ex", ser.getPreferredPrefix(el.getQName().getNamespaceURI()));
  +    assertEquals("ex", ser.getPreferredPrefix(el.getQName().getNamespaceURI()));
       assertNull(ser.getPreferredPrefix("dummyURI"));
     }
   }
  
  
  
  1.15      +15 -10    ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/MarshallerTest.java
  
  Index: MarshallerTest.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/MarshallerTest.java,v
  retrieving revision 1.14
  retrieving revision 1.15
  diff -u -r1.14 -r1.15
  --- MarshallerTest.java	19 Aug 2004 20:41:01 -0000	1.14
  +++ MarshallerTest.java	20 Aug 2004 12:23:08 -0000	1.15
  @@ -46,6 +46,7 @@
   import org.apache.ws.jaxme.JMXmlSerializer;
   import org.apache.ws.jaxme.XMLConstants;
   import org.apache.ws.jaxme.XMLWriter;
  +import org.apache.ws.jaxme.impl.DatatypeConverterImpl;
   import org.apache.ws.jaxme.impl.JAXBContextImpl;
   import org.apache.ws.jaxme.impl.JMMarshallerImpl;
   import org.apache.ws.jaxme.impl.XMLWriterImpl;
  @@ -133,6 +134,10 @@
       return new byte[]{1, 17, 35, 78, 115, -99, -69, -1};
     }
   
  +  protected BigDecimal newBigDecimal() {
  +      return new BigDecimal("6.023e23");
  +  }
  +  
     protected AllSimpleTypes getAllSimpleTypesElement() {
       AllSimpleTypes element = new AllSimpleTypesImpl();
       element.setStringElem("This is a string with german Umlauts: \u00e4\u00f6\u00fc\u00df\u00c4\u00d6\u00dc");
  @@ -151,7 +156,7 @@
       List nmTokens = element.getNmTokensElem();
       nmTokens.add("a-name-token");
       nmTokens.add("another:name-token");
  -    element.setDecimalElem(new BigDecimal("6.023e23"));
  +    element.setDecimalElem(newBigDecimal());
       element.setIntegerElem(new BigDecimal("-6023e20").toBigInteger());
       element.setNonNegativeIntegerElem(new BigInteger("101"));
       element.setPositiveIntegerElem(new BigDecimal("+6023e20").toBigInteger());
  @@ -192,7 +197,7 @@
         "<ex:Base64BinaryElem>AREjTnOdu/8=</ex:Base64BinaryElem>" +
         "<ex:NmTokenElem>a-name-token</ex:NmTokenElem>" +
         "<ex:NmTokensElem>a-name-token another:name-token</ex:NmTokensElem>" +
  -      "<ex:DecimalElem>602300000000000000000000</ex:DecimalElem>" +
  +      "<ex:DecimalElem>" + new DatatypeConverterImpl().printDecimal(newBigDecimal()) + "</ex:DecimalElem>" +
         "<ex:IntegerElem>-602300000000000000000000</ex:IntegerElem>" +
         "<ex:NonNegativeIntegerElem>101</ex:NonNegativeIntegerElem>" +
         "<ex:PositiveIntegerElem>602300000000000000000000</ex:PositiveIntegerElem>" +
  @@ -229,7 +234,7 @@
         sep2 + "<ex:Base64BinaryElem>AREjTnOdu/8=</ex:Base64BinaryElem>" + lf +
         sep2 + "<ex:NmTokenElem>a-name-token</ex:NmTokenElem>" + lf +
         sep2 + "<ex:NmTokensElem>a-name-token another:name-token</ex:NmTokensElem>" + lf +
  -      sep2 + "<ex:DecimalElem>602300000000000000000000</ex:DecimalElem>" + lf +
  +      sep2 + "<ex:DecimalElem>" + new DatatypeConverterImpl().printDecimal(newBigDecimal()) + "</ex:DecimalElem>" + lf +
         sep2 + "<ex:IntegerElem>-602300000000000000000000</ex:IntegerElem>" + lf +
         sep2 + "<ex:NonNegativeIntegerElem>101</ex:NonNegativeIntegerElem>" + lf +
         sep2 + "<ex:PositiveIntegerElem>602300000000000000000000</ex:PositiveIntegerElem>" + lf +
  @@ -254,7 +259,7 @@
     }
   
     protected void verifyAllSimpleTypesElement(AllSimpleTypes pElement) {
  -    assertStringEquals("This is a string with german Umlauts: \u00e4\u00f6\u00fc\u00df\u00c4\u00d6\u00dc",
  +    assertEquals("This is a string with german Umlauts: \u00e4\u00f6\u00fc\u00df\u00c4\u00d6\u00dc",
                          pElement.getStringElem());
       assertEquals(new Double("2.397978293792324E13").doubleValue(),
                    pElement.getDoubleElem(), 0);
  @@ -282,7 +287,7 @@
       Object object = pElement.getUnionTypeElement();
       String dateTime1 = DateFormat.getDateTimeInstance().format(getDateTime().getTime());
       String dateTime2 = DateFormat.getDateTimeInstance().format(((Calendar) object).getTime());
  -    assertStringEquals(dateTime1, dateTime2);
  +    assertEquals(dateTime1, dateTime2);
     }
   
     /** <p>Tests unmarshalling of a simple element.</p>
  @@ -331,7 +336,7 @@
       JMXmlSerializer.Data data = marshaller.getData((JMMarshaller) factory.createMarshaller(), xw);
       AllTypesElementImpl element = new AllTypesElementImpl();
       marshaller.marshal(data, new QName(element.getQName().getNamespaceURI(), "AllSimpleTypesElement"), getAllSimpleTypesElement());
  -    assertStringEquals(getAllSimpleTypesElementString(), sw.toString());
  +    assertEquals(getAllSimpleTypesElementString(), sw.toString());
     }
   
     /** <p>Tests marshalling of a complex element.</p>
  @@ -372,7 +377,7 @@
         }
       }
       marshaller.marshal(getAllTypesElement(), sw);
  -    assertStringEquals(input.toString(), sw.toString());
  +    assertEquals(input.toString(), sw.toString());
     }
   
     protected String getMarshalledAuthor() throws JAXBException {
  @@ -389,7 +394,7 @@
     public void testMarshalSimpleContent() throws Exception {
         String expect = "<ex:Author rating=\"2\" xmlns:ex=\"http://ws.apache.org/jaxme/test/misc/types\">This is a test.</ex:Author>";
         String got = getMarshalledAuthor();
  -      assertStringEquals(expect, got);
  +      assertEquals(expect, got);
     }
   
     private void verifyUnmarshalledAuthor(Author pAuthor) {
  @@ -457,7 +462,7 @@
         "<ex:Base64BinaryElem>AREjTnOdu/8=</ex:Base64BinaryElem>",
         "<ex:NmTokenElem>a-name-token</ex:NmTokenElem>",
         "<ex:NmTokensElem>a-name-token another:name-token</ex:NmTokensElem>",
  -      "<ex:DecimalElem>602300000000000000000000</ex:DecimalElem>",
  +      "<ex:DecimalElem>" + new DatatypeConverterImpl().printDecimal(newBigDecimal()) + "</ex:DecimalElem>",
         "<ex:IntegerElem>-602300000000000000000000</ex:IntegerElem>",
         "<ex:NonNegativeIntegerElem>101</ex:NonNegativeIntegerElem>",
         "<ex:PositiveIntegerElem>602300000000000000000000</ex:PositiveIntegerElem>",
  
  
  
  1.5       +17 -17    ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/ParserTest.java
  
  Index: ParserTest.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/ParserTest.java,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- ParserTest.java	22 Feb 2004 00:52:34 -0000	1.4
  +++ ParserTest.java	20 Aug 2004 12:23:08 -0000	1.5
  @@ -385,9 +385,9 @@
       String[] values = facet.getValues();
       assertNotNull(values);
       assertEquals(3, values.length);
  -    assertStringEquals("AK", values[0]);
  -    assertStringEquals("AL", values[1]);
  -    assertStringEquals("AR", values[2]);
  +    assertEquals("AK", values[0]);
  +    assertEquals("AL", values[1]);
  +    assertEquals("AR", values[2]);
     }
   
     public void testGlobalBindingsDefaults() throws Exception {
  @@ -400,7 +400,7 @@
       SchemaSG jschema = parse(schema, "testGlobalBindingsDefaults.xsd");
   
       String collectionType = jschema.getCollectionType();
  -    assertStringEquals(ArrayList.class.getName(), collectionType);
  +    assertEquals(ArrayList.class.getName(), collectionType);
       JAXBJavaType[] javaTypes = jschema.getJAXBJavaTypes();
       assertNotNull(javaTypes);
       assertEquals(0, javaTypes.length);
  @@ -448,7 +448,7 @@
       SchemaSG jschema = parse(schema, "testGlobalBindingsDefaults.xsd");
   
       String collectionType = jschema.getCollectionType();
  -    assertStringEquals("indexed", collectionType);
  +    assertEquals("indexed", collectionType);
       XsQName[] typesafeEnumBase = jschema.getTypesafeEnumBase();
       assertNotNull(typesafeEnumBase);
       assertEquals(2, typesafeEnumBase.length);
  @@ -732,7 +732,7 @@
       TypeSG usPriceSST = usPrice.getObjectSG().getTypeSG();
       assertTrue(!usPrice.getObjectSG().getTypeSG().isComplex());
       assertTrue(usPriceSST.getSimpleTypeSG().isAtomic());
  -    assertStringEquals(java.math.BigDecimal.class.getName(), usPriceSST.getRuntimeType().toString());   
  +    assertEquals(java.math.BigDecimal.class.getName(), usPriceSST.getRuntimeType().toString());   
       // Items.item.comment
       // <xsd:element ref='comment'   minOccurs='0'/> 
       ParticleSG comment = itemChildren[3];
  @@ -769,7 +769,7 @@
       assertTrue(!shipDateSST.isComplex());
       assertEquals(0, shipDate.getMinOccurs());
       assertTrue(shipDateSST.getSimpleTypeSG().isAtomic());
  -    assertStringEquals(Calendar.class.getName(), shipDateSST.getRuntimeType().toString());    
  +    assertEquals(Calendar.class.getName(), shipDateSST.getRuntimeType().toString());    
   
       // PurchaseOrderType
       TypeSG purchaseOrderType = schemaTypes[3];
  @@ -857,7 +857,7 @@
       ObjectSG quantity = elements[0];
       String maxExclusive = quantity.getTypeSG().getSimpleTypeSG().getAtomicType().getMaxExclusive();
       assertNotNull(maxExclusive);
  -    assertStringEquals("100", maxExclusive);
  +    assertEquals("100", maxExclusive);
     }
   
     /** Test some basic functionality of the builtin datatype nonPositiveInteger. */
  @@ -882,8 +882,8 @@
       assertTrue(!npis.isList());
       assertTrue(!npis.isUnion());
       assertEquals(new Long(0), npis.getAtomicType().getFractionDigits());
  -    assertStringEquals("0", npis.getAtomicType().getMaxInclusive());
  -    assertStringEquals("1", npis.getAtomicType().getMaxExclusive());
  +    assertEquals("0", npis.getAtomicType().getMaxInclusive());
  +    assertEquals("1", npis.getAtomicType().getMaxExclusive());
     }
   
     /** Test some basic functionality of the builtin datatype negativeInteger. */
  @@ -908,8 +908,8 @@
       assertTrue(!nis.isList());
       assertTrue(!nis.isUnion());
       assertEquals(new Long(0), nis.getAtomicType().getFractionDigits());
  -    assertStringEquals("-1", nis.getAtomicType().getMaxInclusive());
  -    assertStringEquals("0", nis.getAtomicType().getMaxExclusive());
  +    assertEquals("-1", nis.getAtomicType().getMaxInclusive());
  +    assertEquals("0", nis.getAtomicType().getMaxExclusive());
     }
   
     public void testNonNegativeIntegerType() throws Exception {
  @@ -933,8 +933,8 @@
       assertTrue(!nnis.isList());
       assertTrue(!nnis.isUnion());
       assertEquals(new Long(0), nnis.getAtomicType().getFractionDigits());
  -    assertStringEquals("-1", nnis.getAtomicType().getMinExclusive());
  -    assertStringEquals("0", nnis.getAtomicType().getMinInclusive());
  +    assertEquals("-1", nnis.getAtomicType().getMinExclusive());
  +    assertEquals("0", nnis.getAtomicType().getMinInclusive());
     }
   
     public void testPositiveIntegerType() throws Exception {
  @@ -958,8 +958,8 @@
       assertTrue(!pis.isList());
       assertTrue(!pis.isUnion());
       assertEquals(new Long(0), pis.getAtomicType().getFractionDigits());
  -    assertStringEquals("0", pis.getAtomicType().getMinExclusive());
  -    assertStringEquals("1", pis.getAtomicType().getMinInclusive());
  +    assertEquals("0", pis.getAtomicType().getMinExclusive());
  +    assertEquals("1", pis.getAtomicType().getMinInclusive());
     }
   
     /** Test some basic functionality of the builtin datatype integer. */
  
  
  
  1.4       +1 -30     ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/BaseTestCase.java
  
  Index: BaseTestCase.java
  ===================================================================
  RCS file: /home/cvs/ws-jaxme/src/jaxme/org/apache/ws/jaxme/junit/BaseTestCase.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- BaseTestCase.java	16 Feb 2004 23:39:54 -0000	1.3
  +++ BaseTestCase.java	20 Aug 2004 12:23:08 -0000	1.4
  @@ -33,35 +33,6 @@
       this(c.getName());
     }
   
  -  // Asserts equality of the two given strings.
  -  protected void assertStringEquals(String pExpect, String pGot) {
  -    if (pExpect == null  ||  pGot == null) {
  -      if (pExpect == null  &&  pGot == null) {
  -        return;
  -      }
  -      if (pExpect == null) {
  -        fail("Expected null, got <" + pGot + ">");
  -      } else {
  -        fail("Expected <" + pExpect + ">, got null");
  -      }
  -    }
  -    if (pExpect.equals(pGot)) {
  -      return;
  -    }
  -    int l1 = pExpect.length();
  -    int l2 = pGot.length();
  -    int l = (l1 > l2) ? l2 : l1;
  -    int offset = 0;
  -    for (int i = 0;  i < l;  i++) {
  -      if (pExpect.charAt(i) != pGot.charAt(i)) {
  -        break;
  -      }
  -      offset = i;
  -    }
  -    fail("Expected <" + pExpect + "> (length " + l1 + "), got <" + pGot +
  -         "> (length " + l2 + "), difference at offset " + offset);
  -  }
  -
     // Asserts equality of the two given byte arrays.
     protected void assertEquals(byte[] pExpect, byte[] pGot) {
       if (pExpect.length != pGot.length) {
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: jaxme-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: jaxme-dev-help@ws.apache.org