Android JUnit Test Runner - java.lang.ClassNotFoundException

Today I've been setting up a test project for my upcoming android-project. First thing I did was using the Eclipse wizard to create a new Android test project for an existing android project.
I quickly threw in a TestSuite that would run all Tests 'below' the current package...

package org.anddev.andengine.test;

import junit.framework.Test;
import junit.framework.TestSuite;
import android.test.suitebuilder.TestSuiteBuilder;

public class AllTests extends TestSuite {
 public static Test suite() {
  return new TestSuiteBuilder(AllTests.class).includeAllPackagesUnderHere().build();
 }
}

... and a dummy TestCase ...

package org.anddev.andengine.test.bla;

import junit.framework.Assert;
import android.test.AndroidTestCase;

public class SomeTest extends AndroidTestCase {

    public void testSomething() throws Throwable {
       Assert.assertTrue(1 + 1 == 2);
    }

    public void testSomethingElse() throws Throwable {
       Assert.assertTrue(1 + 1 == 3);
    }
}

Either running the Android test project right from Eclipse or from the command-line resulted in:

E:\sdk\android\tools>adb shell am instrument -w org.anddev.andengine.test/android.test.InstrumentationTestRunner


INSTRUMENTATION_RESULT: shortMsg=Unable to instantiate instrumentation ComponentInfo{org.anddev.andengine.test/android.test.InstrumentationTestRunner}: java.lang.ClassNotFoundException: android.test.InstrumentationTestRunner in loader dalvik.system.PathClassLoader@4001b4f8
INSTRUMENTATION_RESULT: longMsg=java.lang.RuntimeException: Unable to instantiate instrumentation ComponentInfo{org.anddev.andengine.test/android.test.InstrumentationTestRunner}: java.lang.ClassNotFoundException: android.test.InstrumentationTestRunner in loader dalvik.system.PathClassLoader@4001b4f8
INSTRUMENTATION_CODE: 0

So what was the problem and how did I fix this?

Due to the fact that the project I wanted to test was a kind of libary, which had no need for an application or activity tag or similar i had deleted it from the AndroidManifest.xml, like this:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="org.anddev.andengine"
 android:versionCode="1"
 android:versionName="1.0">

 <uses-sdk android:minSdkVersion="4" />
</manifest> 

... so the only thing I had to change was an empty <application> tag to the AndroidManifest.xml !

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="org.anddev.andengine"
 android:versionCode="1"
 android:versionName="1.0">

 <uses-sdk android:minSdkVersion="4" />
 <application />
</manifest> 

Hope this helps =)

Best Regards,
Nicolas

Scala + GridGain (+ Eclipse + JUnit) = WIN

Recently I stumbled upon GridGain, which seems to be a highly interesing Grid-Framework written in Java. Due to the fact it is written in Java it is supposed to be working with Scala, my upcoming favorite JVM language (Sorry Java!).

Having watched the screencasts by Nikita Ivanov I was kind of forced to give a try! You should watch them to, they explain every single step to take when using GridGain with Java.

This is the specific setup I was using:

• Eclipse: 3.5.1 build 20090920-1017
• GridGain: 2.2.1
  
• Scala: Scala Library version 2.8.0.r20638-b20100123020158
• JUnit: 4.5.0.v20090824
  

To give you an idea of what GridGain (in Java) is like and how to make code run in the cloud with basically just one annotation:

@Gridify   
public int superHeavyMethod(int x, double y){
   // ...
}

Oh yeah, we do like that =)

So as you now have watched the screencasts, I show you how to do the same in Scala. For this example, I chose to execute a function f with a single parameter in the cloud. To do so I defined the @Gridify -ed method myCloudExecutionMethod, which takes such a function and such a parameter.

package org.anddev.scala.gridgain

import org.gridgain.grid._
import org.gridgain.grid.gridify._

