Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2010-2011 the original author or authors.
   *
   * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
   *
  * 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.callbackparams.bdd.support;
 
 import java.util.List;

Author(s):
Henrik Kaipe
 
 public class GenericBddRunner {
 
     private TestrunCallbacks testInstance;
     private CallbackControlPanel ccp;
     private Collection<FieldtestFields = new ArrayList<Field>();
     private List<MethodmethodsInOrder = new ArrayList<Method>();
 
     private GenericBddRunner(TestrunCallbacks testInstance) {
         this. = testInstance;
     }
 
     public static void run(final TestrunCallbacks testInstance)
     throws Throwable {
         GenericBddRunner gbr = new GenericBddRunner(testInstance);
         gbr.init();
         gbr.execute();
     }
 
     private void execute() throws Throwable {
         for (Method m : ) {
             for (Object o : potentialInvokeTargets()) {
                 if (m.getDeclaringClass().isAssignableFrom(o.getClass())) {
                     try {
                         m.invoke(opickArguments(m.getParameterTypes()));
                     } catch (InvocationTargetException ite) {
                         throw ite.getTargetException();
                     }
                 }
             }
         }
     }
 
     private Iterable<ObjectpotentialInvokeTargets() {
         List record = .getCurrentCallbackRecord();
         List targets = new ArrayList(record.size() + 1);
         targets.add();
         targets.addAll(record);
         return targets;
     }
 
     private Object[] pickArguments(Class<?>[] paramTypes)
     throws IllegalAccessException {
         Object[] args = new Object[paramTypes.length];
         for (int i = 0 ; i < paramTypes.length ; ++i) {
             args[i] = pickArgument(paramTypes[i]);
         }
         return args;
     }
 
     private Object pickArgument(Class<?> typethrows IllegalAccessException {
         if (type.isInstance()) {
             return ;
         } else {
             for (Field f : ) {
                 if (type.isAssignableFrom(f.getType())) {
                     return f.get();
                 }
             }
         }
         return null;
     }
 
     private void init() {
        collectTestField();
        collectMethodsInOrder();
    }
    private CallbackRecord getCallbackRecord() {
        try {
            Method m = TestrunCallbacks.class
                    .getDeclaredMethod("getCallbackRecord");
            m.setAccessible(true);
            return (CallbackRecordm.invoke();
        } catch (InvocationTargetException ex) {
            throw new Error(ex.getTargetException());
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }
    private void collectMethodsInOrder() {
        Collection<MethodfindOrderMethods = new LinkedHashSet<Method>();
        for (Class<?> c : testClassHierarchy()) {
            for (Method m : c.getDeclaredMethods()) {
                if (isBddMethod(m)) {
                    m.setAccessible(true);
                    findOrderMethods.add(m);
                }
            }
        }
        for (Object v : recordValues()) {
            for (Method m : v.getClass().getDeclaredMethods()) {
                if (isBddMethod(m)) {
                    m.setAccessible(true);
                    findOrderMethods.add(m);
                }
            }
        }
        .addAll(findOrderMethods);
        Collections.sort(new Comparator<Method>() {
            public int compare(Method m1Method m2) {
                return order(m1).compareTo(order(m2));
            }
            private BigInteger order(Method m) {
                BigInteger order = .;
                for (Annotation a : m.getAnnotations()) {
                    Class<?> annotationClass = a.annotationType();
                    if (annotationClass.isAnnotationPresent(BddOrder.class)) {
                        order = order.add(BigInteger.valueOf(annotationClass
                                .getAnnotation(BddOrder.class).value()));
                    }
                }
                return order;
            }
        });
    }
    private boolean isBddMethod(Method m) {
        for (Annotation a : m.getAnnotations()) {
            if (a.annotationType().isAnnotationPresent(BddOrder.class)) {
                return true;
            }
        }
        return false;
    }
    private void collectTestField() {
        for (Class<?> c : testClassHierarchy()) {
            for (Field f : c.getDeclaredFields()) {
                f.setAccessible(true);
                .add(f);
            }
        }
    }
    private Iterable<ObjectrecordValues() {
        return .getCurrentCallbackRecord();
    }
    private Iterable<Class<?>> testClassHierarchy() {
        List classes = new ArrayList();
        for (Class<?> c = .getClass()
                ; TestrunCallbacks.class != c ; c = c.getSuperclass()) {
            classes.add(c);
        }
        return classes;
    }
New to GrepCode? Check out our FAQ X