final String path = "/home/zecarlos/FEUP/runtime-EclipseApplication/Calculator/bin/";	
final String targetName = "functions.test.AddTest";
final String className = "functions.Calculadora";

InputStream inputTarget = new FileInputStream(path + targetName.replace('.', '/') + ".class");
InputStream inputClass = new FileInputStream(path + className.replace('.', '/') + ".class");

// For instrumentation and runtime we need a IRuntime instance to collect execution data
final IRuntime runtime = new LoggerRuntime();

System.err.println("Instrumenting");
// The Instrumenter creates a modified version of our test target class that contains additional probes for execution data recording
final Instrumenter instr = new Instrumenter(runtime);
final byte[] instrumented = instr.instrument( inputTarget );

final Instrumenter instr2 = new Instrumenter(runtime);
final byte[] instrumented2 = instr2.instrument( inputClass );

System.err.println("Startup");
// Now we're ready to run our instrumented class and need to startup the runtime first
runtime.startup();

System.err.println("Add definition");
// In this tutorial we use a special class loader to directly load the instrumented class definition from a byte[] instances
final MemoryClassLoader memoryClassLoader = new MemoryClassLoader();
memoryClassLoader.addDefinition(targetName, instrumented);
memoryClassLoader.addDefinition(className, instrumented2);
System.err.println("Loading Class: " + targetName);
final Class<?> targetClass = memoryClassLoader.loadClass(targetName);

System.err.println("Running JUnit");
// Here we execute our test target class through its Runnable interface:
JUnitCore junit = new JUnitCore();
Result result = junit.run(targetClass);
System.out.println(result.wasSuccessful());

System.err.println("Collecting");
// At the end of test execution we collect execution data and shutdown the runtime
final ExecutionDataStore executionData = new ExecutionDataStore();
runtime.collect(executionData, null, false);
runtime.shutdown();

System.err.println("Coverage");
// Together with the original class definition we can calculate coverage information
final CoverageBuilder coverageBuilder = new CoverageBuilder();
final Analyzer analyzer = new Analyzer(executionData, coverageBuilder);
inputTarget = new FileInputStream(path + targetName.replace('.', '/') + ".class");
analyzer.analyzeClass( inputTarget );

// Let's dump some metrics and line coverage information:
for (final IClassCoverage cc : coverageBuilder.getClasses())
{
	System.out.printf("Coverage of class %s%n", cc.getName());

	printCounter("instructions", cc.getInstructionCounter());
	printCounter("branches", cc.getBranchCounter());
	printCounter("lines", cc.getLineCounter());
	printCounter("methods", cc.getMethodCounter());
	printCounter("complexity", cc.getComplexityCounter());
}

public static class MemoryClassLoader extends ClassLoader
{
	private final Map<String, byte[]> definitions = new HashMap<String, byte[]>();

	/**
	 * Add a in-memory representation of a class.
	 */
	public void addDefinition(final String name, final byte[] bytes) {
		definitions.put(name, bytes);
	}

	@Override
	protected Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException
	{
		final byte[] bytes = definitions.get(name);
		if (bytes != null)
			return defineClass(name, bytes, 0, bytes.length);
		return super.loadClass(name, resolve);
	}
}

private void printCounter(final String unit, final ICounter counter)
{
	final Integer missed	= Integer.valueOf(counter.getMissedCount());
	final Integer total		= Integer.valueOf(counter.getTotalCount());
	
	System.out.printf("%s of %s %s missed%n", missed, total, unit);
}

final Class<?> targetClass = memoryClassLoader.loadClass(targetName);