commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/lang/src/java/org/apache/commons/lang ClassUtils.java
Date Sun, 15 Dec 2002 19:36:08 GMT
scolebourne    2002/12/15 11:36:08

  Modified:    lang/src/test/org/apache/commons/lang LangTestSuite.java
               lang/src/java/org/apache/commons/lang ClassUtils.java
  Added:       lang/src/test/org/apache/commons/lang ClassUtilsTest.java
  Log:
  Test the ClassUtils class
  
  Revision  Changes    Path
  1.8       +2 -1      jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java
  
  Index: LangTestSuite.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- LangTestSuite.java	15 Dec 2002 16:55:32 -0000	1.7
  +++ LangTestSuite.java	15 Dec 2002 19:36:08 -0000	1.8
  @@ -89,6 +89,7 @@
           suite.addTest(ArrayUtilsTest.suite());
           suite.addTest(BooleanUtilsTest.suite());
           suite.addTest(CharSetUtilsTest.suite());
  +        suite.addTest(ClassUtilsTest.suite());
           suite.addTest(NumberRangeTest.suite());
           suite.addTest(NumberUtilsTest.suite());
           suite.addTest(ObjectUtilsTest.suite());
  
  
  
  1.1                  jakarta-commons/lang/src/test/org/apache/commons/lang/ClassUtilsTest.java
  
  Index: ClassUtilsTest.java
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2002 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Commons", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package org.apache.commons.lang;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import junit.textui.TestRunner;
  /**
   * Unit tests {@link org.apache.commons.lang.ClassUtils}.
   *
   * @author Stephen Colebourne
   * @version $Id: ClassUtilsTest.java,v 1.1 2002/12/15 19:36:08 scolebourne Exp $
   */
  public class ClassUtilsTest extends TestCase {
  
      public ClassUtilsTest(String name) {
          super(name);
      }
  
      public static void main(String[] args) {
          TestRunner.run(suite());
      }
  
      public static Test suite() {
      	TestSuite suite = new TestSuite(ClassUtilsTest.class);
      	suite.setName("ClassUtils Tests");
          return suite;
      }
  
      protected void setUp() throws Exception {
          super.setUp();
      }
  
      protected void tearDown() throws Exception {
          super.tearDown();
      }
  
      private static class Inner {
      }
      
      // -------------------------------------------------------------------------
      public void test_getShortClassName_Object() {
          assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>"));
          assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
          assertEquals("String", ClassUtils.getShortClassName("hello", "<null>"));
          assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>"));
      }
      
      public void test_getShortClassName_Class() {
          assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class));
          assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class));
          try {
              ClassUtils.getShortClassName((Class) null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_getShortClassName_String() {
          assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName()));
          assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName()));
          try {
              ClassUtils.getShortClassName((String) null);
              fail();
          } catch (IllegalArgumentException ex) {}
          try {
              ClassUtils.getShortClassName("");
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      // -------------------------------------------------------------------------
      public void test_getPackageName_Object() {
          assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new ClassUtils(),
"<null>"));
          assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new Inner(), "<null>"));
          assertEquals("<null>", ClassUtils.getPackageName(null, "<null>"));
      }
      
      public void test_getPackageName_Class() {
          assertEquals("java.lang", ClassUtils.getPackageName(String.class));
          assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class));
          try {
              ClassUtils.getPackageName((Class) null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_getPackageName_String() {
          assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(ClassUtils.class.getName()));
          assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName()));
          try {
              ClassUtils.getPackageName((String) null);
              fail();
          } catch (IllegalArgumentException ex) {}
          try {
              ClassUtils.getPackageName("");
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      // -------------------------------------------------------------------------
      public void test_getAllSuperclasses_Class() {
          List list = ClassUtils.getAllSuperclasses(CY.class);
          assertEquals(2, list.size());
          assertEquals(CX.class, list.get(0));
          assertEquals(Object.class, list.get(1));
          try {
              ClassUtils.getAllSuperclasses(null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_getAllInterfaces_Class() {
          List list = ClassUtils.getAllInterfaces(CY.class);
          assertEquals(6, list.size());
          assertEquals(IB.class, list.get(0));
          assertEquals(IC.class, list.get(1));
          assertEquals(ID.class, list.get(2));
          assertEquals(IE.class, list.get(3));
          assertEquals(IF.class, list.get(4));
          assertEquals(IA.class, list.get(5));
          try {
              ClassUtils.getAllInterfaces(null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      private static interface IA {
      }
      private static interface IB {
      }
      private static interface IC extends ID, IE {
      }
      private static interface ID {
      }
      private static interface IE extends IF {
      }
      private static interface IF {
      }
      private static class CX implements IB, IA, IE {
      }
      private static class CY extends CX implements IB, IC {
      }
      
      // -------------------------------------------------------------------------
      public void test_convertClassNamesToClasses_List() {
          List list = new ArrayList();
          List result = ClassUtils.convertClassNamesToClasses(list);
          assertEquals(0, result.size());
          
          list.add("java.lang.String");
          list.add("java.lang.xxx");
          list.add("java.lang.Object");
          result = ClassUtils.convertClassNamesToClasses(list);
          assertEquals(3, result.size());
          assertEquals(String.class, result.get(0));
          assertEquals(null, result.get(1));
          assertEquals(Object.class, result.get(2));
  
          list.add(new Object());
          try {
              ClassUtils.convertClassNamesToClasses(list);
              fail();
          } catch (ClassCastException ex) {}
          
          try {
              ClassUtils.convertClassNamesToClasses(null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      public void test_convertClassesToClassNames_List() {
          List list = new ArrayList();
          List result = ClassUtils.convertClassesToClassNames(list);
          assertEquals(0, result.size());
          
          list.add(String.class);
          list.add(Object.class);
          result = ClassUtils.convertClassesToClassNames(list);
          assertEquals(2, result.size());
          assertEquals("java.lang.String", result.get(0));
          assertEquals("java.lang.Object", result.get(1));
  
          list.add(new Object());
          try {
              ClassUtils.convertClassesToClassNames(list);
              fail();
          } catch (ClassCastException ex) {}
          
          try {
              ClassUtils.convertClassesToClassNames(null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      // -------------------------------------------------------------------------
      public void test_isInnerClass_Class() {
          assertEquals(true, ClassUtils.isInnerClass(Inner.class));
          assertEquals(true, ClassUtils.isInnerClass(Map.Entry.class));
          assertEquals(false, ClassUtils.isInnerClass(this.getClass()));
          assertEquals(false, ClassUtils.isInnerClass(String.class));
          try {
              ClassUtils.isInnerClass(null);
              fail();
          } catch (IllegalArgumentException ex) {}
      }
      
      // -------------------------------------------------------------------------
      public void test_isAssignable_ClassArray_ClassArray() throws Exception {
          Class[] array2 = new Class[] {Object.class, Object.class};
          Class[] array1 = new Class[] {Object.class};
          Class[] array1s = new Class[] {String.class};
          Class[] array0 = new Class[] {};
  
          assertEquals(false, ClassUtils.isAssignable(array1, array2));
          assertEquals(false, ClassUtils.isAssignable(null, array2));
          assertEquals(true, ClassUtils.isAssignable(null, array0));
          assertEquals(true, ClassUtils.isAssignable(array0, array0));
          assertEquals(true, ClassUtils.isAssignable(array0, null));
          assertEquals(true, ClassUtils.isAssignable((Class[]) null, (Class[]) null));
          
          assertEquals(false, ClassUtils.isAssignable(array1, array1s));
          assertEquals(true, ClassUtils.isAssignable(array1s, array1s));
          assertEquals(true, ClassUtils.isAssignable(array1s, array1));
      }
      
      public void test_isAssignable() throws Exception {
          try {
              ClassUtils.isAssignable(String.class, null);
              fail();
          } catch (IllegalArgumentException ex) {}
          try {
              ClassUtils.isAssignable((Class) null, (Class) null);
              fail();
          } catch (IllegalArgumentException ex) {}
          assertEquals(true, ClassUtils.isAssignable(null, Object.class));
          assertEquals(true, ClassUtils.isAssignable(null, Integer.class));
          assertEquals(false, ClassUtils.isAssignable(null, Integer.TYPE));
          assertEquals(true, ClassUtils.isAssignable(String.class, Object.class));
          assertEquals(true, ClassUtils.isAssignable(String.class, String.class));
          assertEquals(false, ClassUtils.isAssignable(Object.class, String.class));
          assertEquals(false, ClassUtils.isAssignable(Integer.TYPE, Integer.class));
          assertEquals(false, ClassUtils.isAssignable(Integer.class, Integer.TYPE));
          assertEquals(true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
          assertEquals(true, ClassUtils.isAssignable(Integer.class, Integer.class));
      }
      
      public void test_isAssignable_Widening() throws Exception {
          // test byte conversions
          assertEquals("byte -> char", false, ClassUtils.isAssignable(Byte.TYPE, Character.TYPE));
          assertEquals("byte -> byte", true, ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE));
          assertEquals("byte -> short", true, ClassUtils.isAssignable(Byte.TYPE, Short.TYPE));
          assertEquals("byte -> int", true, ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE));
          assertEquals("byte -> long", true, ClassUtils.isAssignable(Byte.TYPE, Long.TYPE));
          assertEquals("byte -> float", true, ClassUtils.isAssignable(Byte.TYPE, Float.TYPE));
          assertEquals("byte -> double", true, ClassUtils.isAssignable(Byte.TYPE, Double.TYPE));
          assertEquals("byte -> boolean", false, ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE));
          
          // test short conversions
          assertEquals("short -> char", false, ClassUtils.isAssignable(Short.TYPE, Character.TYPE));
          assertEquals("short -> byte", false, ClassUtils.isAssignable(Short.TYPE, Byte.TYPE));
          assertEquals("short -> short", true, ClassUtils.isAssignable(Short.TYPE, Short.TYPE));
          assertEquals("short -> int", true, ClassUtils.isAssignable(Short.TYPE, Integer.TYPE));
          assertEquals("short -> long", true, ClassUtils.isAssignable(Short.TYPE, Long.TYPE));
          assertEquals("short -> float", true, ClassUtils.isAssignable(Short.TYPE, Float.TYPE));
          assertEquals("short -> double", true, ClassUtils.isAssignable(Short.TYPE, Double.TYPE));
          assertEquals("short -> boolean", false, ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE));
          
          // test char conversions
          assertEquals("char -> char", true, ClassUtils.isAssignable(Character.TYPE, Character.TYPE));
          assertEquals("char -> byte", false, ClassUtils.isAssignable(Character.TYPE, Byte.TYPE));
          assertEquals("char -> short", false, ClassUtils.isAssignable(Character.TYPE,
Short.TYPE));
          assertEquals("char -> int", true, ClassUtils.isAssignable(Character.TYPE, Integer.TYPE));
          assertEquals("char -> long", true, ClassUtils.isAssignable(Character.TYPE, Long.TYPE));
          assertEquals("char -> float", true, ClassUtils.isAssignable(Character.TYPE, Float.TYPE));
          assertEquals("char -> double", true, ClassUtils.isAssignable(Character.TYPE,
Double.TYPE));
          assertEquals("char -> boolean", false, ClassUtils.isAssignable(Character.TYPE,
Boolean.TYPE));
          
          // test int conversions
          assertEquals("int -> char", false, ClassUtils.isAssignable(Integer.TYPE, Character.TYPE));
          assertEquals("int -> byte", false, ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE));
          assertEquals("int -> short", false, ClassUtils.isAssignable(Integer.TYPE, Short.TYPE));
          assertEquals("int -> int", true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
          assertEquals("int -> long", true, ClassUtils.isAssignable(Integer.TYPE, Long.TYPE));
          assertEquals("int -> float", true, ClassUtils.isAssignable(Integer.TYPE, Float.TYPE));
          assertEquals("int -> double", true, ClassUtils.isAssignable(Integer.TYPE, Double.TYPE));
          assertEquals("int -> boolean", false, ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE));
   
          // test long conversions
          assertEquals("long -> char", false, ClassUtils.isAssignable(Long.TYPE, Character.TYPE));
          assertEquals("long -> byte", false, ClassUtils.isAssignable(Long.TYPE, Byte.TYPE));
          assertEquals("long -> short", false, ClassUtils.isAssignable(Long.TYPE, Short.TYPE));
          assertEquals("long -> int", false, ClassUtils.isAssignable(Long.TYPE, Integer.TYPE));
          assertEquals("long -> long", true, ClassUtils.isAssignable(Long.TYPE, Long.TYPE));
          assertEquals("long -> float", true, ClassUtils.isAssignable(Long.TYPE, Float.TYPE));
          assertEquals("long -> double", true, ClassUtils.isAssignable(Long.TYPE, Double.TYPE));
          assertEquals("long -> boolean", false, ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE));
   
          // test float conversions
          assertEquals("float -> char", false, ClassUtils.isAssignable(Float.TYPE, Character.TYPE));
          assertEquals("float -> byte", false, ClassUtils.isAssignable(Float.TYPE, Byte.TYPE));
          assertEquals("float -> short", false, ClassUtils.isAssignable(Float.TYPE, Short.TYPE));
          assertEquals("float -> int", false, ClassUtils.isAssignable(Float.TYPE, Integer.TYPE));
          assertEquals("float -> long", false, ClassUtils.isAssignable(Float.TYPE, Long.TYPE));
          assertEquals("float -> float", true, ClassUtils.isAssignable(Float.TYPE, Float.TYPE));
          assertEquals("float -> double", true, ClassUtils.isAssignable(Float.TYPE, Double.TYPE));
          assertEquals("float -> boolean", false, ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE));
          
          // test float conversions
          assertEquals("double -> char", false, ClassUtils.isAssignable(Double.TYPE, Character.TYPE));
          assertEquals("double -> byte", false, ClassUtils.isAssignable(Double.TYPE, Byte.TYPE));
          assertEquals("double -> short", false, ClassUtils.isAssignable(Double.TYPE, Short.TYPE));
          assertEquals("double -> int", false, ClassUtils.isAssignable(Double.TYPE, Integer.TYPE));
          assertEquals("double -> long", false, ClassUtils.isAssignable(Double.TYPE, Long.TYPE));
          assertEquals("double -> float", false, ClassUtils.isAssignable(Double.TYPE, Float.TYPE));
          assertEquals("double -> double", true, ClassUtils.isAssignable(Double.TYPE, Double.TYPE));
          assertEquals("double -> boolean", false, ClassUtils.isAssignable(Double.TYPE,
Boolean.TYPE));
          
          // test float conversions
          assertEquals("boolean -> char", false, ClassUtils.isAssignable(Boolean.TYPE,
Character.TYPE));
          assertEquals("boolean -> byte", false, ClassUtils.isAssignable(Boolean.TYPE,
Byte.TYPE));
          assertEquals("boolean -> short", false, ClassUtils.isAssignable(Boolean.TYPE,
Short.TYPE));
          assertEquals("boolean -> int", false, ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE));
          assertEquals("boolean -> long", false, ClassUtils.isAssignable(Boolean.TYPE,
Long.TYPE));
          assertEquals("boolean -> float", false, ClassUtils.isAssignable(Boolean.TYPE,
Float.TYPE));
          assertEquals("boolean -> double", false, ClassUtils.isAssignable(Boolean.TYPE,
Double.TYPE));
          assertEquals("boolean -> boolean", true, ClassUtils.isAssignable(Boolean.TYPE,
Boolean.TYPE));
      }
      
  //    public static List getAssignableFrom(List classes, Class superclass) {
  //    public static boolean isAssignable(Class[] classArray, Class[] toClassArray) {
  //    public static boolean isAssignable(Class cls, Class toClass) {
  }
  
  
  
  1.6       +75 -73    jakarta-commons/lang/src/java/org/apache/commons/lang/ClassUtils.java
  
  Index: ClassUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/ClassUtils.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- ClassUtils.java	16 Nov 2002 10:41:03 -0000	1.5
  +++ ClassUtils.java	15 Dec 2002 19:36:08 -0000	1.6
  @@ -79,8 +79,21 @@
       // -------------------------------------------------------------------------
       
       /**
  -     * <p>Gets the class name minus the package name from a
  -     * <code>Class</code>.</p>
  +     * <p>Gets the class name minus the package name for an <code>Object</code>.</p>
  +     * 
  +     * @param object  the class to get the short name for
  +     * @param valueIfNull  the value to return if null
  +     * @return the class name of the object without the package name, or the null value
  +     */
  +    public static String getShortClassName(Object object, String valueIfNull) {
  +        if (object == null) {
  +            return valueIfNull;
  +        }
  +        return getShortClassName(object.getClass().getName());
  +    }
  +    
  +    /**
  +     * <p>Gets the class name minus the package name from a <code>Class</code>.</p>
        * 
        * @param cls  the class to get the short name for, must not be
        *  <code>null</code>
  @@ -95,22 +108,6 @@
       }
       
       /**
  -     * <p>Gets the class name minus the package name for an
  -     * <code>Object</code>.</p>
  -     * 
  -     * @param object  the class to get the short name for, must not be
  -     *  <code>null</code>
  -     * @return the class name of the object without the package name
  -     * @throws IllegalArgumentException if the object is <code>null</code>
  -     */
  -    public static String getShortClassName(Object object) {
  -        if (object == null) {
  -            throw new IllegalArgumentException("The object must not be null");
  -        }
  -        return getShortClassName(object.getClass().getName());
  -    }
  -    
  -    /**
        * <p>Gets the class name minus the package name from a String.</p>
        *
        * <p>The string passed in is assumed to be a class name - it is not checked.</p>
  @@ -138,6 +135,20 @@
       // -------------------------------------------------------------------------
       
       /**
  +     * <p>Gets the package name of an <code>Object</code>.</p>
  +     * 
  +     * @param object  the class to get the package name for
  +     * @param valueIfNull  the value to return if null
  +     * @return the package name of the object, or the null value
  +     */
  +    public static String getPackageName(Object object, String valueIfNull) {
  +        if (object == null) {
  +            return valueIfNull;
  +        }
  +        return getPackageName(object.getClass().getName());
  +    }
  +    
  +    /**
        * <p>Gets the package name of a <code>Class</code>.</p>
        * 
        * @param cls  the class to get the package name for, must not be
  @@ -153,21 +164,6 @@
       }
       
       /**
  -     * <p>Gets the package name of an <code>Object</code>.</p>
  -     * 
  -     * @param object  the class to get the package name for, must not be
  -     *  <code>null</code>
  -     * @return the package name
  -     * @throws IllegalArgumentException if the object is <code>null</code>
  -     */
  -    public static String getPackageName(Object object) {
  -        if (object == null) {
  -            throw new IllegalArgumentException("The object must not be null");
  -        }
  -        return getPackageName(object.getClass().getName());
  -    }
  -    
  -    /**
        * <p>Gets the package name from a <code>String</code>.</p>
        *
        * <p>The string passed in is assumed to be a class name - it is not checked.</p>
  @@ -211,11 +207,12 @@
       
       /**
        * <p>Gets a <code>List</code> of all interfaces implemented by the
given
  -     * class.</p>
  +     * class and its superclasses.</p>
        *
        * <p>The order is determined by looking through each interface in turn as
  -     * declared in the source file and following its hieracrchy up. Later
  -     * duplicates are ignored, so the order is maintained.</p>
  +     * declared in the source file and following its hieracrchy up. Then each 
  +     * superclass is considered in the same way. Later duplicates are ignored, 
  +     * so the order is maintained.</p>
        * 
        * @param cls  the class to look up, must not be <code>null</code>
        * @return the <code>List</code> of interfaces in order
  @@ -226,18 +223,21 @@
               throw new IllegalArgumentException("The class must not be null");
           }
           List list = new ArrayList();
  -        Class[] interfaces = cls.getInterfaces();
  -        for (int i = 0; i < interfaces.length; i++) {
  -            if (list.contains(interfaces[i]) == false) {
  -                list.add(interfaces[i]);
  -            }
  -            List superInterfaces = getAllInterfaces(interfaces[i]);
  -            for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
  -                Class intface = (Class) it.next();
  -                if (list.contains(intface) == false) {
  -                    list.add(intface);
  +        while (cls != null) {
  +            Class[] interfaces = cls.getInterfaces();
  +            for (int i = 0; i < interfaces.length; i++) {
  +                if (list.contains(interfaces[i]) == false) {
  +                    list.add(interfaces[i]);
  +                }
  +                List superInterfaces = getAllInterfaces(interfaces[i]);
  +                for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
  +                    Class intface = (Class) it.next();
  +                    if (list.contains(intface) == false) {
  +                        list.add(intface);
  +                    }
                   }
               }
  +            cls = cls.getSuperclass();
           }
           return list;
       }
  @@ -295,17 +295,18 @@
   //        return null;
   //    }
   
  +    // -------------------------------------------------------------------------
  +    
       /**
        * <p>Given a <code>List</code> of class names, this method converts
them into classes.     *
        * A new <code>List</code> is returned. If the class name cannot be found,
<code>null</code>
        * is stored in the <code>List</code>. If the class name in the <code>List</code>
is
        * <code>null</code>, <code>null</code> is stored in the output
<code>List</code>.</p>
        * 
  -     * @param classNames  the classNames to change, the class is stored back
  -     *  into the <code>List</code>. <code>null</code> will be stored
in the <code>List</code>
  -     *  if no class is found.
  -     * @return the <code>List</code> of Class objects corresponding to the
class names
  +     * @param classNames  the classNames to change
  +     * @return a <code>List</code> of Class objects corresponding to the class
names
        * @throws IllegalArgumentException if the classNames is <code>null</code>
  +     * @throws ClassCastException if classNames contains a non String entry
        */
       public static List convertClassNamesToClasses(List classNames) {
           if (classNames == null) {
  @@ -324,40 +325,41 @@
       }
       
       /**
  -     * <p>Given a <code>List</code> of classes, this method finds all
those which
  -     * are subclasses or implementations of a specified superclass.</p>
  +     * <p>Given a <code>List</code> of <code>Class</code>
objects, this method converts
  +     * them into class names.
  +     * A new <code>List</code> is returned. <code>null</code> objects
will be copied into
  +     * the returned list as <code>null</code>.</p>
        * 
  -     * @param classes  the classes to check
  -     * @param superclass  the superclass to check for
  -     * @return the list of subclasses or implementations
  -     * @throws IllegalArgumentException if the classes or superClass is <code>null</code>
  +     * @param classes  the classes to change
  +     * @return a <code>List</code> of Class objects corresponding to the class
names
  +     * @throws IllegalArgumentException if the classNames is <code>null</code>
  +     * @throws ClassCastException if classNames contains a non Class or null entry
        */
  -    public static List getAssignableFrom(List classes, Class superclass) {
  +    public static List convertClassesToClassNames(List classes) {
           if (classes == null) {
  -            throw new IllegalArgumentException("The classes must not be null");
  +            throw new IllegalArgumentException("The classes list must not be null");
           }
  -        if (superclass == null) {
  -            throw new IllegalArgumentException("The superclass must not be null");
  -        }
  -        List subs = new ArrayList();
  -        Iterator it = classes.iterator();
  -        while (it.hasNext()) {
  +        List classNames = new ArrayList(classes.size());
  +        for (Iterator it = classes.iterator(); it.hasNext();) {
               Class cls = (Class) it.next();
               if (cls == null) {
  -                throw new IllegalArgumentException("The class list must not contain nulls");
  -            }
  -            if (isAssignable(cls, superclass)) {
  -                subs.add(cls);
  +                classNames.add(null);
  +            } else {
  +                classNames.add(cls.getName());
               }
           }
  -        return subs;
  +        return classNames;
       }
  -
  +    
  +    // -------------------------------------------------------------------------
  +    
       /**
        * <p>Checks if an array of Classes can be assigned to another array of Classes.</p>
        *
  -     * <p>This can be used to check if parameter types are suitably compatable for
  -     * reflection invocation.</p>
  +     * <p>This method calls {@link #isAssignable(Class, Class) isAssignable} for
each
  +     * Class pair in the input arrays. It can be used to check if a set of arguments
  +     * (the first parameter) are suitably compatable with a set of method parameter types
  +     * (the second parameter).</p>
        *
        * <p>Unlike the {@link Class#isAssignableFrom(java.lang.Class)} method, this
        * method takes into account widenings of primitive classes and
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message