Make code style consistent

kcooney · kcooney · commit a85566fd2b4a · 2013-02-25T17:08:11.000-08:00
diff --git a/src/main/java/org/junit/runner/notification/RunNotifier.java b/src/main/java/org/junit/runner/notification/RunNotifier.java
@@ -45,21 +45,21 @@ public void removeListener(RunListener listener) {
     }
 
     private abstract class SafeNotifier {
-        private final List<RunListener> currentListeners;
+        private final List<RunListener> fCurrentListeners;
 
         SafeNotifier() {
             this(fListeners);
         }
 
         SafeNotifier(List<RunListener> currentListeners) {
-            this.currentListeners = currentListeners;
+            this.fCurrentListeners = currentListeners;
         }
 
         void run() {
-            int capacity = currentListeners.size();
+            int capacity = fCurrentListeners.size();
             ArrayList<RunListener> safeListeners = new ArrayList<RunListener>(capacity);
             ArrayList<Failure> failures = new ArrayList<Failure>(capacity);
-            for (RunListener listener : currentListeners) {
+            for (RunListener listener : fCurrentListeners) {
                 try {
                     notifyListener(listener);
                     safeListeners.add(listener);
diff --git a/src/main/java/org/junit/runner/notification/SynchronizedRunListener.java b/src/main/java/org/junit/runner/notification/SynchronizedRunListener.java
@@ -99,7 +99,7 @@ public boolean equals(Object other) {
         if (!(other instanceof SynchronizedRunListener)) {
             return false;
         }
-        SynchronizedRunListener that= (SynchronizedRunListener) other;
+        SynchronizedRunListener that = (SynchronizedRunListener) other;
         
         return this.fListener.equals(that.fListener);
     }
diff --git a/src/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java b/src/test/java/org/junit/runner/notification/ConcurrentRunNotifierTest.java
@@ -26,41 +26,41 @@
  */
 public final class ConcurrentRunNotifierTest {
     private static final long TIMEOUT = 3;
-    private final RunNotifier notifier = new RunNotifier();
+    private final RunNotifier fNotifier = new RunNotifier();
 
     private static class ConcurrentRunListener extends RunListener {
-        final AtomicInteger testStarted = new AtomicInteger(0);
+        final AtomicInteger fTestStarted = new AtomicInteger(0);
 
         @Override
         public void testStarted(Description description) throws Exception {
-            testStarted.incrementAndGet();
+            fTestStarted.incrementAndGet();
         }
     }
 
     @Test
     public void realUsage() throws Exception {
         ConcurrentRunListener listener1 = new ConcurrentRunListener();
         ConcurrentRunListener listener2 = new ConcurrentRunListener();
-        notifier.addListener(listener1);
-        notifier.addListener(listener2);
+        fNotifier.addListener(listener1);
+        fNotifier.addListener(listener2);
 
         final int numParallelTests = 4;
         ExecutorService pool = Executors.newFixedThreadPool(numParallelTests);
         for (int i = 0; i < numParallelTests; ++i) {
             pool.submit(new Runnable() {
                 public void run() {
-                    notifier.fireTestStarted(null);
+                    fNotifier.fireTestStarted(null);
                 }
             });
         }
         pool.shutdown();
         assertTrue(pool.awaitTermination(TIMEOUT, TimeUnit.SECONDS));
 
-        notifier.removeListener(listener1);
-        notifier.removeListener(listener2);
+        fNotifier.removeListener(listener1);
+        fNotifier.removeListener(listener2);
 
-        assertThat(listener1.testStarted.get(), is(4));
-        assertThat(listener2.testStarted.get(), is(4));
+        assertThat(listener1.fTestStarted.get(), is(4));
+        assertThat(listener2.fTestStarted.get(), is(4));
     }
 
     private static class ExaminedListener extends RunListener {
@@ -73,7 +73,7 @@ private static class ExaminedListener extends RunListener {
 
         @Override
         public void testStarted(Description description) throws Exception {
-            if (!throwFromTestStarted) {
+            if (throwFromTestStarted) {
                 throw new Exception();
             }
         }
@@ -98,7 +98,7 @@ public void test() throws Exception {
                 if (fail) {
                     ++totalListenersFailures;
                 }
-                examinedListeners[i] = new ExaminedListener(!fail);
+                examinedListeners[i] = new ExaminedListener(fail);
             }
 
             final AtomicBoolean condition = new AtomicBoolean(true);
@@ -110,10 +110,10 @@ public void test() throws Exception {
                 public Void call() throws Exception {
                     trigger.await();
                     while (condition.get()) {
-                        notifier.fireTestStarted(null);
+                        fNotifier.fireTestStarted(null);
                         latch.countDown();
                     }
-                    notifier.fireTestStarted(null);
+                    fNotifier.fireTestStarted(null);
                     return null;
                 }
             });
@@ -149,7 +149,7 @@ public void reportConcurrentFailuresAfterAddListener() throws Exception {
         new AbstractConcurrentFailuresTest() {
             @Override
             protected void addListener(ExaminedListener listener) {
-                notifier.addListener(listener);
+                fNotifier.addListener(listener);
             }
         }.test();
     }
@@ -163,7 +163,7 @@ public void reportConcurrentFailuresAfterAddFirstListener() throws Exception {
         new AbstractConcurrentFailuresTest() {
             @Override
             protected void addListener(ExaminedListener listener) {
-                notifier.addFirstListener(listener);
+                fNotifier.addFirstListener(listener);
             }
         }.test();
     }
diff --git a/src/test/java/org/junit/runner/notification/RunNotifierTest.java b/src/test/java/org/junit/runner/notification/RunNotifierTest.java
@@ -11,24 +11,24 @@
 import org.junit.runner.Result;
 
 public class RunNotifierTest {
-    private final RunNotifier notifier = new RunNotifier();
+    private final RunNotifier fNotifier = new RunNotifier();
 
     @Test
     public void notifiesSecondListenerIfFirstThrowsException() {
         FailureListener failureListener = new FailureListener();
-        notifier.addListener(new CorruptListener());
-        notifier.addListener(failureListener);
-        notifier.fireTestFailure(new Failure(null, null));
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.addListener(failureListener);
+        fNotifier.fireTestFailure(new Failure(null, null));
         assertNotNull("The FailureListener registered no failure.",
                 failureListener.failure);
     }
 
     @Test
     public void hasNoProblemsWithFailingListeners() { // see issues 209 and 395
-        notifier.addListener(new CorruptListener());
-        notifier.addListener(new FailureListener());
-        notifier.addListener(new CorruptListener());
-        notifier.fireTestRunFinished(new Result());
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.addListener(new FailureListener());
+        fNotifier.addListener(new CorruptListener());
+        fNotifier.fireTestRunFinished(new Result());
     }
 
     private static class CorruptListener extends RunListener {
@@ -46,49 +46,49 @@ public void testFailure(Failure failure) throws Exception {
     @Test
     public void addAndRemoveWithNonThreadSafeListener() {
         CountingListener listener = new CountingListener();
-        assertThat(listener.testStarted.get(), is(0));
-        notifier.addListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
-        notifier.removeListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
     }
 
     @Test
     public void addFirstAndRemoveWithNonThreadSafeListener() {
         CountingListener listener = new CountingListener();
-        assertThat(listener.testStarted.get(), is(0));
-        notifier.addFirstListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
-        notifier.removeListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addFirstListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
     }
     
     @Test
     public void addAndRemoveWithThreadSafeListener() {
         ThreadSafeListener listener = new ThreadSafeListener();
-        assertThat(listener.testStarted.get(), is(0));
-        notifier.addListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
-        notifier.removeListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
     }
 
     @Test
     public void addFirstAndRemoveWithThreadSafeListener() {
         ThreadSafeListener listener = new ThreadSafeListener();
-        assertThat(listener.testStarted.get(), is(0));
-        notifier.addFirstListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
-        notifier.removeListener(listener);
-        notifier.fireTestStarted(null);
-        assertThat(listener.testStarted.get(), is(1));
+        assertThat(listener.fTestStarted.get(), is(0));
+        fNotifier.addFirstListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
+        fNotifier.removeListener(listener);
+        fNotifier.fireTestStarted(null);
+        assertThat(listener.fTestStarted.get(), is(1));
     }
 
     private static class FailureListener extends RunListener {
@@ -101,11 +101,11 @@ public void testFailure(Failure failure) throws Exception {
     }
     
     private static class CountingListener extends RunListener {
-        final AtomicInteger testStarted = new AtomicInteger(0);
+        final AtomicInteger fTestStarted = new AtomicInteger(0);
 
         @Override
         public void testStarted(Description description) throws Exception {
-            testStarted.incrementAndGet();
+            fTestStarted.incrementAndGet();
         }
     }
     
diff --git a/src/test/java/org/junit/runner/notification/SynchronizedRunListenerTest.java b/src/test/java/org/junit/runner/notification/SynchronizedRunListenerTest.java
@@ -24,24 +24,24 @@
 public class SynchronizedRunListenerTest {
 
     private static class MethodSignature {
-        private final Method method;
-        private final String name;
-        private final List<Class<?>> parameterTypes;
+        private final Method fMethod;
+        private final String fName;
+        private final List<Class<?>> fParameterTypes;
 
         public MethodSignature(Method method) {
-            this.method = method;
-            name = method.getName();
-            parameterTypes = Arrays.asList(method.getParameterTypes());
+            fMethod = method;
+            fName = method.getName();
+            fParameterTypes = Arrays.asList(method.getParameterTypes());
         }
         
         @Override
         public String toString() {
-            return method.toString();
+            return fMethod.toString();
         }
 
         @Override
         public int hashCode() {
-            return name.hashCode();
+            return fName.hashCode();
         }
 
         @Override
@@ -53,7 +53,7 @@ public boolean equals(Object obj) {
                 return false;
             }
             MethodSignature that = (MethodSignature) obj;
-            return name.equals(that.name) && parameterTypes.equals(that.parameterTypes);
+            return fName.equals(that.fName) && fParameterTypes.equals(that.fParameterTypes);
         }
     }
 
@@ -75,15 +75,15 @@ public void overridesAllMethodsInRunListener() {
     }
 
     private static class NamedListener extends RunListener {
-        private final String name;
+        private final String fName;
 
         public NamedListener(String name) {
-            this.name = name;
+            fName = name;
         }
 
         @Override
         public int hashCode() {
-            return name.hashCode();
+            return fName.hashCode();
         }
 
         @Override
@@ -95,7 +95,7 @@ public boolean equals(Object obj) {
                 return false;
             }
             NamedListener that = (NamedListener) obj;
-            return this.name.equals(that.name);
+            return this.fName.equals(that.fName);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ public boolean equals(Object other) {`
`99`	`99`	`if (!(other instanceof SynchronizedRunListener)) {`
`100`	`100`	`return false;`
`101`	`101`	`}`
`102`		`- SynchronizedRunListener that= (SynchronizedRunListener) other;`
	`102`	`+ SynchronizedRunListener that = (SynchronizedRunListener) other;`
`103`	`103`
`104`	`104`	`return this.fListener.equals(that.fListener);`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,24 +24,24 @@`
`24`	`24`	`public class SynchronizedRunListenerTest {`
`25`	`25`
`26`	`26`	`private static class MethodSignature {`
`27`		`- private final Method method;`
`28`		`- private final String name;`
`29`		`- private final List<Class<?>> parameterTypes;`
	`27`	`+ private final Method fMethod;`
	`28`	`+ private final String fName;`
	`29`	`+ private final List<Class<?>> fParameterTypes;`
`30`	`30`
`31`	`31`	`public MethodSignature(Method method) {`
`32`		`- this.method = method;`
`33`		`- name = method.getName();`
`34`		`- parameterTypes = Arrays.asList(method.getParameterTypes());`
	`32`	`+ fMethod = method;`
	`33`	`+ fName = method.getName();`
	`34`	`+ fParameterTypes = Arrays.asList(method.getParameterTypes());`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`@Override`
`38`	`38`	`public String toString() {`
`39`		`- return method.toString();`
	`39`	`+ return fMethod.toString();`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`@Override`
`43`	`43`	`public int hashCode() {`
`44`		`- return name.hashCode();`
	`44`	`+ return fName.hashCode();`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`@Override`
`@@ -53,7 +53,7 @@ public boolean equals(Object obj) {`
`53`	`53`	`return false;`
`54`	`54`	`}`
`55`	`55`	`MethodSignature that = (MethodSignature) obj;`
`56`		`- return name.equals(that.name) && parameterTypes.equals(that.parameterTypes);`
	`56`	`+ return fName.equals(that.fName) && fParameterTypes.equals(that.fParameterTypes);`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`@@ -75,15 +75,15 @@ public void overridesAllMethodsInRunListener() {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`private static class NamedListener extends RunListener {`
`78`		`- private final String name;`
	`78`	`+ private final String fName;`
`79`	`79`
`80`	`80`	`public NamedListener(String name) {`
`81`		`- this.name = name;`
	`81`	`+ fName = name;`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`@Override`
`85`	`85`	`public int hashCode() {`
`86`		`- return name.hashCode();`
	`86`	`+ return fName.hashCode();`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`@Override`
`@@ -95,7 +95,7 @@ public boolean equals(Object obj) {`
`95`	`95`	`return false;`
`96`	`96`	`}`
`97`	`97`	`NamedListener that = (NamedListener) obj;`
`98`		`- return this.name.equals(that.name);`
	`98`	`+ return this.fName.equals(that.fName);`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`