You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by gd...@apache.org on 2001/05/22 20:43:06 UTC

cvs commit: xml-axis/java/test/utils/cache PackageTests.java TestJavaClass.java TestJavaMethod.java

gdaniels    01/05/22 11:43:03

  Modified:    java     build.xml
               java/samples/encoding Data.java DataSer.java TestSer.java
               java/src/org/apache/axis/utils/cache JavaMethod.java
  Added:       java/test/utils ConsumerPipe.java PackageTests.java
                        TestAxisClassLoader.java TestOptions.java
                        TestQFault.java TestQName.java TestXMLUtils.java
               java/test/utils/cache PackageTests.java TestJavaClass.java
                        TestJavaMethod.java
  Log:
  Check in QA stuff submitted by Scott Stirling (sstirling@macromedia.com).
  
  Tests for a lot of the stuff in the utils package, and use the XML test formatter in
  build.xml.
  
  Revision  Changes    Path
  1.21      +6 -4      xml-axis/java/build.xml
  
  Index: build.xml
  ===================================================================
  RCS file: /home/cvs/xml-axis/java/build.xml,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- build.xml	2001/05/09 21:16:39	1.20
  +++ build.xml	2001/05/22 18:41:54	1.21
  @@ -181,7 +181,8 @@
   
       <!-- Tests are packaged as test.*, so source dir is main dir -->
       <javac srcdir="${basedir}"
  -      destdir="${build.dir}">
  +      destdir="${build.dir}"
  +      debug="on"> <!-- set debug on since it helps with line numbers when unit tests fail. -->
         <include name="test/**/*.java" />
         <classpath refid="test-classpath" />
       </javac>
  @@ -192,10 +193,11 @@
     <!-- Runs the JUnit testcases -->
     <!-- =================================================================== -->
     <target name="junit" if="junit.present" depends="buildTest">
  -    <junit printsummary="yes" haltonfailure="yes" fork="yes">
  +    <mkdir dir="${basedir}/test-reports" />
  +    <junit printsummary="yes" haltonfailure="no" fork="yes">
         <classpath refid="test-classpath" />
  -      <formatter type="plain" />
  -      <batchtest>
  +      <formatter type="xml" />
  +      <batchtest todir="test-reports">
           <fileset dir="${build.dir}">
             <!-- Convention: each package that's being tested
                   has its own test class collecting all the tests -->
  
  
  
  1.3       +8 -5      xml-axis/java/samples/encoding/Data.java
  
  Index: Data.java
  ===================================================================
  RCS file: /home/cvs/xml-axis/java/samples/encoding/Data.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- Data.java	2001/05/04 19:27:50	1.2
  +++ Data.java	2001/05/22 18:42:17	1.3
  @@ -8,19 +8,22 @@
       
       public String toString()
       {
  -        return getStringVal("");
  +        return getStringVal("", this);
       }
       
  -    public String getStringVal(String indent)
  +    public String getStringVal(String indent, Data topLevel)
       {
           String ret = "\n" + indent + "Data:\n";
           ret +=       indent + " str[" + stringMember + "]\n";
           ret +=       indent + " float[" + floatMember + "]\n";
           ret +=       indent + " data[";
           
  -        if (dataMember != null)
  -            ret += dataMember.getStringVal(indent + "  ") + "\n" + indent;
  -        else
  +        if (dataMember != null) {
  +            if (dataMember == topLevel) {
  +                ret += " top level";
  +            } else
  +                ret += dataMember.getStringVal(indent + "  ", topLevel) + "\n" + indent;
  +        } else
               ret += " null";
           
           ret += " ]";
  
  
  
  1.4       +1 -0      xml-axis/java/samples/encoding/DataSer.java
  
  Index: DataSer.java
  ===================================================================
  RCS file: /home/cvs/xml-axis/java/samples/encoding/DataSer.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- DataSer.java	2001/05/04 19:27:51	1.3
  +++ DataSer.java	2001/05/22 18:42:22	1.4
  @@ -69,6 +69,7 @@
           context.startElement(name, attributes);
           context.serialize(new QName("", STRINGMEMBER), null, data.stringMember);
           context.serialize(new QName("", FLOATMEMBER), null, data.floatMember);
  +        context.serialize(new QName("", DATAMEMBER), null, data.dataMember);
           context.endElement();
       }
   }
  
  
  
  1.6       +7 -1      xml-axis/java/samples/encoding/TestSer.java
  
  Index: TestSer.java
  ===================================================================
  RCS file: /home/cvs/xml-axis/java/samples/encoding/TestSer.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- TestSer.java	2001/05/05 22:16:52	1.5
  +++ TestSer.java	2001/05/22 18:42:27	1.6
  @@ -25,8 +25,14 @@
           service.addInputParam("struct", dataQName);
           
           Data data = new Data();
  +        Data data2 = new Data();
           data.stringMember = "String member";
  -        data.floatMember = new Float("4.54");
  +        data.floatMember = new Float("1.23");
  +        data.dataMember = data2;
  +        
  +        data2.stringMember = "another str member";
  +        data2.floatMember = new Float("4.56");
  +        data2.dataMember = null;  // "data;" for loop-test of multi-refs
           
           RPCParam arg2 = new RPCParam("", "struct", data);
           RPCElement body = new RPCElement("urn:myNamespace", "method1", new Object[]{ arg1, arg2 });
  
  
  
  1.2       +1 -0      xml-axis/java/src/org/apache/axis/utils/cache/JavaMethod.java
  
  Index: JavaMethod.java
  ===================================================================
  RCS file: /home/cvs/xml-axis/java/src/org/apache/axis/utils/cache/JavaMethod.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- JavaMethod.java	2001/05/02 23:19:27	1.1
  +++ JavaMethod.java	2001/05/22 18:42:41	1.2
  @@ -85,6 +85,7 @@
               if (methods[i].getName().equals(name)) {
                   if (unique != null) {
                       workinglist = new Vector();
  +                    workinglist.addElement(unique);
                       workinglist.addElement(methods[i]);
                       unique = null;
                   } else if (workinglist != null) {
  
  
  
  1.1                  xml-axis/java/test/utils/ConsumerPipe.java
  
  Index: ConsumerPipe.java
  ===================================================================
  package test.utils;
  
  import java.io.*;
  
  public class ConsumerPipe implements Runnable
  {
      PipedInputStream consumer = null;
      String result;
      private static int pipecount = 0; //thread counter for debuggers and stack traces.
    boolean done = false;
      
      public ConsumerPipe(PipedOutputStream out) throws IOException {
          consumer = new PipedInputStream(out);
          pipecount++;
      }
      
      public void run()
      {
          try
          {
              char[] chars = new char[consumer.available()];
              for (int i =0; i < chars.length; i++)
              {
                  chars[i] = (char)consumer.read();
              }
              result = new String(chars);
          }
          catch (IOException ioe)
          {
              ioe.printStackTrace();
          }
          finally {
              try {
                  consumer.close();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              done = true;
              synchronized (this) {
                notifyAll();
            }
          }
      }
  
      /**
       * Starts this object as a thread, which results in the run() method being
       * invoked and work being done.
       */
      public String getResult() {
          Thread reader = new Thread(this, "Piper-"+pipecount);
          reader.start();
          while (!done) {
            synchronized (this) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
              }
        }
          return result;
      }
  }
  
  
  1.1                  xml-axis/java/test/utils/PackageTests.java
  
  Index: PackageTests.java
  ===================================================================
  package test.utils;
  
  import junit.framework.TestCase;
  import junit.framework.Test;
  import junit.framework.TestSuite;
  
  /**
   */
  public class PackageTests 
  {
      public static void main (String[] args) {
              junit.textui.TestRunner.run (suite());
      }
  
      public static Test suite()
      {
          TestSuite suite = new TestSuite("All axis.utils tests");
  
          suite.addTest(TestAxisClassLoader.suite());
          // suite.addTest(TestOptions.suite()); //comment out for now - this
          // class is a mess
          suite.addTest(TestQName.suite());
          suite.addTest(TestQFault.suite());
          suite.addTest(TestXMLUtils.suite());
  
          return suite;
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/TestAxisClassLoader.java
  
  Index: TestAxisClassLoader.java
  ===================================================================
  package test.utils;
  
  import junit.framework.*;
  import org.apache.axis.utils.AxisClassLoader;
  import org.apache.axis.utils.cache.JavaClass;
  
  public class TestAxisClassLoader extends TestCase
  {
      protected AxisClassLoader acl;
  
      public TestAxisClassLoader (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestAxisClassLoader.class);
      }
  
      protected void setup() {
      }
      
      public void testGetClassLoaderNoArg()
      {
  	AxisClassLoader expect = AxisClassLoader.getClassLoader();
  	AxisClassLoader actual = AxisClassLoader.getClassLoader("<default_class_loader>");
          assert(expect instanceof AxisClassLoader);
          assertEquals(expect, actual);
      }
      
      public void testGetClassLoaderStringArg()
      {
          AxisClassLoader acl = AxisClassLoader.getClassLoader("newClassLoader");
          AxisClassLoader result = AxisClassLoader.getClassLoader("newClassLoader");
          if (!acl.equals(result))
          {
              fail("Test failure: these 2 AxisClassLoader references should refer to same instance.");
          }
      }
  
      public void testRemoveClassLoader()
      {
          AxisClassLoader acl = AxisClassLoader.getClassLoader("newClassLoader");
          AxisClassLoader.removeClassLoader("newClassLoader");
          AxisClassLoader result = acl.getClassLoader("newClassLoader");
          if (acl.equals(result))
          {
              fail("These 2 AxisClassLoader references should not refer to same instance.");
          }
      }
  
      public void testRegisterClassNameClass()
      {
  	AxisClassLoader acl = AxisClassLoader.getClassLoader();
          java.util.Stack stack = new java.util.Stack(); //Stack was chosen arbitrarily
          Class clazz = stack.getClass();
          acl.registerClass("myStack",clazz);
          assert(acl.isClassRegistered("myStack"));
      }
  
      public void testIsClassRegistered()
      {
  	AxisClassLoader acl = AxisClassLoader.getClassLoader();
          java.util.Stack stack = new java.util.Stack(); //Stack was chosen arbitrarily
          Class clazz = stack.getClass();
          acl.registerClass("anotherStack",clazz);
          if (acl.isClassRegistered("noStack"))
          {
              fail("Nonce class name should not be registered.");
          }
          assert(acl.isClassRegistered("anotherStack"));
      }
  
      public void testDeregisterClass()
      {
  	AxisClassLoader acl = AxisClassLoader.getClassLoader();
          java.util.Stack stack = new java.util.Stack(); //Stack was chosen arbitrarily
          Class clazz = stack.getClass();
          acl.registerClass("myStack",clazz);
          assert(acl.isClassRegistered("myStack"));
          acl.deregisterClass("myStack");
          if (acl.isClassRegistered("myStack"))
          {
              fail("Class should have been deregistered.");
          } 
      }
  
      public void testLoadClass() throws ClassNotFoundException
      {
  	AxisClassLoader acl = AxisClassLoader.getClassLoader();
          Class clazz = acl.loadClass("java.util.BitSet"); //BitSet was chosen arbitrarily 
          assert(clazz.getName().equals("java.util.BitSet"));
  
          java.util.Stack stack = new java.util.Stack(); //Stack was chosen arbitrarily
          Class clazz1 = stack.getClass();
          acl.registerClass("myStack",clazz1);
          Class klass = acl.loadClass("myStack");
          assert(klass.getName().equals("java.util.Stack"));
      }
  
      public void testLookup() throws ClassNotFoundException
      {
  	AxisClassLoader acl = AxisClassLoader.getClassLoader();
          JavaClass jc = acl.lookup("java.util.BitSet"); //BitSet was chosen arbitrarily 
          Class c = jc.getJavaClass(); 
          assert(c.getName().equals("java.util.BitSet"));
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/TestOptions.java
  
  Index: TestOptions.java
  ===================================================================
  package test.utils;
  
  import junit.framework.*;
  import org.apache.axis.utils.Options;
  import java.net.MalformedURLException;
  
  public class TestOptions extends TestCase
  {
      public TestOptions (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestOptions.class);
      }
  
      protected void setup() {
      }
  
      public void testOptionsConstructor() throws MalformedURLException
      {
          String[] fake_args = { "-h 127.0.0.1","-p 8081","-u scott","-w tiger" };
          Options ops = new Options(fake_args); 
      }   
  
  
      /* 
      * Note - by Java conventions, the isFlagSet and isValueSet should either
      * return a boolean value, or be given more descriptive names.  I might
      * suggest getFlagFrequency and getArgValue or something.
      */
      public void testIsFlagSet() throws MalformedURLException 
      {
          String[] fake_args = { "-w tiger" };
          Options ops = new Options(fake_args); 
          String result = ops.isValueSet('w');
          assertEquals("tiger", result);
      }   
  
  }
  
  
  
  1.1                  xml-axis/java/test/utils/TestQFault.java
  
  Index: TestQFault.java
  ===================================================================
  package test.utils;
  
  import junit.framework.*;
  import org.apache.axis.utils.QFault;
  import org.apache.axis.utils.QName;
  import org.w3c.dom.*;
  
  public class TestQFault extends TestCase
  {
      public TestQFault (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestQFault.class);
      }
  
      protected void setup() {
      }
  
      public void testQFaultConstructorWith3Params()
      {
          QFault qfault = new QFault("xsl","include","extra");
          assert(qfault instanceof QName);
          assert(qfault instanceof QFault);
          assertEquals("include.extra", qfault.getLocalPart());
      }   
      
      public void testQFaultConstructorWithQFaultParam()
      {
          QFault qfault = new QFault("rdf","title");
          QFault qfaultWithMinorCode = new QFault(qfault,"extraBits");
          assert(qfaultWithMinorCode instanceof QFault);
          assertEquals("title.extraBits", qfaultWithMinorCode.getLocalPart());
      }   
      
      public void testQFaultConstructorWithQNameParam()
      {
          QName qname = new QFault("rdf", "title");
          QFault qfault = new QFault(qname, "someCode");
          assertEquals("title.someCode", qfault.getLocalPart());
      }   
      
      public void testAppendMinorCode()
      {
          QFault qfault = new QFault("rdf","title");
          qfault.appendMinorCode("minor-code");
          assertEquals("rdf", qfault.getNamespaceURI());
          assertEquals("title.minor-code", qfault.getLocalPart());
      }   
  }
  
  
  
  1.1                  xml-axis/java/test/utils/TestQName.java
  
  Index: TestQName.java
  ===================================================================
  package test.utils;
  
  import junit.framework.*;
  import org.apache.axis.utils.QName;
  import org.w3c.dom.*;
  
  public class TestQName extends TestCase
  {
      public TestQName (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestQName.class);
      }
  
      protected void setup() {
      }
  
      public void testQNameDefaultConstructor()
      {
          QName qname = new QName();
          assert(qname instanceof QName);
          assertNull(qname.getLocalPart());
      }   
      
      public void testQName2StringConstructor()
      {
          QName qname = new QName("rdf","article");
          assertNotNull(qname); 
          assertEquals("rdf", qname.getNamespaceURI()); 
          assertEquals("article", qname.getLocalPart()); 
      }
  
      /*
      public void testQNameStringElementConstructor()
      {
          //need a fully implemented mock
          //Element class to test this . . .
          //Element elem = new MockElement();
          QName qname = new QName("PREFIX:LOCALPART", elem);
          assertNotNull(qname); 
          assertEquals("PREFIX", qname.getNamespaceURI()); 
          assertEquals("LOCALPART", qname.getNamespaceURI()); 
      }
       */
  
      public void testToString()
      {
          QName qname = new QName("PREFIX", "LOCALPART");
          assertEquals("PREFIX:LOCALPART", qname.toString());
  
          qname.setNamespaceURI(null);
          assertEquals("LOCALPART", qname.toString());
      }
  
      public void testEquals()
      {
          QName qname1 = new QName();
          QName qname2 = new QName("PREFIX", "LOCALPART");
          QName qname3 = new QName("PREFIX", "LOCALPART");
          QName qname4 = new QName("PREFIX", "DIFFLOCALPART");
          //need a fully implemented mock Element class...
          //Element elem = new MockElement();        
          ////QName qname5 = new QName("PREFIX:LOCALPART", elem);
  
          /*
          *  This first test causes a NullPointerException.  I don't think it 
          *  should, but I know why it does.  If you have an instance of QName 
          *  that was constructed with the no-args constructor, then its 
          *  namespaceURI and localPart fields will be null.  When you call the 
          *  equals(Object o) method, it compares those values between two 
          *  instances of QName using the String.equals() method.  This causes a 
          *  NullPointerException when the "empty" QName's namespaceURI field is 
          *  accessed for the comparison. 
          *
          *  If you switch them around so that the QName doing the comparison 
          *  (the one whose equals() method is called) has non-null fields, then
          *  you will not get a NullPointerException.
          *
          *  Suggestions:
          *  1. Initialize QName's fields to empty strings instead of letting them
          *  be nulls.
          *
          *  2. explicity throw or implicitly handle NullPointerExceptions under
          *  this condition.
          */
          boolean passed = false;
          try {
              assert(!qname1.equals(qname2));
          }
          catch (NullPointerException npe) {
              passed = true; // this should not really be a pass, but this is the 
                             // behavior the class currently exhibits.
          }
          assert(passed);
         
          //Note: this test is comparing the same two QName objects as above, but
          //due to the order and the implementation of the QName.equals() method,
          //this test passes without incurring a NullPointerException. 
          assert(!qname2.equals(qname1));
  
          assert(qname2.equals(qname3));
          assert(!qname3.equals(qname4));
      }
      
      public void testHashCode()
      {
          QName control = new QName("xsl", "text");
          QName compare = new QName("xsl", "text");
          QName contrast = new QName("xso", "text");
          assertEquals(control.hashCode(), compare.hashCode());
          assert(!(control.hashCode() == contrast.hashCode()));
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/TestXMLUtils.java
  
  Index: TestXMLUtils.java
  ===================================================================
  package test.utils;
  
  import junit.framework.*;
  import java.io.*;
  import org.apache.axis.utils.XMLUtils;
  import org.xml.sax.*;
  import org.w3c.dom.*;
  import javax.xml.parsers.*;
  
  public class TestXMLUtils extends TestCase
  {
  
      public TestXMLUtils (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestXMLUtils.class);
      }
  
      public void setup() {
      }
      
      public void testInit()
      {
          DocumentBuilderFactory dbf = XMLUtils.init();
          assert(dbf instanceof DocumentBuilderFactory);
      }
  
      public void testNewDocumentNoArgConstructor()
      {
          Document doc = XMLUtils.newDocument();
          assert(doc instanceof org.w3c.dom.Document);
      }
      
      public void testNewDocumentInputSource()
      {
          Reader reader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(reader);
          Document doc = XMLUtils.newDocument(inputsrc);
          assert(doc instanceof org.w3c.dom.Document);
      }
  
      public void testNewDocumentInputStream()
      {
          InputStream iostream = (InputStream)this.getTestXml("inputstream");
          InputSource inputsrc = new InputSource(iostream);
          Document doc = XMLUtils.newDocument(inputsrc);
          assert(doc instanceof org.w3c.dom.Document);
      }
     
      /* This test will fail unless you are connected to the Web, so just skip
      * it unless you really want to test it.  When not connected to the Web you
      * will get an UnknownHostException.
      */
      /*
      public void testNewDocumentURI()
      {
          String uri = "http://java.sun.com/j2ee/dtds/web-app_2.2.dtd";
          Document doc = XMLUtils.newDocument(uri);
          assert(doc instanceof org.w3c.dom.Document);
      }
      */
  
      public void testDocumentToString()
      {
          Reader reader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(reader);
          Document doc = XMLUtils.newDocument(inputsrc);
          
          String xmlString = (String)this.getTestXml("string");
          String result = XMLUtils.DocumentToString(doc);
          assertEquals(xmlString, result);
      }
      
      /**
      * This test method is somewhat complex, but it solves a problem people have
      * asked me about, which is how to unit test a method that has void return
      * type but writes its output to an output stream.  So half the reason for
      * creating and using it here is as a reference point.  <i>Note</i>, the
      * XMLUtils class does not omit the XML declaration when it does
      * ElementToStream, which is different behavior from its toString() method.
      * Might mention that to te developers.
      */
      public void testElementToStream() throws IOException
      {
          /* Get the Document and one of its elements. */ 
          Reader xmlReader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(xmlReader);
          Document doc = XMLUtils.newDocument(inputsrc);
          NodeList nl = doc.getElementsByTagName("display-name");
          Element elem = (Element)nl.item(0);
          String expected = "<display-name>Apache-Axis</display-name>";
         
          /*
          * Create a PipedOutputStream to get the output from the tested method. 
          * Pass the PipedOutputStream to the ConsumerPipe's constructor, which 
          * will create a PipedInputStream in a separate thread.
          */
          PipedOutputStream out = new PipedOutputStream();
          ConsumerPipe cpipe = new ConsumerPipe(out);
          
          /*
          * Call the method under test, passing the PipedOutStream to trap the
          * results.
          */
          XMLUtils.ElementToStream(elem, out);
  
          /*
          * The output of the test will be piped to ConsumerPipe's PipedInputStream, which
          * is used to read the bytes of the stream into an array.  It then creates a
          * String for comparison from that byte array.
          */
          out.flush();
          String result = cpipe.getResult();
          //don't forget to close this end of the pipe (ConsumerPipe closes the other end).
          out.close();
          
          /* 
          * Unlike toString(), the XML declaration is not ommitted so we check to
          * make sure it's there.
          */
          assert(result.startsWith("<?xml version=")); 
          assert(result.endsWith(expected));
      }
      
      /**
      * For explanation of the methodology used to test this method, see notes in
      * previous test method.
      */ 
      public void testDocumentToStream() throws IOException
      {
          Reader reader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(reader);
          Document doc = XMLUtils.newDocument(inputsrc);
          
          PipedOutputStream out = new PipedOutputStream();
          ConsumerPipe cpipe = new ConsumerPipe(out);
         
          XMLUtils.DocumentToStream(doc, out);
          out.flush();
          String result = cpipe.getResult();
          out.close();
          
          String expected = (String)this.getTestXml("string");
          assertEquals(expected, result);
      }
  
      public void testElementToString()
      {
          Reader reader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(reader);
          Document doc = XMLUtils.newDocument(inputsrc);
          
          NodeList nl = doc.getElementsByTagName("display-name");
          Element elem = (Element)nl.item(0);
          String expected = "<display-name>Apache-Axis</display-name>";
          String result = XMLUtils.ElementToString(elem);
          assertEquals("display-name", elem.getTagName());
          assertEquals(expected, result);
      }
      
      public void testGetInnerXMLString()
      {
          Reader reader = (Reader)this.getTestXml("reader");
          InputSource inputsrc = new InputSource(reader);
          Document doc = XMLUtils.newDocument(inputsrc);
          
          NodeList nl = doc.getElementsByTagName("display-name");
          Element elem = (Element)nl.item(0);
          String expected = "Apache-Axis";
          String result = XMLUtils.getInnerXMLString(elem);
          assertEquals(expected, result);
      }
          
      public void testGetPrefix()
      {
          Document doc = XMLUtils.newDocument();
         
          Element elem = doc.createElement("svg"); 
          elem.setAttribute("xmlns:svg", "\"http://www.w3.org/2000/svg\""); 
          elem.setAttribute("xmlns:xlink", "\"http://www.w3.org/1999/xlink\""); 
          elem.setAttribute("xmlns:xhtml", "\"http://www.w3.org/1999/xhtml\""); 
          
          String expected = "svg";
          String result = XMLUtils.getPrefix("\"http://www.w3.org/2000/svg\"", elem);
          assertEquals(expected, result);
          expected = "xlink";
          result = XMLUtils.getPrefix("\"http://www.w3.org/1999/xlink\"", elem);
          assertEquals(expected, result);
          expected = "xhtml";
          result = XMLUtils.getPrefix("\"http://www.w3.org/1999/xhtml\"", elem);
          assertEquals(expected, result);
      }
      
      public void testGetNamespace()
      {
          Document doc = XMLUtils.newDocument();
         
          Element elem = doc.createElement("svg"); 
          elem.setAttribute("xmlns:svg", "\"http://www.w3.org/2000/svg\""); 
          
          String expected = "\"http://www.w3.org/2000/svg\"";
          String result = XMLUtils.getNamespace("svg", elem);
          assertEquals(expected, result);
      }
      
      /**
      * This is a utility method for creating XML document input sources for this
      * JUnit test class.  The returned Object should be cast to the type you
      * request via the gimme parameter.
      *
      * @param gimme A String specifying the underlying type you want the XML
      * input source returned as; one of "string", "reader", or "inputstream."
      */
      public Object getTestXml(String gimme)
      {
          StringBuffer sb = new StringBuffer();
            sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
          //The System ID will cause an unknown host exception unless you are
          //connected to the Internet, so comment it out for testing.
            //.append("<!DOCTYPE web-app PUBLIC \"-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN\"\n")
            //.append("\"http://java.sun.com/j2ee/dtds/web-app_2.2.dtd\">\n")
            .append("<web-app>\n")
            .append("<display-name>Apache-Axis</display-name>\n") 
            .append("<servlet>\n") 
            .append("<servlet-name>AxisServlet</servlet-name>\n") 
            .append("<display-name>Apache-Axis Servlet</display-name>\n") 
            .append("<servlet-class>\n") 
            .append("org.apache.axis.transport.http.AxisServlet\n") 
            .append("</servlet-class>\n") 
            .append("</servlet>\n") 
            .append("<servlet-mapping>\n") 
            .append("<servlet-name>AxisServlet</servlet-name>\n") 
            .append("<url-pattern>servlet/AxisServlet</url-pattern>\n") 
            .append("<url-pattern>*.jws</url-pattern>\n") 
            .append("</servlet-mapping>\n") 
            .append("</web-app>");
  
          String xmlString = sb.toString();
          
          if (gimme.equals("string"))
          {
              return xmlString;
          }
          else if (gimme.equals("reader"))
          { 
              StringReader strReader = new StringReader(xmlString);
              return strReader;
          }
          else if (gimme.equals("inputstream"))
          {
              ByteArrayInputStream byteStream = new ByteArrayInputStream(xmlString.getBytes());
              return byteStream;
          }
          else return null;
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/cache/PackageTests.java
  
  Index: PackageTests.java
  ===================================================================
  package test.utils.cache;
  
  import junit.framework.TestCase;
  import junit.framework.Test;
  import junit.framework.TestSuite;
  
  /**
   */
  public class PackageTests
  {
      public static void main (String[] args) {
              junit.textui.TestRunner.run (suite());
      }
  
      public static Test suite()
      {
          TestSuite suite = new TestSuite("All axis.utils.cache tests");
  
          suite.addTest(TestJavaClass.suite());
          suite.addTest(TestJavaMethod.suite());
  
          return suite;
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/cache/TestJavaClass.java
  
  Index: TestJavaClass.java
  ===================================================================
  package test.utils.cache;
  
  import junit.framework.*;
  import org.apache.axis.utils.cache.JavaClass;
  import java.lang.reflect.Method;
  
  public class TestJavaClass extends TestCase
  {
      public TestJavaClass (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestJavaClass.class);
      }
      
      protected void setup() {
      }
  
      public void testGetJavaClass()
      {
          Class c = new java.util.Date().getClass(); 
          JavaClass jc = new JavaClass(c);
          assertNotNull(jc);
          assert(jc.getJavaClass().getName().equals("java.util.Date"));
          assert(!jc.getJavaClass().getName().equals("java.util.D"));
      }
  
      public void testGetMethod()
      {
          Class v = new java.util.Vector().getClass(); 
          Class st = new java.util.StringTokenizer("some string").getClass();
          JavaClass jcVec = new JavaClass(v);
          JavaClass jcST = new JavaClass(st);
  
          Method countTkns = jcST.getMethod("countTokens", 1);
          Method nextTkn = jcST.getMethod("nextToken", 1);
  
          Method add1 = jcVec.getMethod("add", 1);
          Method add2 = jcVec.getMethod("add", 2);
  
          assertEquals("countTokens", countTkns.getName());
          assertEquals("nextToken", nextTkn.getName());
  
          assertEquals("boolean", add1.getReturnType().getName());
          assertEquals("void", add2.getReturnType().getName());
      }
  }
  
  
  
  1.1                  xml-axis/java/test/utils/cache/TestJavaMethod.java
  
  Index: TestJavaMethod.java
  ===================================================================
  package test.utils.cache;
  
  import junit.framework.*;
  import org.apache.axis.utils.cache.JavaMethod;
  import java.lang.reflect.Method;
  
  public class TestJavaMethod extends TestCase
  {
      public TestJavaMethod (String name) {
          super(name);
      }
  
      public static Test suite() {
          return new TestSuite(TestJavaMethod.class);
      }
  
      protected void setup() {
      }
  
      public void testGetMethodWithVectorMethods()
      {
          Class vector = new java.util.Vector().getClass(); 
          JavaMethod jmAdd = new JavaMethod(vector, "add");
          assertNotNull(jmAdd);
          
          Method methodWithOneParam = jmAdd.getMethod(1);
          assertEquals("add", methodWithOneParam.getName());
          Method methodWithTwoParams = jmAdd.getMethod(2);
          assertEquals("add", methodWithTwoParams.getName());
  
          assertEquals("boolean", methodWithOneParam.getReturnType().getName());
          assertEquals("void", methodWithTwoParams.getReturnType().getName());
          
          boolean gotError = false;
          try {
              Method nonceMethod = jmAdd.getMethod(0); //should be no add() method with 0 params
              nonceMethod.getName();
          }
          catch (NullPointerException ex) {
              gotError = true;
          }
          assert("Expected NullPointerException", gotError);
  
          //on the other hand, make sure methods with 0 params work...
          JavaMethod jmCapacity = new JavaMethod(vector, "capacity");
          Method methodWithNoParams = jmCapacity.getMethod(0);
          assertEquals("capacity", methodWithNoParams.getName());
      }
      
      public void testGetMethodWithOverloadedStringValueOf()
      {
          Class str = new String().getClass(); 
          JavaMethod jm = new JavaMethod(str, "valueOf");
          assertNotNull(jm);
          
          Method methodWithOneParam = jm.getMethod(1);
          assertEquals("valueOf",methodWithOneParam.getName());
          Method methodWithThreeParams = jm.getMethod(3);
          assertEquals("valueOf",methodWithThreeParams.getName());
  
          assertEquals("java.lang.String", methodWithOneParam.getReturnType().getName());
          assertEquals("java.lang.String", methodWithThreeParams.getReturnType().getName());
          
          boolean gotError = false;
          try {
              Method nonceMethod = jm.getMethod(2); //should be no valueOf() method with 2 params
              nonceMethod.getName();
          }
          catch (NullPointerException ex) {
              gotError = true;
          }
          assert("Expected NullPointerException", gotError);
      }
  }