object MyGridifyApp {
 def main (args : Array[String]) : Unit = {
  GridFactory.start()  
  try { 
   def f = (x:Int) => {println(">>> Executing f(x)=x*x ..."); x*x} 
   println(">>> f(5)=" + myCloudExecutionMethod(f, 5))  
  }  
  finally GridFactory.stop(true)  
 }  

 @Gridify  
 def myCloudExecutionMethod(f: Int => Int, x: Int): Int = {
  println(">>> myCloudExecutionMethod ...")  
  f(x)  
 }  
}

This is how the whole project with all resources looks like (Note: MyGridApp, MyGridJob and MyGridTask are not used in this example):

When running the app you might need to create/modify the Run-Configuration, as the current Scala-Eclipse Plugin pretty much fails on creating one for you. (You'll probably have to enter the 'Main class' in the 'Main'-tab)

This is how the run configuration looks like, when you have set up your project correctly (See the screencasts on how to add what and where) :

So to actually run this awesome code on the grid, you'd start some grid-nodes (from sth. like: C:\Program Files (x86)\gridgain-2.1.1\bin ) then sth like this will be logged to your Eclipse Console view:

  _____      _     _  _____       _       
 / ____|    (_)   | |/ ____|     (_)      
| |  __ _ __ _  __| | |  __  __ _ _ _ __   
| | |_ | '__| |/ _` | | |_ |/ _` | | '_ \ 
| |__| | |  | | (_| | |__| | (_| | | | | | 
 \_____|_|  |_|\__,_|\_____|\__,_|_|_| |_|

>>> GridGain ver. 2.1.1-26022009
>>> Copyright (C) 2005-2009 GridGain Systems.

.....
>>> -------------------
>>> Discovery Snapshot.
>>> -------------------
>>> Number of nodes: 3
...
>>> Total number of CPUs: 2
...
>>> --------------------------------------------------
>>> GridGain ver. 2.1.1-26022009 STARTED OK in 8466ms.
>>> --------------------------------------------------
...
>>> f(5)=25
....
>>> ------------------------------------------------
>>> GridGain ver. 2.1.1-26022009 STOPPED OK in 19ms.
>>> ------------------------------------------------
>>> Optional instance name: null
>>> Grid up time: 00:00:01:256

We can see that the result was actually printed in our application, just as we expected. And if you now have a look to the nodes you had started, you'll find the following in one of them:

>>> myCloudExecutionMethod ...
>>> Executing f(x)=x*x ...

Think about this for a moment.... BAZINGA! - You've just successfully executed your first Grid-enabled application.

As you also have seen, the screencasts show off some JUnit-love on GridGain and this is how you do it with Scala. Note: You'll have all the same buildpath-setup as above!

Basically we will have two TestCases and one of the will throw an Exception on purpose, so we can see that we can even view the proper stacktrace of a Exception that was thrown somewhere in the grid!!! (Both TestCases are wrapped in a TestSuite)

package org.anddev.scala.gridgain

import java.lang.management._
import junit.framework._

class MyGridAppTestA extends TestCase {
    def testA() : Unit = {
        throw new RuntimeException("Exception in test A on " + ManagementFactory.getRuntimeMXBean().getName())
    }
}

package org.anddev.scala.gridgain

import java.lang.management._
import junit.framework._

class MyGridAppTestB extends TestCase {
    def testB() : Unit = {
        println("Executing test B on: " + ManagementFactory.getRuntimeMXBean().getName())
    }
}

package org.anddev.scala.gridgain

import junit.framework._
import org.junit.runner.RunWith
import org.junit.runners.Suite
import org.gridgain.grid.test._
import org.gridgain.grid.test.junit4._

@GridifyTest
@RunWith(classOf[GridJunit4Suite])
@Suite.SuiteClasses(Array(classOf[MyGridAppTestA], classOf[MyGridAppTestB]))
class MyGridAppTestSuite

In this case the Eclipse JUnit Runner could successfully pick up the TestSuite and I didn't even have to create a Run Configuration manually!

This is what we expected and what you will get:

As I said WIN ! GridGain rocks!