/**

  * Copyright 2005-2011 The Kuali Foundation

  *

  * Licensed under the Educational Community License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.opensource.org/licenses/ecl2.php

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.kuali.rice.test;

 import org.junit.Assert;

 import java.lang.annotation.Annotation;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Set;

 public final class TestUtilities {

         private static Thread exceptionThreader;

         private TestUtilities() {

                 throw new UnsupportedOperationException("do not call");

         }

         /**

      * Waits "indefinately" for the exception routing thread to terminate.

      *

      * This actually doesn't wait forever but puts an upper bound of 5 minutes

      * on the time to wait for the exception routing thread to complete.  If a

      * document cannot go into exception routing within 5 minutes  then we got

      * problems.

      */

     public static void waitForExceptionRouting() {

             waitForExceptionRouting(5*60*1000);

     }

     public static void waitForExceptionRouting(long milliseconds) {

             try {

                     Thread thread = getExceptionThreader();

                     if (thread == null) {

                             throw new IllegalStateException("No exception thread was established, likely message is not being processed for exception routing.");

                     }

                     thread.join(milliseconds);

             } catch (InterruptedException e) {

                     Assert.fail("This thread was interuppted while waiting for exception routing.");

             }

             if (getExceptionThreader().isAlive()) {

                     Assert.fail("Document was not put into exception routing within the specified amount of time " + milliseconds);

             }

     }

     public static Thread getExceptionThreader() {

         return exceptionThreader;

     }

     public static void setExceptionThreader(Thread exceptionThreader) {

         TestUtilities.exceptionThreader = exceptionThreader;

     }

     protected static boolean contains(Class[] list, Class target) {

         for (Class c: list) {

             if (c.getName().equals(target.getName())) {

                 return true;

             }

         }

         return false;

     }

     /**

      * This method facilitates using annotations in a unit test class hierarchy.  We walk up the class hierarchy

      * and on each class, looking for the presence of any of the specified annotation types.  If the particular class

      * defines one of the annotation types, it is marked for handling.  Once any single target annotation is found

      * on the class, it is marked and no further annotations are inspected.

      * 

      * If the annotation defines an 'overrideSuperClasses' method, and this method returns false, then processing

      * continues up the class hierarchy.  Otherwise processing stops when the first annotation is found.  Note that

      * this feature only makes sense when specifying a single annotation type.

      * 

      * After a list of classes in descending hierarchy order is compiled, the list is iterated over (again, in

      * descending hierarchy order) and if the class is not already present in the caller-supplied list of classes

      * already handled by the caller, the class is added to a list of classes that need to be handled by the caller,

      * which is then returned to the caller.

      * 

      * It is the caller's responsibility to handle the returned classes, and store them in some internal list which it may

      * give back to this method in the future.

      * 

      * @throws Exception if there is a problem in reflection on an Annotation object

      */

     public static List<Class> getHierarchyClassesToHandle(Class testClass, Class[] annotationClasses, Set<String> classesHandled) throws Exception {

         List<Class> classesThatNeedHandling = new ArrayList<Class>();

         // get a list of all classes the current class extends from that use the PerSuiteUnitTestData annotation

         List<Class> classesToCheck = new ArrayList<Class>();

         // here we get the list apart checking the annotations to support the perSuiteDataLoaderLifecycleNamesRun variable better

         {

             Class clazz = testClass;

             superClassLoop: while (!clazz.getName().equals(Object.class.getName())) {

                 for (Annotation annotation : clazz.getDeclaredAnnotations()) {

                     // if this isn't one of the annotations we're interested in, move on

                     if (!contains(annotationClasses, annotation.annotationType())) {

                         continue;

                     }

                     // this class should be processed because it contains an annotation we are interested in

                     classesToCheck.add(0, clazz);

                     // now check to see if annotation overrides super class implementations

                     if (annotationOverridesSuperClass(annotation)) {

                         // we're done here

                         break superClassLoop;

                     }

                     // we just added the class to classes to check, we don't need to add it again

                     // so just stop looking at annotations in this particular class

                     break;

                 }

                 clazz = clazz.getSuperclass();

             }

         }

         for (Class clazz: classesToCheck) {

             if (!classesHandled.contains(clazz.getName())) {

                 classesThatNeedHandling.add(clazz);

             }

         }

         return classesThatNeedHandling;

     }

     /**

      * Determines whether an annotation should override the same type of annotation on a superclass,

      * by using reflection to invoke the 'overrideSuperClasses' method on the annotation if it exists.

      * If the annotation does not supply this method, the default is true.

      * @param annotation the annotation to inspect

      * @return whether this annotation overrides any annotations of similar type in super classes

      * @throws Exception if an error occurs during reflection

      */

     protected static boolean annotationOverridesSuperClass(Annotation annotation) throws Exception {

         boolean overrides = true; // default is to just override

         Method m = null;;

         try {

             m = annotation.getClass().getMethod("overrideSuperClasses", null);

         } catch (NoSuchMethodException nsme) {

             // do nothing

         }

         if (m != null) {

             Object result = m.invoke(annotation, (Object[]) null);

             if (result instanceof Boolean) {

                 overrides = (Boolean) result;

             } else {

                 throw new RuntimeException("Annotation 'overrideSuperClasses' did not return Boolean value");

             }

         }

         return overrides;

     }

 }