    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.commons;
    18
    19  import junit.framework.TestCase;
    20  import org.apache.commons.vfs.FileSystemException;
    21  import org.apache.commons.vfs.util.Messages;
    22
    23  import java.io.File;
    24  import java.io.IOException;
    25  import java.lang.reflect.Method;
    26
    27  /***
    28   * A base class for VFS tests.  Provides utility methods for locating
    29   * test resources.
    30   *
    31   * @author <a href="mailto:adammurdoch@apache.org">Adam Murdoch</a>
    32   * @version $Revision: 485757 $ $Date: 2006-12-11 18:14:29 +0100 (Mo, 11 Dez 2006) $
    33   */
    34  public abstract class AbstractVfsTestCase
    35      extends TestCase
    36  {
    37      private static File baseDir;
    38
    39      /***
    40       * Returns the name of the package containing a class.
    41       *
    42       * @return The . delimited package name, or an empty string if the class
    43       *         is in the default package.
    44       */
    45      public static String getPackageName(final Class clazz)
    46      {
    47          final Package pkg = clazz.getPackage();
    48          if (null != pkg)
    49          {
    50              return pkg.getName();
    51          }
    52
    53          final String name = clazz.getName();
    54          if (-1 == name.lastIndexOf("."))
    55          {
    56              return "";
    57          }
    58          else
    59          {
    60              return name.substring(0, name.lastIndexOf("."));
    61          }
    62      }
    63
    64      /***
    65       * Locates a test resource, and asserts that the resource exists
    66       *
    67       * @param name path of the resource, relative to this test's base directory.
    68       */
    69      public static File getTestResource(final String name)
    70      {
    71          return getTestResource(name, true);
    72      }
    73
    74      /***
    75       * Locates a test resource.
    76       *
    77       * @param name path of the resource, relative to this test's base directory.
    78       */
    79      public static File getTestResource(final String name, final boolean mustExist)
    80      {
    81          File file = new File(getTestDirectoryFile(), name);
    82          file = getCanonicalFile(file);
    83          if (mustExist)
    84          {
    85              assertTrue("Test file \"" + file + "\" does not exist.", file.exists());
    86          }
    87          else
    88          {
    89              assertTrue("Test file \"" + file + "\" should not exist.", !file.exists());
    90          }
    91
    92          return file;
    93      }
    94
    95      /***
    96       * Locates the base directory for this test.
    97       */
    98      public static File getTestDirectoryFile()
    99      {
    100         if (baseDir == null)
    101         {
    102             // final String baseDirProp = System.getProperty("test.basedir");
    103             final String baseDirProp = getTestDirectory();
    104             baseDir = getCanonicalFile(new File(baseDirProp));
    105         }
    106         return baseDir;
    107     }
    108
    109     public static String getTestDirectory()
    110     {
    111         return System.getProperty("test.basedir");
    112     }
    113
    114 	public static String getResourceTestDirectory()
    115 	{
    116 		return System.getProperty("test.basedir.res");
    117 	}
    118
    119 	/***
    120      * Locates a test directory, creating it if it does not exist.
    121      *
    122      * @param name path of the directory, relative to this test's base directory.
    123      */
    124     public static File getTestDirectory(final String name)
    125     {
    126         File file = new File(getTestDirectoryFile(), name);
    127         file = getCanonicalFile(file);
    128         assertTrue("Test directory \"" + file + "\" does not exist or is not a directory.",
    129             file.isDirectory() || file.mkdirs());
    130         return file;
    131     }
    132
    133     /***
    134      * Makes a file canonical
    135      */
    136     public static File getCanonicalFile(final File file)
    137     {
    138         try
    139         {
    140             return file.getCanonicalFile();
    141         }
    142         catch (IOException e)
    143         {
    144             return file.getAbsoluteFile();
    145         }
    146     }
    147
    148     /***
    149      * Asserts that an exception chain contains the expected messages.
    150      *
    151      * @param messages The messages, in order.  A null entry in this array
    152      *                 indicates that the message should be ignored.
    153      */
    154     public static void assertSameMessage(final String[] messages, final Throwable throwable)
    155     {
    156         Throwable current = throwable;
    157         for (int i = 0; i < messages.length; i++)
    158         {
    159             String message = messages[i];
    160             assertNotNull(current);
    161             if (message != null)
    162             {
    163                 assertEquals(message, current.getMessage());
    164             }
    165
    166             // Get the next exception in the chain
    167             current = getCause(current);
    168         }
    169     }
    170
    171     /***
    172      * Returns the cause of an exception.
    173      */
    174     public static Throwable getCause(Throwable throwable)
    175     {
    176         try
    177         {
    178             Method method = throwable.getClass().getMethod("getCause", null);
    179             return (Throwable) method.invoke(throwable, null);
    180         }
    181         catch (Exception e)
    182         {
    183             return null;
    184         }
    185     }
    186
    187     /***
    188      * Asserts that an exception contains the expected message.
    189      */
    190     public static void assertSameMessage(final String code,
    191                                          final Throwable throwable)
    192     {
    193         assertSameMessage(code, new Object[0], throwable);
    194     }
    195
    196     /***
    197      * Asserts that an exception contains the expected message.
    198      */
    199     public static void assertSameMessage(final String code,
    200                                          final Object[] params,
    201                                          final Throwable throwable)
    202     {
    203         if (throwable instanceof FileSystemException)
    204         {
    205             final FileSystemException fse = (FileSystemException) throwable;
    206
    207             // Compare message code and params
    208             assertEquals(code, fse.getCode());
    209             assertEquals(params.length, fse.getInfo().length);
    210             for (int i = 0; i < params.length; i++)
    211             {
    212                 final Object param = params[i];
    213                 assertEquals(String.valueOf(param), fse.getInfo()[i]);
    214             }
    215         }
    216
    217         // Compare formatted message
    218         final String message = Messages.getString(code, params);
    219         assertEquals(message, throwable.getMessage());
    220     }
    221
    222     /***
    223      * Asserts that an exception contains the expected message.
    224      */
    225     public static void assertSameMessage(final String code,
    226                                          final Object param,
    227                                          final Throwable throwable)
    228     {
    229         assertSameMessage(code, new Object[]{param}, throwable);
    230     }
    231
    232     /***
    233      * Compares 2 objects for equality, nulls are equal.  Used by the test
    234      * classes' equals() methods.
    235      */
    236     public static boolean equals(final Object o1, final Object o2)
    237     {
    238         if (o1 == null && o2 == null)
    239         {
    240             return true;
    241         }
    242         if (o1 == null || o2 == null)
    243         {
    244             return false;
    245         }
    246         return o1.equals(o2);
    247     }
    248 }