diff --git a/testing/agent/src/main/java/sbt/ForkConfiguration.java b/testing/agent/src/main/java/sbt/ForkConfiguration.java index 397d1aaa9..9f51e9c69 100644 --- a/testing/agent/src/main/java/sbt/ForkConfiguration.java +++ b/testing/agent/src/main/java/sbt/ForkConfiguration.java @@ -3,10 +3,10 @@ package sbt; import java.io.Serializable; public final class ForkConfiguration implements Serializable { - private boolean ansiCodesSupported; - private boolean parallel; + private final boolean ansiCodesSupported; + private final boolean parallel; - public ForkConfiguration(boolean ansiCodesSupported, boolean parallel) { + public ForkConfiguration(final boolean ansiCodesSupported, final boolean parallel) { this.ansiCodesSupported = ansiCodesSupported; this.parallel = parallel; } diff --git a/testing/agent/src/main/java/sbt/ForkMain.java b/testing/agent/src/main/java/sbt/ForkMain.java old mode 100755 new mode 100644 index 142bc6aa1..b7871ecde --- a/testing/agent/src/main/java/sbt/ForkMain.java +++ b/testing/agent/src/main/java/sbt/ForkMain.java @@ -16,16 +16,16 @@ import java.util.Arrays; import java.util.List; import java.util.concurrent.*; -public class ForkMain { +final public class ForkMain { // serializables // ----------------------------------------------------------------------------- - static class SubclassFingerscan implements SubclassFingerprint, Serializable { - private boolean isModule; - private String superclassName; - private boolean requireNoArgConstructor; - SubclassFingerscan(SubclassFingerprint print) { + final static class SubclassFingerscan implements SubclassFingerprint, Serializable { + private final boolean isModule; + private final String superclassName; + private final boolean requireNoArgConstructor; + SubclassFingerscan(final SubclassFingerprint print) { isModule = print.isModule(); superclassName = print.superclassName(); requireNoArgConstructor = print.requireNoArgConstructor(); @@ -35,10 +35,10 @@ public class ForkMain { public boolean requireNoArgConstructor() { return requireNoArgConstructor; } } - static class AnnotatedFingerscan implements AnnotatedFingerprint, Serializable { - private boolean isModule; - private String annotationName; - AnnotatedFingerscan(AnnotatedFingerprint print) { + final static class AnnotatedFingerscan implements AnnotatedFingerprint, Serializable { + private final boolean isModule; + private final String annotationName; + AnnotatedFingerscan(final AnnotatedFingerprint print) { isModule = print.isModule(); annotationName = print.annotationName(); } @@ -46,34 +46,34 @@ public class ForkMain { public String annotationName() { return annotationName; } } - static class ForkEvent implements Event, Serializable { - private String fullyQualifiedName; - private Fingerprint fingerprint; - private Selector selector; - private Status status; - private OptionalThrowable throwable; - private long duration; + final static class ForkEvent implements Event, Serializable { + private final String fullyQualifiedName; + private final Fingerprint fingerprint; + private final Selector selector; + private final Status status; + private final OptionalThrowable throwable; + private final long duration; - ForkEvent(Event e) { + ForkEvent(final Event e) { fullyQualifiedName = e.fullyQualifiedName(); - Fingerprint rawFingerprint = e.fingerprint(); + final Fingerprint rawFingerprint = e.fingerprint(); if (rawFingerprint instanceof SubclassFingerprint) - this.fingerprint = new SubclassFingerscan((SubclassFingerprint) rawFingerprint); + fingerprint = new SubclassFingerscan((SubclassFingerprint) rawFingerprint); else - this.fingerprint = new AnnotatedFingerscan((AnnotatedFingerprint) rawFingerprint); + fingerprint = new AnnotatedFingerscan((AnnotatedFingerprint) rawFingerprint); selector = e.selector(); checkSerializableSelector(selector); status = e.status(); - OptionalThrowable originalThrowable = e.throwable(); + final OptionalThrowable originalThrowable = e.throwable(); if (originalThrowable.isDefined()) - this.throwable = new OptionalThrowable(new ForkError(originalThrowable.get())); + throwable = new OptionalThrowable(new ForkError(originalThrowable.get())); else - this.throwable = originalThrowable; + throwable = originalThrowable; - this.duration = e.duration(); + duration = e.duration(); } public String fullyQualifiedName() { return fullyQualifiedName; } @@ -83,7 +83,7 @@ public class ForkMain { public OptionalThrowable throwable() { return throwable; } public long duration() { return duration; } - static void checkSerializableSelector(Selector selector) { + private static void checkSerializableSelector(final Selector selector) { if (! (selector instanceof Serializable)) { throw new UnsupportedOperationException("Selector implementation must be Serializable, but " + selector.getClass().getName() + " is not."); } @@ -93,11 +93,11 @@ public class ForkMain { // ----------------------------------------------------------------------------- - static class ForkError extends Exception { - private String originalMessage; - private String originalName; + final static class ForkError extends Exception { + private final String originalMessage; + private final String originalName; private ForkError cause; - ForkError(Throwable t) { + ForkError(final Throwable t) { originalMessage = t.getMessage(); originalName = t.getClass().getName(); setStackTrace(t.getStackTrace()); @@ -111,8 +111,8 @@ public class ForkMain { // main // ---------------------------------------------------------------------------------------------------------------- - public static void main(String[] args) throws Exception { - Socket socket = new Socket(InetAddress.getByName(null), Integer.valueOf(args[0])); + public static void main(final String[] args) throws Exception { + final Socket socket = new Socket(InetAddress.getByName(null), Integer.valueOf(args[0])); final ObjectInputStream is = new ObjectInputStream(socket.getInputStream()); final ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream()); // Must flush the header that the constructor writes, otherwise the ObjectInputStream on the other end may block indefinitely @@ -132,76 +132,76 @@ public class ForkMain { // ---------------------------------------------------------------------------------------------------------------- - private static class Run { + final private static class Run { - void run(ObjectInputStream is, ObjectOutputStream os) { + private void run(final ObjectInputStream is, final ObjectOutputStream os) { try { runTests(is, os); - } catch (RunAborted e) { + } catch (final RunAborted e) { internalError(e); - } catch (Throwable t) { + } catch (final Throwable t) { try { logError(os, "Uncaught exception when running tests: " + t.toString()); write(os, new ForkError(t)); - } catch (Throwable t2) { + } catch (final Throwable t2) { internalError(t2); } } } - boolean matches(Fingerprint f1, Fingerprint f2) { + private boolean matches(final Fingerprint f1, final Fingerprint f2) { if (f1 instanceof SubclassFingerprint && f2 instanceof SubclassFingerprint) { final SubclassFingerprint sf1 = (SubclassFingerprint) f1; final SubclassFingerprint sf2 = (SubclassFingerprint) f2; return sf1.isModule() == sf2.isModule() && sf1.superclassName().equals(sf2.superclassName()); } else if (f1 instanceof AnnotatedFingerprint && f2 instanceof AnnotatedFingerprint) { - AnnotatedFingerprint af1 = (AnnotatedFingerprint) f1; - AnnotatedFingerprint af2 = (AnnotatedFingerprint) f2; + final AnnotatedFingerprint af1 = (AnnotatedFingerprint) f1; + final AnnotatedFingerprint af2 = (AnnotatedFingerprint) f2; return af1.isModule() == af2.isModule() && af1.annotationName().equals(af2.annotationName()); } return false; } class RunAborted extends RuntimeException { - RunAborted(Exception e) { super(e); } + RunAborted(final Exception e) { super(e); } } - synchronized void write(ObjectOutputStream os, Object obj) { + private synchronized void write(final ObjectOutputStream os, final Object obj) { try { os.writeObject(obj); os.flush(); - } catch (IOException e) { + } catch (final IOException e) { throw new RunAborted(e); } } - void log(ObjectOutputStream os, String message, ForkTags level) { + private void log(final ObjectOutputStream os, final String message, final ForkTags level) { write(os, new Object[]{level, message}); } - void logDebug(ObjectOutputStream os, String message) { log(os, message, ForkTags.Debug); } - void logInfo(ObjectOutputStream os, String message) { log(os, message, ForkTags.Info); } - void logWarn(ObjectOutputStream os, String message) { log(os, message, ForkTags.Warn); } - void logError(ObjectOutputStream os, String message) { log(os, message, ForkTags.Error); } + private void logDebug(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Debug); } + private void logInfo(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Info); } + private void logWarn(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Warn); } + private void logError(final ObjectOutputStream os, final String message) { log(os, message, ForkTags.Error); } - Logger remoteLogger(final boolean ansiCodesSupported, final ObjectOutputStream os) { + private Logger remoteLogger(final boolean ansiCodesSupported, final ObjectOutputStream os) { return new Logger() { public boolean ansiCodesSupported() { return ansiCodesSupported; } - public void error(String s) { logError(os, s); } - public void warn(String s) { logWarn(os, s); } - public void info(String s) { logInfo(os, s); } - public void debug(String s) { logDebug(os, s); } - public void trace(Throwable t) { write(os, new ForkError(t)); } + public void error(final String s) { logError(os, s); } + public void warn(final String s) { logWarn(os, s); } + public void info(final String s) { logInfo(os, s); } + public void debug(final String s) { logDebug(os, s); } + public void trace(final Throwable t) { write(os, new ForkError(t)); } }; } - void writeEvents(ObjectOutputStream os, TaskDef taskDef, ForkEvent[] events) { + private void writeEvents(final ObjectOutputStream os, final TaskDef taskDef, final ForkEvent[] events) { write(os, new Object[]{taskDef.fullyQualifiedName(), events}); } - ExecutorService executorService(ForkConfiguration config, ObjectOutputStream os) { + private ExecutorService executorService(final ForkConfiguration config, final ObjectOutputStream os) { if(config.isParallel()) { - int nbThreads = Runtime.getRuntime().availableProcessors(); + final int nbThreads = Runtime.getRuntime().availableProcessors(); logDebug(os, "Create a test executor with a thread pool of " + nbThreads + " threads."); // more options later... // TODO we might want to configure the blocking queue with size #proc @@ -212,12 +212,12 @@ public class ForkMain { } } - void runTests(ObjectInputStream is, final ObjectOutputStream os) throws Exception { + private void runTests(final ObjectInputStream is, final ObjectOutputStream os) throws Exception { final ForkConfiguration config = (ForkConfiguration) is.readObject(); - ExecutorService executor = executorService(config, os); + final ExecutorService executor = executorService(config, os); final TaskDef[] tests = (TaskDef[]) is.readObject(); - int nFrameworks = is.readInt(); - Logger[] loggers = { remoteLogger(config.isAnsiCodesSupported(), os) }; + final int nFrameworks = is.readInt(); + final Logger[] loggers = { remoteLogger(config.isAnsiCodesSupported(), os) }; for (int i = 0; i < nFrameworks; i++) { final String[] implClassNames = (String[]) is.readObject(); @@ -225,15 +225,15 @@ public class ForkMain { final String[] remoteFrameworkArgs = (String[]) is.readObject(); Framework framework = null; - for (String implClassName : implClassNames) { + for (final String implClassName : implClassNames) { try { - Object rawFramework = Class.forName(implClassName).newInstance(); + final Object rawFramework = Class.forName(implClassName).newInstance(); if (rawFramework instanceof Framework) framework = (Framework) rawFramework; else framework = new FrameworkWrapper((org.scalatools.testing.Framework) rawFramework); break; - } catch (ClassNotFoundException e) { + } catch (final ClassNotFoundException e) { logDebug(os, "Framework implementation '" + implClassName + "' not present."); } } @@ -241,16 +241,16 @@ public class ForkMain { if (framework == null) continue; - ArrayList filteredTests = new ArrayList(); - for (Fingerprint testFingerprint : framework.fingerprints()) { - for (TaskDef test : tests) { + final ArrayList filteredTests = new ArrayList(); + for (final Fingerprint testFingerprint : framework.fingerprints()) { + for (final TaskDef test : tests) { // TODO: To pass in correct explicitlySpecified and selectors if (matches(testFingerprint, test.fingerprint())) filteredTests.add(new TaskDef(test.fullyQualifiedName(), test.fingerprint(), test.explicitlySpecified(), test.selectors())); } } final Runner runner = framework.runner(frameworkArgs, remoteFrameworkArgs, getClass().getClassLoader()); - Task[] tasks = runner.tasks(filteredTests.toArray(new TaskDef[filteredTests.size()])); + final Task[] tasks = runner.tasks(filteredTests.toArray(new TaskDef[filteredTests.size()])); logDebug(os, "Runner for " + framework.getClass().getName() + " produced " + tasks.length + " initial tasks for " + filteredTests.size() + " tests."); runTestTasks(executor, tasks, loggers, os); @@ -261,20 +261,20 @@ public class ForkMain { is.readObject(); } - void runTestTasks(ExecutorService executor, Task[] tasks, Logger[] loggers, ObjectOutputStream os) { + private void runTestTasks(final ExecutorService executor, final Task[] tasks, final Logger[] loggers, final ObjectOutputStream os) { if( tasks.length > 0 ) { - List> futureNestedTasks = new ArrayList>(); - for( Task task : tasks ) { + final List> futureNestedTasks = new ArrayList>(); + for( final Task task : tasks ) { futureNestedTasks.add(runTest(executor, task, loggers, os)); } // Note: this could be optimized further, we could have a callback once a test finishes that executes immediately the nested tasks // At the moment, I'm especially interested in JUnit, which doesn't have nested tasks. - List nestedTasks = new ArrayList(); - for( Future futureNestedTask : futureNestedTasks ) { + final List nestedTasks = new ArrayList(); + for( final Future futureNestedTask : futureNestedTasks ) { try { nestedTasks.addAll( Arrays.asList(futureNestedTask.get())); - } catch (Exception e) { + } catch (final Exception e) { logError(os, "Failed to execute task " + futureNestedTask); } } @@ -282,23 +282,23 @@ public class ForkMain { } } - Future runTest(ExecutorService executor, final Task task, final Logger[] loggers, final ObjectOutputStream os) { + private Future runTest(final ExecutorService executor, final Task task, final Logger[] loggers, final ObjectOutputStream os) { return executor.submit(new Callable() { @Override public Task[] call() { ForkEvent[] events; Task[] nestedTasks; - TaskDef taskDef = task.taskDef(); + final TaskDef taskDef = task.taskDef(); try { final List eventList = new ArrayList(); - EventHandler handler = new EventHandler() { public void handle(Event e){ eventList.add(new ForkEvent(e)); } }; + final EventHandler handler = new EventHandler() { public void handle(final Event e){ eventList.add(new ForkEvent(e)); } }; logDebug(os, " Running " + taskDef); nestedTasks = task.execute(handler, loggers); if(nestedTasks.length > 0 || eventList.size() > 0) logDebug(os, " Produced " + nestedTasks.length + " nested tasks and " + eventList.size() + " events."); events = eventList.toArray(new ForkEvent[eventList.size()]); } - catch (Throwable t) { + catch (final Throwable t) { nestedTasks = new Task[0]; events = new ForkEvent[] { testError(os, taskDef, "Uncaught exception when running " + taskDef.fullyQualifiedName() + ": " + t.toString(), t) }; } @@ -308,11 +308,11 @@ public class ForkMain { }); } - void internalError(Throwable t) { + private void internalError(final Throwable t) { System.err.println("Internal error when running tests: " + t.toString()); } - ForkEvent testEvent(final String fullyQualifiedName, final Fingerprint fingerprint, final Selector selector, final Status r, final ForkError err, final long duration) { + private ForkEvent testEvent(final String fullyQualifiedName, final Fingerprint fingerprint, final Selector selector, final Status r, final ForkError err, final long duration) { final OptionalThrowable throwable; if (err == null) throwable = new OptionalThrowable(); @@ -332,9 +332,9 @@ public class ForkMain { }); } - ForkEvent testError(ObjectOutputStream os, TaskDef taskDef, String message, Throwable t) { + private ForkEvent testError(final ObjectOutputStream os, final TaskDef taskDef, final String message, final Throwable t) { logError(os, message); - ForkError fe = new ForkError(t); + final ForkError fe = new ForkError(t); write(os, fe); return testEvent(taskDef.fullyQualifiedName(), taskDef.fingerprint(), new SuiteSelector(), Status.Error, fe, 0); } diff --git a/testing/agent/src/main/java/sbt/ForkTags.java b/testing/agent/src/main/java/sbt/ForkTags.java index 7fe3f365b..4318555ee 100644 --- a/testing/agent/src/main/java/sbt/ForkTags.java +++ b/testing/agent/src/main/java/sbt/ForkTags.java @@ -6,4 +6,3 @@ package sbt; public enum ForkTags { Error, Warn, Info, Debug, Done } - diff --git a/testing/agent/src/main/java/sbt/FrameworkWrapper.java b/testing/agent/src/main/java/sbt/FrameworkWrapper.java index 1ad5d0e1f..dd606ab54 100644 --- a/testing/agent/src/main/java/sbt/FrameworkWrapper.java +++ b/testing/agent/src/main/java/sbt/FrameworkWrapper.java @@ -8,9 +8,9 @@ import sbt.testing.*; */ final class FrameworkWrapper implements Framework { - private org.scalatools.testing.Framework oldFramework; + private final org.scalatools.testing.Framework oldFramework; - public FrameworkWrapper(org.scalatools.testing.Framework oldFramework) { + FrameworkWrapper(final org.scalatools.testing.Framework oldFramework) { this.oldFramework = oldFramework; } @@ -19,11 +19,11 @@ final class FrameworkWrapper implements Framework { } public Fingerprint[] fingerprints() { - org.scalatools.testing.Fingerprint[] oldFingerprints = oldFramework.tests(); - int length = oldFingerprints.length; - Fingerprint[] fingerprints = new Fingerprint[length]; + final org.scalatools.testing.Fingerprint[] oldFingerprints = oldFramework.tests(); + final int length = oldFingerprints.length; + final Fingerprint[] fingerprints = new Fingerprint[length]; for (int i=0; i < length; i++) { - org.scalatools.testing.Fingerprint oldFingerprint = oldFingerprints[i]; + final org.scalatools.testing.Fingerprint oldFingerprint = oldFingerprints[i]; if (oldFingerprint instanceof org.scalatools.testing.TestFingerprint) fingerprints[i] = new SubclassFingerprintWrapper((org.scalatools.testing.TestFingerprint) oldFingerprint); else if (oldFingerprint instanceof org.scalatools.testing.SubclassFingerprint) @@ -34,20 +34,20 @@ final class FrameworkWrapper implements Framework { return fingerprints; } - public Runner runner(String[] args, String[] remoteArgs, ClassLoader testClassLoader) { + public Runner runner(final String[] args, final String[] remoteArgs, final ClassLoader testClassLoader) { return new RunnerWrapper(oldFramework, testClassLoader, args); } } final class SubclassFingerprintWrapper implements SubclassFingerprint { - private String superclassName; - private boolean isModule; - private boolean requireNoArgConstructor; + private final String superclassName; + private final boolean isModule; + private final boolean requireNoArgConstructor; - public SubclassFingerprintWrapper(org.scalatools.testing.SubclassFingerprint oldFingerprint) { - this.superclassName = oldFingerprint.superClassName(); - this.isModule = oldFingerprint.isModule(); - this.requireNoArgConstructor = false; // Old framework SubclassFingerprint does not require no arg constructor + SubclassFingerprintWrapper(final org.scalatools.testing.SubclassFingerprint oldFingerprint) { + superclassName = oldFingerprint.superClassName(); + isModule = oldFingerprint.isModule(); + requireNoArgConstructor = false; // Old framework SubclassFingerprint does not require no arg constructor } public boolean isModule() { @@ -57,19 +57,19 @@ final class SubclassFingerprintWrapper implements SubclassFingerprint { public String superclassName() { return superclassName; } - + public boolean requireNoArgConstructor() { return requireNoArgConstructor; } } final class AnnotatedFingerprintWrapper implements AnnotatedFingerprint { - private String annotationName; - private boolean isModule; + private final String annotationName; + private final boolean isModule; - public AnnotatedFingerprintWrapper(org.scalatools.testing.AnnotatedFingerprint oldFingerprint) { - this.annotationName = oldFingerprint.annotationName(); - this.isModule = oldFingerprint.isModule(); + AnnotatedFingerprintWrapper(final org.scalatools.testing.AnnotatedFingerprint oldFingerprint) { + annotationName = oldFingerprint.annotationName(); + isModule = oldFingerprint.isModule(); } public boolean isModule() { @@ -83,33 +83,33 @@ final class AnnotatedFingerprintWrapper implements AnnotatedFingerprint { final class EventHandlerWrapper implements org.scalatools.testing.EventHandler { - private EventHandler newEventHandler; - private String fullyQualifiedName; - private Fingerprint fingerprint; + private final EventHandler newEventHandler; + private final String fullyQualifiedName; + private final Fingerprint fingerprint; - public EventHandlerWrapper(EventHandler newEventHandler, String fullyQualifiedName, Fingerprint fingerprint) { + EventHandlerWrapper(final EventHandler newEventHandler, final String fullyQualifiedName, final Fingerprint fingerprint) { this.newEventHandler = newEventHandler; this.fullyQualifiedName = fullyQualifiedName; this.fingerprint = fingerprint; } - public void handle(org.scalatools.testing.Event oldEvent) { + public void handle(final org.scalatools.testing.Event oldEvent) { newEventHandler.handle(new EventWrapper(oldEvent, fullyQualifiedName, fingerprint)); } } final class EventWrapper implements Event { - private org.scalatools.testing.Event oldEvent; - private String className; - private Fingerprint fingerprint; - private OptionalThrowable throwable; + private final org.scalatools.testing.Event oldEvent; + private final String className; + private final Fingerprint fingerprint; + private final OptionalThrowable throwable; - public EventWrapper(org.scalatools.testing.Event oldEvent, String className, Fingerprint fingerprint) { + EventWrapper(final org.scalatools.testing.Event oldEvent, final String className, final Fingerprint fingerprint) { this.oldEvent = oldEvent; this.className = className; this.fingerprint = fingerprint; - Throwable oldThrowable = oldEvent.error(); + final Throwable oldThrowable = oldEvent.error(); if (oldThrowable == null) throwable = new OptionalThrowable(); else @@ -121,7 +121,7 @@ final class EventWrapper implements Event { } public Fingerprint fingerprint() { - return fingerprint; + return fingerprint; } public Selector selector() { @@ -130,9 +130,9 @@ final class EventWrapper implements Event { public Status status() { switch (oldEvent.result()) { - case Success: + case Success: return Status.Success; - case Error: + case Error: return Status.Error; case Failure: return Status.Failure; @@ -154,47 +154,47 @@ final class EventWrapper implements Event { final class RunnerWrapper implements Runner { - private org.scalatools.testing.Framework oldFramework; - private ClassLoader testClassLoader; - private String[] args; + private final org.scalatools.testing.Framework oldFramework; + private final ClassLoader testClassLoader; + private final String[] args; - public RunnerWrapper(org.scalatools.testing.Framework oldFramework, ClassLoader testClassLoader, String[] args) { + RunnerWrapper(final org.scalatools.testing.Framework oldFramework, final ClassLoader testClassLoader, final String[] args) { this.oldFramework = oldFramework; this.testClassLoader = testClassLoader; this.args = args; } - - public Task[] tasks(TaskDef[] taskDefs) { - int length = taskDefs.length; - Task[] tasks = new Task[length]; + + public Task[] tasks(final TaskDef[] taskDefs) { + final int length = taskDefs.length; + final Task[] tasks = new Task[length]; for (int i = 0; i < length; i++) { - TaskDef taskDef = taskDefs[i]; + final TaskDef taskDef = taskDefs[i]; tasks[i] = createTask(taskDef); } return tasks; } - public Task createTask(final TaskDef taskDef) { + private Task createTask(final TaskDef taskDef) { return new Task() { public String[] tags() { return new String[0]; // Old framework does not support tags } - + private org.scalatools.testing.Logger createOldLogger(final Logger logger) { return new org.scalatools.testing.Logger() { - public boolean ansiCodesSupported() { return logger.ansiCodesSupported(); } - public void error(String msg) { logger.error(msg); } - public void warn(String msg) { logger.warn(msg); } - public void info(String msg) { logger.info(msg); } - public void debug(String msg) { logger.debug(msg); } - public void trace(Throwable t) { logger.trace(t); } + public boolean ansiCodesSupported() { return logger.ansiCodesSupported(); } + public void error(final String msg) { logger.error(msg); } + public void warn(final String msg) { logger.warn(msg); } + public void info(final String msg) { logger.info(msg); } + public void debug(final String msg) { logger.debug(msg); } + public void trace(final Throwable t) { logger.trace(t); } }; } - - private void runRunner(org.scalatools.testing.Runner runner, Fingerprint fingerprint, EventHandler eventHandler) { + + private void runRunner(final org.scalatools.testing.Runner runner, final Fingerprint fingerprint, final EventHandler eventHandler) { // Old runner only support subclass fingerprint. final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint; - org.scalatools.testing.TestFingerprint oldFingerprint = + final org.scalatools.testing.TestFingerprint oldFingerprint = new org.scalatools.testing.TestFingerprint() { public boolean isModule() { return subclassFingerprint.isModule(); } public String superClassName() { return subclassFingerprint.superclassName(); } @@ -202,9 +202,9 @@ final class RunnerWrapper implements Runner { final String name = taskDef.fullyQualifiedName(); runner.run(name, oldFingerprint, new EventHandlerWrapper(eventHandler, name, subclassFingerprint), args); } - - private void runRunner2(org.scalatools.testing.Runner2 runner, Fingerprint fingerprint, EventHandler eventHandler) { - org.scalatools.testing.Fingerprint oldFingerprint = null; + + private void runRunner2(final org.scalatools.testing.Runner2 runner, final Fingerprint fingerprint, final EventHandler eventHandler) { + final org.scalatools.testing.Fingerprint oldFingerprint; if (fingerprint instanceof SubclassFingerprint) { final SubclassFingerprint subclassFingerprint = (SubclassFingerprint) fingerprint; oldFingerprint = new org.scalatools.testing.SubclassFingerprint() { @@ -222,10 +222,10 @@ final class RunnerWrapper implements Runner { final String name = taskDef.fullyQualifiedName(); runner.run(name, oldFingerprint, new EventHandlerWrapper(eventHandler, name, fingerprint), args); } - - public Task[] execute(EventHandler eventHandler, Logger[] loggers) { - int length = loggers.length; - org.scalatools.testing.Logger[] oldLoggers = new org.scalatools.testing.Logger[length]; + + public Task[] execute(final EventHandler eventHandler, final Logger[] loggers) { + final int length = loggers.length; + final org.scalatools.testing.Logger[] oldLoggers = new org.scalatools.testing.Logger[length]; for (int i=0; i