All tests passing again. Ref #525.

cucumber · Jun 25, 2013 · b3a800b · mfellner · Jun 26, 2013 · aslakhellesoy
1 parent 51da5a8
commit b3a800b
Show file tree

Hide file tree

Showing 14 changed files with 79 additions and 77 deletions.
diff --git a/android-test/pom.xml b/android-test/pom.xml
@@ -54,7 +54,7 @@
                 <plugin>
                     <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                     <artifactId>android-maven-plugin</artifactId>
-                    <version>3.5.3</version>
+                    <version>3.6.0</version>
                     <extensions>true</extensions>
                 </plugin>
             </plugins>

diff --git a/android-test/project.properties b/android-test/project.properties
@@ -1,3 +1,3 @@
-target=android-17
+target=android-8
 android.library=false
 android.library.reference.1=../android
diff --git a/android-test/src/cucumber/android/test/CucumberActivitySteps.java b/android-test/src/cucumber/android/test/CucumberActivitySteps.java
@@ -7,6 +7,7 @@
 import cucumber.api.java.en.Then;
 import cucumber.api.java.en.When;
 
+// I don't quite get why glue code has to be in a subclass....
 public class CucumberActivitySteps extends ActivityInstrumentationTestCase2<CucumberActivity> {
     private int steps;
 

diff --git a/android/README.md b/android/README.md
@@ -12,3 +12,11 @@ On OS X: Note that for the path to work on the commandline and in IDE's started
 The generated target artifacts are an [apklib](https://code.google.com/p/maven-android-plugin/wiki/ApkLib) file and a regular .jar.
 
 Tests are in `../cucumber-test/`.
+
+## Developers
+
+When running the test app, logs can be read with:
+
+```
+adb logcat
+```
diff --git a/android/pom.xml b/android/pom.xml
@@ -46,7 +46,7 @@
                 <plugin>
                     <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                     <artifactId>android-maven-plugin</artifactId>
-                    <version>3.5.3</version>
+                    <version>3.6.0</version>
                     <extensions>true</extensions>
                 </plugin>
             </plugins>

diff --git a/android/project.properties b/android/project.properties
@@ -1,2 +1,2 @@
-target=android-17
+target=android-8
 android.library=true
diff --git a/android/src/cucumber/api/android/CucumberInstrumentation.java b/android/src/cucumber/api/android/CucumberInstrumentation.java
@@ -10,7 +10,10 @@
 import cucumber.runtime.CucumberException;
 import cucumber.runtime.Runtime;
 import cucumber.runtime.RuntimeOptions;
-import cucumber.runtime.android.*;
+import cucumber.runtime.android.AndroidFormatter;
+import cucumber.runtime.android.AndroidObjectFactory;
+import cucumber.runtime.android.AndroidReflections;
+import cucumber.runtime.android.AndroidResourceLoader;
 import cucumber.runtime.io.Reflections;
 import cucumber.runtime.io.ResourceLoader;
 import cucumber.runtime.java.JavaBackend;
@@ -50,13 +53,40 @@ public class CucumberInstrumentation extends Instrumentation {
     public void onCreate(Bundle arguments) {
         super.onCreate(arguments);
 
+        if(arguments == null) {
+            throw new CucumberException("No arguments");
+        }
+        Log.d(TAG, "************** KEYS **************");
+        for (String key : arguments.keySet()) {
+            Log.d(TAG, key + " => " + arguments.get(key));
+        }
+        /*
+        MAVEN:
+        log => false
+        coverage => false
+        coverageFile => expression
+        debug => false
+
+        IDEA:
+        class => cucumber.android.test.CucumberActivitySteps
+        debug => false
+        */
+
+
+
+        // Maven: [log, coverage, coverageFile, debug]
+        // IDEA:  [log, coverage, coverageFile, debug]
+
         Context context = getContext();
         classLoader = context.getClassLoader();
 
+        String apkPath = context.getPackageCodePath();
+        ClassPathPackageInfoSource.setApkPaths(new String[]{apkPath});
+        ClassPathPackageInfoSource source = new ClassPathPackageInfoSource();
+
         // For glue and features either use the provided arguments or try to find a RunWithCucumber annotated class.
         // If nothing works, default values will be used instead.
-        if (arguments != null &&
-                (arguments.containsKey(ARGUMENT_TEST_CLASS) || arguments.containsKey(ARGUMENT_TEST_PACKAGE))) {
+        if (arguments.containsKey(ARGUMENT_TEST_CLASS) || arguments.containsKey(ARGUMENT_TEST_PACKAGE)) {
 
             String testClass = arguments.getString(ARGUMENT_TEST_CLASS);
             testClass = testClass != null ? testClass : "null";
@@ -82,11 +112,10 @@ public void onCreate(Bundle arguments) {
                 Log.w(TAG, e.toString());
             }
         } else {
-            throw new CucumberException("bad args");
-//            ClassPathPackageInfoSource source = AndroidClasspathMethodScanner.classPathPackageInfoSource(context);
-//            for (Class<?> clazz : source.getPackageInfo(context.getPackageName()).getTopLevelClassesRecursive()) {
-//                if (readRunWithCucumberAnnotation(clazz)) break;
-//            }
+//            throw new CucumberException("bad args");
+            for (Class<?> clazz : source.getPackageInfo(context.getPackageName()).getTopLevelClassesRecursive()) {
+                if (readRunWithCucumberAnnotation(clazz)) break;
+            }
         }
 
         Properties properties = new Properties();
@@ -97,15 +126,10 @@ public void onCreate(Bundle arguments) {
         runtimeOptions = new RuntimeOptions(properties);
 
         resourceLoader = new AndroidResourceLoader(context);
-//        resourceLoader = new ClasspathResourceLoader(classLoader);
-        List<Backend> backends = new ArrayList<Backend>();
-//        backends.add(new AndroidBackend(this));
-
-        String apkPath = context.getPackageCodePath();
-        ClassPathPackageInfoSource.setApkPaths(new String[]{apkPath});
-        ClassPathPackageInfoSource source = new ClassPathPackageInfoSource();
 
         Reflections androidReflections = new AndroidReflections(source);
+
+        List<Backend> backends = new ArrayList<Backend>();
         backends.add(new JavaBackend(new AndroidObjectFactory(this), androidReflections));
         runtime = new Runtime(resourceLoader, classLoader, backends, runtimeOptions);
 

diff --git a/android/src/cucumber/api/android/RunWithCucumber.java b/android/src/cucumber/api/android/RunWithCucumber.java
@@ -5,6 +5,8 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+// TODO (aslak): In stead of a stripped down copy of cucumber-junit's @Cucumber.Options annotation
+// it would be better to pull that annotation up to core and deprecate the JUnit one.
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE})
 public @interface RunWithCucumber {

diff --git a/android/src/cucumber/runtime/android/AndroidObjectFactory.java b/android/src/cucumber/runtime/android/AndroidObjectFactory.java
@@ -15,29 +15,29 @@
 import java.util.Set;
 
 public class AndroidObjectFactory implements ObjectFactory {
-    private final Instrumentation mInstrumentation;
-    private final Set<Class<?>> mClasses = new HashSet<Class<?>>();
-    private final Map<Class<?>, Object> mInstances = new HashMap<Class<?>, Object>();
+    private final Instrumentation instrumentation;
+    private final Set<Class<?>> classes = new HashSet<Class<?>>();
+    private final Map<Class<?>, Object> instances = new HashMap<Class<?>, Object>();
 
     public AndroidObjectFactory(Instrumentation instrumentation) {
-        mInstrumentation = instrumentation;
+        this.instrumentation = instrumentation;
     }
 
     public void start() {
         // No-op
     }
 
     public void stop() {
-        mInstances.clear();
+        instances.clear();
     }
 
     public void addClass(Class<?> clazz) {
-        mClasses.add(clazz);
+        classes.add(clazz);
     }
 
     public <T> T getInstance(Class<T> type) {
-        if (mInstances.containsKey(type)) {
-            return type.cast(mInstances.get(type));
+        if (instances.containsKey(type)) {
+            return type.cast(instances.get(type));
         } else {
             return cacheNewInstance(type);
         }
@@ -49,18 +49,18 @@ private <T> T cacheNewInstance(Class<T> type) {
             T instance = constructor.newInstance();
 
             if (instance instanceof ActivityInstrumentationTestCase2) {
-                ((ActivityInstrumentationTestCase2) instance).injectInstrumentation(mInstrumentation);
+                ((ActivityInstrumentationTestCase2) instance).injectInstrumentation(instrumentation);
                 // This Intent prevents the ActivityInstrumentationTestCase2 to stall on
                 // Intent.startActivitySync (when calling getActivity) if the activity is already running.
                 Intent intent = new Intent();
                 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                 ((ActivityInstrumentationTestCase2) instance).setActivityIntent(intent);
             } else if (instance instanceof InstrumentationTestCase) {
-                ((InstrumentationTestCase) instance).injectInstrumentation(mInstrumentation);
+                ((InstrumentationTestCase) instance).injectInstrumentation(instrumentation);
             } else if (instance instanceof AndroidTestCase) {
-                ((AndroidTestCase) instance).setContext(mInstrumentation.getTargetContext());
+                ((AndroidTestCase) instance).setContext(instrumentation.getTargetContext());
             }
-            mInstances.put(type, instance);
+            instances.put(type, instance);
             return instance;
         } catch (NoSuchMethodException e) {
             throw new CucumberException(String.format("%s doesn't have an empty constructor. If you need DI, put cucumber-picocontainer on the classpath", type), e);

diff --git a/android/src/ext/android/test/ClassPathPackageInfoSource.java b/android/src/ext/android/test/ClassPathPackageInfoSource.java
@@ -164,36 +164,6 @@ private void findClassesInDirectory(File classDir,
         }
     }
 
-    /**
-     * Finds all classes and sub packages that are below the packageName and
-     * add them to the respective sets. Searches the package in a single jar file.
-     */
-    private void findClassesInJar(File jarFile, String pathPrefix,
-                                  Set<String> classNames, Set<String> subpackageNames)
-            throws IOException {
-        Set<String> entryNames = getJarEntries(jarFile);
-        // check if the Jar contains the package.
-        if (!entryNames.contains(pathPrefix)) {
-            return;
-        }
-        int prefixLength = pathPrefix.length();
-        for (String entryName : entryNames) {
-            if (entryName.startsWith(pathPrefix)) {
-                if (entryName.endsWith(CLASS_EXTENSION)) {
-                    // check if the class is in the package itself or in one of its
-                    // subpackages.
-                    int index = entryName.indexOf('/', prefixLength);
-                    if (index >= 0) {
-                        String p = entryName.substring(0, index).replace('/', '.');
-                        subpackageNames.add(p);
-                    } else if (isToplevelClass(entryName)) {
-                        classNames.add(getClassName(entryName).replace('/', '.'));
-                    }
-                }
-            }
-        }
-    }
-
     /**
      * Finds all classes and sub packages that are below the packageName and
      * add them to the respective sets. Searches the package in a single apk file.
@@ -300,8 +270,4 @@ private static String[] getClassPath() {
         String separator = System.getProperty("path.separator", ":");
         return classPath.split(Pattern.quote(separator));
     }
-
-    public void setClassLoader(ClassLoader classLoader) {
-        this.classLoader = classLoader;
-    }
 }
diff --git a/core/src/main/java/cucumber/runtime/io/ResourceLoaderReflections.java b/core/src/main/java/cucumber/runtime/io/ResourceLoaderReflections.java
@@ -26,7 +26,7 @@ public Collection<Class<? extends Annotation>> getAnnotations(String packageName
     @Override
     public <T> Collection<Class<? extends T>> getDescendants(Class<T> parentType, String packageName) {
         Collection<Class<? extends T>> result = new HashSet<Class<? extends T>>();
-        String packagePath = packageName.replace('.', '/').replace(File.separatorChar, '/');
+        String packagePath = "classpath:" + packageName.replace('.', '/').replace(File.separatorChar, '/');
         for (Resource classResource : resourceLoader.resources(packagePath, ".class")) {
             String className = classResource.getClassName();
             Class<?> clazz = loadClass(className, classLoader);

diff --git a/java/src/main/java/cucumber/runtime/java/JavaBackend.java b/java/src/main/java/cucumber/runtime/java/JavaBackend.java
@@ -3,10 +3,7 @@
 import cucumber.api.java.After;
 import cucumber.api.java.Before;
 import cucumber.runtime.*;
-import cucumber.runtime.io.ClasspathResourceLoader;
-import cucumber.runtime.io.Reflections;
-import cucumber.runtime.io.ResourceLoader;
-import cucumber.runtime.io.ResourceLoaderReflections;
+import cucumber.runtime.io.*;
 import cucumber.runtime.snippets.SnippetGenerator;
 import gherkin.formatter.model.Step;
 
@@ -36,7 +33,7 @@ public JavaBackend(ResourceLoader resourceLoader) {
 
     public JavaBackend(ObjectFactory objectFactory) {
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        ResourceLoader resourceLoader = new  ClasspathResourceLoader(classLoader);
+        ResourceLoader resourceLoader = new MultiLoader(classLoader);
         reflections = new ResourceLoaderReflections(resourceLoader, classLoader);
         methodScanner = new MethodScanner(reflections);
         this.objectFactory = objectFactory;

diff --git a/java/src/test/java/cucumber/runtime/java/MethodScannerTest.java b/java/src/test/java/cucumber/runtime/java/MethodScannerTest.java
@@ -3,7 +3,8 @@
 import cucumber.api.java.Before;
 import cucumber.runtime.CucumberException;
 import cucumber.runtime.Glue;
-import cucumber.runtime.io.ClasspathResourceLoader;
+import cucumber.runtime.io.MultiLoader;
+import cucumber.runtime.io.ResourceLoader;
 import cucumber.runtime.io.ResourceLoaderReflections;
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -18,7 +19,7 @@ public class MethodScannerTest {
     @Test
     public void loadGlue_registers_the_methods_declaring_class_in_the_object_factory() throws NoSuchMethodException {
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        ClasspathResourceLoader resourceLoader = new ClasspathResourceLoader(classLoader);
+        ResourceLoader resourceLoader = new MultiLoader(classLoader);
         MethodScanner methodScanner = new MethodScanner(new ResourceLoaderReflections(resourceLoader, classLoader));
 
         ObjectFactory factory = Mockito.mock(ObjectFactory.class);

diff --git a/scala/src/main/scala/cucumber/runtime/scala/ScalaBackend.scala b/scala/src/main/scala/cucumber/runtime/scala/ScalaBackend.scala
@@ -5,14 +5,16 @@ import _root_.gherkin.formatter.model.Step
 import _root_.java.lang.reflect.Modifier
 import _root_.cucumber.runtime.snippets.SnippetGenerator
 import _root_.cucumber.api.scala.ScalaDsl
+import _root_.cucumber.runtime.io.Reflections
+import _root_.cucumber.runtime.io.ResourceLoaderReflections
 import _root_.cucumber.runtime.io.ResourceLoader
-import _root_.cucumber.runtime.io.ClasspathResourceLoader
+import _root_.cucumber.runtime.io.MultiLoader
 import _root_.cucumber.runtime.Backend
 import _root_.cucumber.runtime.UnreportedStepExecutor
 import _root_.cucumber.runtime.Glue
 import collection.JavaConversions._
 
-class ScalaBackend(ignore:ResourceLoader) extends Backend {
+class ScalaBackend(resourceLoader:ResourceLoader) extends Backend {
   private var snippetGenerator = new SnippetGenerator(new ScalaSnippetGenerator())
   private var instances:Seq[ScalaDsl] = Nil
 
@@ -33,9 +35,10 @@ class ScalaBackend(ignore:ResourceLoader) extends Backend {
   }
 
   def loadGlue(glue: Glue, gluePaths: JList[String]) {
-    val cl = new ClasspathResourceLoader(Thread.currentThread().getContextClassLoader)
+    val cl = Thread.currentThread().getContextClassLoader
+    val reflections = new ResourceLoaderReflections(resourceLoader, cl)
     val packages = gluePaths map { cucumber.runtime.io.MultiLoader.packageName(_) }
-    val dslClasses = packages flatMap { cl.getDescendants(classOf[ScalaDsl], _) } filter { cls =>
+    val dslClasses = packages flatMap { reflections.getDescendants(classOf[ScalaDsl], _) } filter { cls =>
       try {
         cls.getDeclaredConstructor()
         true