storm-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ptgo...@apache.org
Subject [21/50] [abbrv] Reformat Java code to use 2 instead of 4 spaces (to match Clojure style)
Date Thu, 20 Mar 2014 21:22:44 GMT
http://git-wip-us.apache.org/repos/asf/incubator-storm/blob/a51c8247/test/jvm/storm/starter/tools/NthLastModifiedTimeTrackerTest.java
----------------------------------------------------------------------
diff --git a/test/jvm/storm/starter/tools/NthLastModifiedTimeTrackerTest.java b/test/jvm/storm/starter/tools/NthLastModifiedTimeTrackerTest.java
index 77f8f71..c79d382 100644
--- a/test/jvm/storm/starter/tools/NthLastModifiedTimeTrackerTest.java
+++ b/test/jvm/storm/starter/tools/NthLastModifiedTimeTrackerTest.java
@@ -1,112 +1,108 @@
 package storm.starter.tools;
 
-import static org.fest.assertions.api.Assertions.assertThat;
-
+import backtype.storm.utils.Time;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import backtype.storm.utils.Time;
+import static org.fest.assertions.api.Assertions.assertThat;
 
 public class NthLastModifiedTimeTrackerTest {
 
-    private static final int ANY_NUM_TIMES_TO_TRACK = 3;
-    private static final int MILLIS_IN_SEC = 1000;
-
-    @DataProvider
-    public Object[][] illegalNumTimesData() {
-        return new Object[][] { { -10 }, { -3 }, { -2 }, { -1 }, { 0 } };
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalNumTimesData")
-    public void negativeOrZeroNumTimesToTrackShouldThrowIAE(int numTimesToTrack) {
-        new NthLastModifiedTimeTracker(numTimesToTrack);
-    }
-
-    @DataProvider
-    public Object[][] legalNumTimesData() {
-        return new Object[][] { { 1 }, { 2 }, { 3 }, { 20 } };
-    }
-
-    @Test(dataProvider = "legalNumTimesData")
-    public void positiveNumTimesToTrackShouldBeOk(int numTimesToTrack) {
-        new NthLastModifiedTimeTracker(numTimesToTrack);
-    }
-
-    @DataProvider
-    public Object[][] whenNotYetMarkedAsModifiedData() {
-        return new Object[][] { { 0 }, { 1 }, { 2 }, { 3 }, { 4 }, { 5 }, { 8 }, { 10 } };
+  private static final int ANY_NUM_TIMES_TO_TRACK = 3;
+  private static final int MILLIS_IN_SEC = 1000;
+
+  @DataProvider
+  public Object[][] illegalNumTimesData() {
+    return new Object[][]{ { -10 }, { -3 }, { -2 }, { -1 }, { 0 } };
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalNumTimesData")
+  public void negativeOrZeroNumTimesToTrackShouldThrowIAE(int numTimesToTrack) {
+    new NthLastModifiedTimeTracker(numTimesToTrack);
+  }
+
+  @DataProvider
+  public Object[][] legalNumTimesData() {
+    return new Object[][]{ { 1 }, { 2 }, { 3 }, { 20 } };
+  }
+
+  @Test(dataProvider = "legalNumTimesData")
+  public void positiveNumTimesToTrackShouldBeOk(int numTimesToTrack) {
+    new NthLastModifiedTimeTracker(numTimesToTrack);
+  }
+
+  @DataProvider
+  public Object[][] whenNotYetMarkedAsModifiedData() {
+    return new Object[][]{ { 0 }, { 1 }, { 2 }, { 3 }, { 4 }, { 5 }, { 8 }, { 10 } };
+  }
+
+  @Test(dataProvider = "whenNotYetMarkedAsModifiedData")
+  public void shouldReturnCorrectModifiedTimeEvenWhenNotYetMarkedAsModified(int secondsToAdvance) {
+    // given
+    Time.startSimulating();
+    NthLastModifiedTimeTracker tracker = new NthLastModifiedTimeTracker(ANY_NUM_TIMES_TO_TRACK);
+
+    // when
+    advanceSimulatedTimeBy(secondsToAdvance);
+    int seconds = tracker.secondsSinceOldestModification();
+
+    // then
+    assertThat(seconds).isEqualTo(secondsToAdvance);
+
+    // cleanup
+    Time.stopSimulating();
+  }
+
+  @DataProvider
+  public Object[][] simulatedTrackerIterations() {
+    return new Object[][]{ { 1, new int[]{ 0, 1 }, new int[]{ 0, 0 } }, { 1, new int[]{ 0, 2 }, new int[]{ 0, 0 } },
+        { 2, new int[]{ 2, 2 }, new int[]{ 2, 2 } }, { 2, new int[]{ 0, 4 }, new int[]{ 0, 4 } },
+        { 1, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 0, 0, 0, 0, 0, 0, 0 } },
+        { 1, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 0, 0, 0, 0, 0, 0, 0 } },
+        { 2, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 1, 1, 1, 1, 1, 1, 1 } },
+        { 2, new int[]{ 2, 2, 2, 2, 2, 2, 2 }, new int[]{ 2, 2, 2, 2, 2, 2, 2 } },
+        { 2, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 1, 2, 3, 4, 5, 6, 7 } },
+        { 3, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 1, 2, 2, 2, 2, 2, 2 } },
+        { 3, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 1, 3, 5, 7, 9, 11, 13 } },
+        { 3, new int[]{ 2, 2, 2, 2, 2, 2, 2 }, new int[]{ 2, 4, 4, 4, 4, 4, 4 } },
+        { 4, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 1, 2, 3, 3, 3, 3, 3 } },
+        { 4, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 1, 3, 6, 9, 12, 15, 18 } },
+        { 4, new int[]{ 2, 2, 2, 2, 2, 2, 2 }, new int[]{ 2, 4, 6, 6, 6, 6, 6 } },
+        { 5, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 1, 2, 3, 4, 4, 4, 4 } },
+        { 5, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 1, 3, 6, 10, 14, 18, 22 } },
+        { 5, new int[]{ 2, 2, 2, 2, 2, 2, 2 }, new int[]{ 2, 4, 6, 8, 8, 8, 8 } },
+        { 6, new int[]{ 1, 1, 1, 1, 1, 1, 1 }, new int[]{ 1, 2, 3, 4, 5, 5, 5 } },
+        { 6, new int[]{ 1, 2, 3, 4, 5, 6, 7 }, new int[]{ 1, 3, 6, 10, 15, 20, 25 } },
+        { 6, new int[]{ 2, 2, 2, 2, 2, 2, 2 }, new int[]{ 2, 4, 6, 8, 10, 10, 10 } },
+        { 3, new int[]{ 1, 2, 3 }, new int[]{ 1, 3, 5 } } };
+  }
+
+  @Test(dataProvider = "simulatedTrackerIterations")
+  public void shouldReturnCorrectModifiedTimeWhenMarkedAsModified(int numTimesToTrack,
+      int[] secondsToAdvancePerIteration, int[] expLastModifiedTimes) {
+    // given
+    Time.startSimulating();
+    NthLastModifiedTimeTracker tracker = new NthLastModifiedTimeTracker(numTimesToTrack);
+
+    int[] modifiedTimes = new int[expLastModifiedTimes.length];
+
+    // when
+    int i = 0;
+    for (int secondsToAdvance : secondsToAdvancePerIteration) {
+      advanceSimulatedTimeBy(secondsToAdvance);
+      tracker.markAsModified();
+      modifiedTimes[i] = tracker.secondsSinceOldestModification();
+      i++;
     }
 
-    @Test(dataProvider = "whenNotYetMarkedAsModifiedData")
-    public void shouldReturnCorrectModifiedTimeEvenWhenNotYetMarkedAsModified(int secondsToAdvance) {
-        // given
-        Time.startSimulating();
-        NthLastModifiedTimeTracker tracker = new NthLastModifiedTimeTracker(ANY_NUM_TIMES_TO_TRACK);
+    // then
+    assertThat(modifiedTimes).isEqualTo(expLastModifiedTimes);
 
-        // when
-        advanceSimulatedTimeBy(secondsToAdvance);
-        int seconds = tracker.secondsSinceOldestModification();
-
-        // then
-        assertThat(seconds).isEqualTo(secondsToAdvance);
-
-        // cleanup
-        Time.stopSimulating();
-    }
+    // cleanup
+    Time.stopSimulating();
+  }
 
-    @DataProvider
-    public Object[][] simulatedTrackerIterations() {
-        return new Object[][] {
-                { 1, new int[] { 0, 1 }, new int[] { 0, 0 } },
-                { 1, new int[] { 0, 2 }, new int[] { 0, 0 } },
-                { 2, new int[] { 2, 2 }, new int[] { 2, 2 } },
-                { 2, new int[] { 0, 4 }, new int[] { 0, 4 } },
-                { 1, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 0, 0, 0, 0, 0, 0, 0 } },
-                { 1, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 0, 0, 0, 0, 0, 0, 0 } },
-                { 2, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 1, 1, 1, 1, 1, 1, 1 } },
-                { 2, new int[] { 2, 2, 2, 2, 2, 2, 2 }, new int[] { 2, 2, 2, 2, 2, 2, 2 } },
-                { 2, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 1, 2, 3, 4, 5, 6, 7 } },
-                { 3, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 1, 2, 2, 2, 2, 2, 2 } },
-                { 3, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 1, 3, 5, 7, 9, 11, 13 } },
-                { 3, new int[] { 2, 2, 2, 2, 2, 2, 2 }, new int[] { 2, 4, 4, 4, 4, 4, 4 } },
-                { 4, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 1, 2, 3, 3, 3, 3, 3 } },
-                { 4, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 1, 3, 6, 9, 12, 15, 18 } },
-                { 4, new int[] { 2, 2, 2, 2, 2, 2, 2 }, new int[] { 2, 4, 6, 6, 6, 6, 6 } },
-                { 5, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 1, 2, 3, 4, 4, 4, 4 } },
-                { 5, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 1, 3, 6, 10, 14, 18, 22 } },
-                { 5, new int[] { 2, 2, 2, 2, 2, 2, 2 }, new int[] { 2, 4, 6, 8, 8, 8, 8 } },
-                { 6, new int[] { 1, 1, 1, 1, 1, 1, 1 }, new int[] { 1, 2, 3, 4, 5, 5, 5 } },
-                { 6, new int[] { 1, 2, 3, 4, 5, 6, 7 }, new int[] { 1, 3, 6, 10, 15, 20, 25 } },
-                { 6, new int[] { 2, 2, 2, 2, 2, 2, 2 }, new int[] { 2, 4, 6, 8, 10, 10, 10 } },
-                { 3, new int[] { 1, 2, 3 }, new int[] { 1, 3, 5 } } };
-    }
-
-    @Test(dataProvider = "simulatedTrackerIterations")
-    public void shouldReturnCorrectModifiedTimeWhenMarkedAsModified(int numTimesToTrack,
-        int[] secondsToAdvancePerIteration, int[] expLastModifiedTimes) {
-        // given
-        Time.startSimulating();
-        NthLastModifiedTimeTracker tracker = new NthLastModifiedTimeTracker(numTimesToTrack);
-
-        int[] modifiedTimes = new int[expLastModifiedTimes.length];
-
-        // when
-        int i = 0;
-        for (int secondsToAdvance : secondsToAdvancePerIteration) {
-            advanceSimulatedTimeBy(secondsToAdvance);
-            tracker.markAsModified();
-            modifiedTimes[i] = tracker.secondsSinceOldestModification();
-            i++;
-        }
-
-        // then
-        assertThat(modifiedTimes).isEqualTo(expLastModifiedTimes);
-
-        // cleanup
-        Time.stopSimulating();
-    }
-
-    private void advanceSimulatedTimeBy(int seconds) {
-        Time.advanceTime(seconds * MILLIS_IN_SEC);
-    }
+  private void advanceSimulatedTimeBy(int seconds) {
+    Time.advanceTime(seconds * MILLIS_IN_SEC);
+  }
 }

http://git-wip-us.apache.org/repos/asf/incubator-storm/blob/a51c8247/test/jvm/storm/starter/tools/RankableObjectWithFieldsTest.java
----------------------------------------------------------------------
diff --git a/test/jvm/storm/starter/tools/RankableObjectWithFieldsTest.java b/test/jvm/storm/starter/tools/RankableObjectWithFieldsTest.java
index b2360c1..c8a14cc 100644
--- a/test/jvm/storm/starter/tools/RankableObjectWithFieldsTest.java
+++ b/test/jvm/storm/starter/tools/RankableObjectWithFieldsTest.java
@@ -1,225 +1,214 @@
 package storm.starter.tools;
 
-import static org.fest.assertions.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.testng.Assert.assertFalse;
-import static org.testng.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.List;
-
+import backtype.storm.tuple.Tuple;
+import com.google.common.collect.Lists;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import backtype.storm.tuple.Tuple;
+import java.util.ArrayList;
+import java.util.List;
 
-import com.google.common.collect.Lists;
+import static org.fest.assertions.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
 
 public class RankableObjectWithFieldsTest {
 
-    private static final Object ANY_OBJECT = new Object();
-    private static final long ANY_COUNT = 271;
-    private static final String ANY_FIELD = "someAdditionalField";
-    private static final int GREATER_THAN = 1;
-    private static final int EQUAL_TO = 0;
-    private static final int SMALLER_THAN = -1;
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void constructorWithNullObjectAndNoFieldsShouldThrowIAE() {
-        new RankableObjectWithFields(null, ANY_COUNT);
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void constructorWithNullObjectAndFieldsShouldThrowIAE() {
-        Object someAdditionalField = new Object();
-        new RankableObjectWithFields(null, ANY_COUNT, someAdditionalField);
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void constructorWithNegativeCountAndNoFieldsShouldThrowIAE() {
-        new RankableObjectWithFields(ANY_OBJECT, -1);
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void constructorWithNegativeCountAndFieldsShouldThrowIAE() {
-        Object someAdditionalField = new Object();
-        new RankableObjectWithFields(ANY_OBJECT, -1, someAdditionalField);
-    }
-
-    @Test
-    public void shouldBeEqualToItself() {
-        RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
-        assertThat(r).isEqualTo(r);
-    }
-
-    @DataProvider
-    public Object[][] otherClassesData() {
-        return new Object[][] {
-                { new String("foo") },
-                { new Object() },
-                { Integer.valueOf(4) },
-                { Lists.newArrayList(7, 8, 9) } };
-    }
-
-    @Test(dataProvider = "otherClassesData")
-    public void shouldNotBeEqualToInstancesOfOtherClasses(Object notARankable) {
-        RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
-        assertFalse(r.equals(notARankable), r + " is equal to " + notARankable + " but it should not be");
-    }
-
-    @DataProvider
-    public Object[][] falseDuplicatesData() {
-        return new Object[][] {
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1) },
-                { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("Foo", 1) },
-                { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("FOO", 1) },
-                { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 1) },
-                { new RankableObjectWithFields("", 0), new RankableObjectWithFields("", 1) },
-                { new RankableObjectWithFields("", 1), new RankableObjectWithFields("bar", 1) } };
-    }
-
-    @Test(dataProvider = "falseDuplicatesData")
-    public void shouldNotBeEqualToFalseDuplicates(RankableObjectWithFields r, RankableObjectWithFields falseDuplicate) {
-        assertFalse(r.equals(falseDuplicate), r + " is equal to " + falseDuplicate + " but it should not be");
-    }
-
-    @Test(dataProvider = "falseDuplicatesData")
-    public void shouldHaveDifferentHashCodeThanFalseDuplicates(RankableObjectWithFields r,
-        RankableObjectWithFields falseDuplicate) {
-        assertThat(r.hashCode()).isNotEqualTo(falseDuplicate.hashCode());
-    }
-
-    @DataProvider
-    public Object[][] trueDuplicatesData() {
-        return new Object[][] {
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0) },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0, "someOtherField") },
-                {
-                        new RankableObjectWithFields("foo", 0, "someField"),
-                        new RankableObjectWithFields("foo", 0, "someOtherField") } };
-    }
-
-    @Test(dataProvider = "trueDuplicatesData")
-    public void shouldBeEqualToTrueDuplicates(RankableObjectWithFields r, RankableObjectWithFields trueDuplicate) {
-        assertTrue(r.equals(trueDuplicate), r + " is not equal to " + trueDuplicate + " but it should be");
-    }
-
-    @Test(dataProvider = "trueDuplicatesData")
-    public void shouldHaveSameHashCodeAsTrueDuplicates(RankableObjectWithFields r,
-        RankableObjectWithFields trueDuplicate) {
-        assertThat(r.hashCode()).isEqualTo(trueDuplicate.hashCode());
-    }
-
-    @DataProvider
-    public Object[][] compareToData() {
-        return new Object[][] {
-                { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("foo", 0), GREATER_THAN },
-                { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("foo", 0), GREATER_THAN },
-                { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("bar", 0), GREATER_THAN },
-                { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 0), GREATER_THAN },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0), EQUAL_TO },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 0), EQUAL_TO },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1000), SMALLER_THAN },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1), SMALLER_THAN },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1), SMALLER_THAN },
-                { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1000), SMALLER_THAN }, };
-    }
-
-    @Test(dataProvider = "compareToData")
-    public void verifyCompareTo(RankableObjectWithFields first, RankableObjectWithFields second, int expCompareToValue) {
-        assertThat(first.compareTo(second)).isEqualTo(expCompareToValue);
-    }
-
-    @DataProvider
-    public Object[][] toStringData() {
-        return new Object[][] { { new String("foo"), 0L }, { new String("BAR"), 8L } };
-    }
-
-    @Test(dataProvider = "toStringData")
-    public void toStringShouldContainStringRepresentationsOfObjectAndCount(Object obj, long count) {
-        // given
-        RankableObjectWithFields r = new RankableObjectWithFields(obj, count);
-
-        // when
-        String strRepresentation = r.toString();
-
-        // then
-        assertThat(strRepresentation).contains(obj.toString()).contains("" + count);
-    }
-
-    @Test
-    public void shouldReturnTheObject() {
-        // given
-        RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
-
-        // when
-        Object obj = r.getObject();
-
-        // then
-        assertThat(obj).isEqualTo(ANY_OBJECT);
-    }
-
-    @Test
-    public void shouldReturnTheCount() {
-        // given
-        RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
-
-        // when
-        long count = r.getCount();
-
-        // then
-        assertThat(count).isEqualTo(ANY_COUNT);
-    }
-
-    @DataProvider
-    public Object[][] fieldsData() {
-        return new Object[][] {
-                { ANY_OBJECT, ANY_COUNT, new Object[] { ANY_FIELD } },
-                { "quux", 42L, new Object[] { "one", "two", "three" } } };
-    }
-
-    @Test(dataProvider = "fieldsData")
-    public void shouldReturnTheFields(Object obj, long count, Object[] fields) {
-        // given
-        RankableObjectWithFields r = new RankableObjectWithFields(obj, count, fields);
-
-        // when
-        List<Object> actualFields = r.getFields();
-
-        // then
-        assertThat(actualFields).isEqualTo(Lists.newArrayList(fields));
-    }
-
-    @Test(expectedExceptions = UnsupportedOperationException.class)
-    public void fieldsShouldBeImmutable() {
-        // given
-        RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
-
-        // when
-        List<Object> fields = r.getFields();
-        // try to modify the list, which should fail
-        fields.remove(0);
-
-        // then (exception)
-    }
-
-    @Test
-    public void shouldCreateRankableObjectFromTuple() {
-        // given
-        Tuple tuple = mock(Tuple.class);
-        List<Object> tupleValues = Lists.newArrayList(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
-        when(tuple.getValues()).thenReturn(tupleValues);
-
-        // when
-        RankableObjectWithFields r = RankableObjectWithFields.from(tuple);
-
-        // then
-        assertThat(r.getObject()).isEqualTo(ANY_OBJECT);
-        assertThat(r.getCount()).isEqualTo(ANY_COUNT);
-        List<Object> fields = new ArrayList<Object>();
-        fields.add(ANY_FIELD);
-        assertThat(r.getFields()).isEqualTo(fields);
-
-    }
+  private static final Object ANY_OBJECT = new Object();
+  private static final long ANY_COUNT = 271;
+  private static final String ANY_FIELD = "someAdditionalField";
+  private static final int GREATER_THAN = 1;
+  private static final int EQUAL_TO = 0;
+  private static final int SMALLER_THAN = -1;
+
+  @Test(expectedExceptions = IllegalArgumentException.class)
+  public void constructorWithNullObjectAndNoFieldsShouldThrowIAE() {
+    new RankableObjectWithFields(null, ANY_COUNT);
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class)
+  public void constructorWithNullObjectAndFieldsShouldThrowIAE() {
+    Object someAdditionalField = new Object();
+    new RankableObjectWithFields(null, ANY_COUNT, someAdditionalField);
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class)
+  public void constructorWithNegativeCountAndNoFieldsShouldThrowIAE() {
+    new RankableObjectWithFields(ANY_OBJECT, -1);
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class)
+  public void constructorWithNegativeCountAndFieldsShouldThrowIAE() {
+    Object someAdditionalField = new Object();
+    new RankableObjectWithFields(ANY_OBJECT, -1, someAdditionalField);
+  }
+
+  @Test
+  public void shouldBeEqualToItself() {
+    RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
+    assertThat(r).isEqualTo(r);
+  }
+
+  @DataProvider
+  public Object[][] otherClassesData() {
+    return new Object[][]{ { new String("foo") }, { new Object() }, { Integer.valueOf(4) }, { Lists.newArrayList(7, 8,
+        9) } };
+  }
+
+  @Test(dataProvider = "otherClassesData")
+  public void shouldNotBeEqualToInstancesOfOtherClasses(Object notARankable) {
+    RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
+    assertFalse(r.equals(notARankable), r + " is equal to " + notARankable + " but it should not be");
+  }
+
+  @DataProvider
+  public Object[][] falseDuplicatesData() {
+    return new Object[][]{ { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1) },
+        { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("Foo", 1) },
+        { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("FOO", 1) },
+        { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 1) },
+        { new RankableObjectWithFields("", 0), new RankableObjectWithFields("", 1) }, { new RankableObjectWithFields("",
+        1), new RankableObjectWithFields("bar", 1) } };
+  }
+
+  @Test(dataProvider = "falseDuplicatesData")
+  public void shouldNotBeEqualToFalseDuplicates(RankableObjectWithFields r, RankableObjectWithFields falseDuplicate) {
+    assertFalse(r.equals(falseDuplicate), r + " is equal to " + falseDuplicate + " but it should not be");
+  }
+
+  @Test(dataProvider = "falseDuplicatesData")
+  public void shouldHaveDifferentHashCodeThanFalseDuplicates(RankableObjectWithFields r,
+      RankableObjectWithFields falseDuplicate) {
+    assertThat(r.hashCode()).isNotEqualTo(falseDuplicate.hashCode());
+  }
+
+  @DataProvider
+  public Object[][] trueDuplicatesData() {
+    return new Object[][]{ { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0) },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0, "someOtherField") },
+        { new RankableObjectWithFields("foo", 0, "someField"), new RankableObjectWithFields("foo", 0,
+            "someOtherField") } };
+  }
+
+  @Test(dataProvider = "trueDuplicatesData")
+  public void shouldBeEqualToTrueDuplicates(RankableObjectWithFields r, RankableObjectWithFields trueDuplicate) {
+    assertTrue(r.equals(trueDuplicate), r + " is not equal to " + trueDuplicate + " but it should be");
+  }
+
+  @Test(dataProvider = "trueDuplicatesData")
+  public void shouldHaveSameHashCodeAsTrueDuplicates(RankableObjectWithFields r,
+      RankableObjectWithFields trueDuplicate) {
+    assertThat(r.hashCode()).isEqualTo(trueDuplicate.hashCode());
+  }
+
+  @DataProvider
+  public Object[][] compareToData() {
+    return new Object[][]{ { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("foo", 0),
+        GREATER_THAN }, { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("foo", 0),
+        GREATER_THAN }, { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("bar", 0),
+        GREATER_THAN }, { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 0),
+        GREATER_THAN }, { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0), EQUAL_TO },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 0), EQUAL_TO },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1000), SMALLER_THAN },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1), SMALLER_THAN },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1), SMALLER_THAN },
+        { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1000), SMALLER_THAN }, };
+  }
+
+  @Test(dataProvider = "compareToData")
+  public void verifyCompareTo(RankableObjectWithFields first, RankableObjectWithFields second, int expCompareToValue) {
+    assertThat(first.compareTo(second)).isEqualTo(expCompareToValue);
+  }
+
+  @DataProvider
+  public Object[][] toStringData() {
+    return new Object[][]{ { new String("foo"), 0L }, { new String("BAR"), 8L } };
+  }
+
+  @Test(dataProvider = "toStringData")
+  public void toStringShouldContainStringRepresentationsOfObjectAndCount(Object obj, long count) {
+    // given
+    RankableObjectWithFields r = new RankableObjectWithFields(obj, count);
+
+    // when
+    String strRepresentation = r.toString();
+
+    // then
+    assertThat(strRepresentation).contains(obj.toString()).contains("" + count);
+  }
+
+  @Test
+  public void shouldReturnTheObject() {
+    // given
+    RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
+
+    // when
+    Object obj = r.getObject();
+
+    // then
+    assertThat(obj).isEqualTo(ANY_OBJECT);
+  }
+
+  @Test
+  public void shouldReturnTheCount() {
+    // given
+    RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
+
+    // when
+    long count = r.getCount();
+
+    // then
+    assertThat(count).isEqualTo(ANY_COUNT);
+  }
+
+  @DataProvider
+  public Object[][] fieldsData() {
+    return new Object[][]{ { ANY_OBJECT, ANY_COUNT, new Object[]{ ANY_FIELD } },
+        { "quux", 42L, new Object[]{ "one", "two", "three" } } };
+  }
+
+  @Test(dataProvider = "fieldsData")
+  public void shouldReturnTheFields(Object obj, long count, Object[] fields) {
+    // given
+    RankableObjectWithFields r = new RankableObjectWithFields(obj, count, fields);
+
+    // when
+    List<Object> actualFields = r.getFields();
+
+    // then
+    assertThat(actualFields).isEqualTo(Lists.newArrayList(fields));
+  }
+
+  @Test(expectedExceptions = UnsupportedOperationException.class)
+  public void fieldsShouldBeImmutable() {
+    // given
+    RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
+
+    // when
+    List<Object> fields = r.getFields();
+    // try to modify the list, which should fail
+    fields.remove(0);
+
+    // then (exception)
+  }
+
+  @Test
+  public void shouldCreateRankableObjectFromTuple() {
+    // given
+    Tuple tuple = mock(Tuple.class);
+    List<Object> tupleValues = Lists.newArrayList(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
+    when(tuple.getValues()).thenReturn(tupleValues);
+
+    // when
+    RankableObjectWithFields r = RankableObjectWithFields.from(tuple);
+
+    // then
+    assertThat(r.getObject()).isEqualTo(ANY_OBJECT);
+    assertThat(r.getCount()).isEqualTo(ANY_COUNT);
+    List<Object> fields = new ArrayList<Object>();
+    fields.add(ANY_FIELD);
+    assertThat(r.getFields()).isEqualTo(fields);
+
+  }
 }

http://git-wip-us.apache.org/repos/asf/incubator-storm/blob/a51c8247/test/jvm/storm/starter/tools/RankingsTest.java
----------------------------------------------------------------------
diff --git a/test/jvm/storm/starter/tools/RankingsTest.java b/test/jvm/storm/starter/tools/RankingsTest.java
index b95a86f..138a8b3 100644
--- a/test/jvm/storm/starter/tools/RankingsTest.java
+++ b/test/jvm/storm/starter/tools/RankingsTest.java
@@ -1,248 +1,235 @@
 package storm.starter.tools;
 
-import static org.fest.assertions.api.Assertions.assertThat;
-
-import java.util.List;
-
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
 import org.jmock.lib.concurrent.Blitzer;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import com.google.common.collect.Lists;
-
-public class RankingsTest {
-
-    private static final int ANY_TOPN = 42;
-    private static final Rankable ANY_RANKABLE = new RankableObjectWithFields("someObject", ANY_TOPN);
-    private static final Rankable A = new RankableObjectWithFields("A", 1);
-    private static final Rankable B = new RankableObjectWithFields("B", 2);
-    private static final Rankable C = new RankableObjectWithFields("C", 3);
-    private static final Rankable D = new RankableObjectWithFields("D", 4);
-    private static final Rankable E = new RankableObjectWithFields("E", 5);
-    private static final Rankable F = new RankableObjectWithFields("F", 6);
-    private static final Rankable G = new RankableObjectWithFields("G", 7);
-    private static final Rankable H = new RankableObjectWithFields("H", 8);
-
-    @DataProvider
-    public Object[][] illegalTopNData() {
-        return new Object[][] { { 0 }, { -1 }, { -2 }, { -10 } };
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalTopNData")
-    public void constructorWithNegativeOrZeroTopNShouldThrowIAE(int topN) {
-        new Rankings(topN);
-    }
-
-    @DataProvider
-    public Object[][] legalTopNData() {
-        return new Object[][] { { 1 }, { 2 }, { 1000 }, { 1000000 } };
-    }
-
-    @Test(dataProvider = "legalTopNData")
-    public void constructorWithPositiveTopNShouldBeOk(int topN) {
-        // given/when
-        Rankings rankings = new Rankings(topN);
-
-        // then
-        assertThat(rankings.maxSize()).isEqualTo(topN);
-    }
-
-    @Test
-    public void shouldHaveDefaultConstructor() {
-        new Rankings();
-    }
-
-    @Test
-    public void defaultConstructorShouldSetPositiveTopN() {
-        // given/when
-        Rankings rankings = new Rankings();
-
-        // then
-        assertThat(rankings.maxSize()).isGreaterThan(0);
-    }
-
-    @DataProvider
-    public Object[][] rankingsGrowData() {
-        return new Object[][] {
-                {
-                        2,
-                        Lists.newArrayList(new RankableObjectWithFields("A", 1), new RankableObjectWithFields("B", 2),
-                            new RankableObjectWithFields("C", 3)) },
-                {
-                        2,
-                        Lists.newArrayList(new RankableObjectWithFields("A", 1), new RankableObjectWithFields("B", 2),
-                            new RankableObjectWithFields("C", 3), new RankableObjectWithFields("D", 4)) } };
-    }
-
-    @Test(dataProvider = "rankingsGrowData")
-    public void sizeOfRankingsShouldNotGrowBeyondTopN(int topN, List<Rankable> rankables) {
-        // sanity check of the provided test data
-        assertThat(rankables.size()).overridingErrorMessage(
-            "The supplied test data is not correct: the number of rankables <%d> should be greater than <%d>",
-            rankables.size(), topN).isGreaterThan(topN);
-
-        // given
-        Rankings rankings = new Rankings(topN);
-
-        // when
-        for (Rankable r : rankables) {
-            rankings.updateWith(r);
-        }
-
-        // then
-        assertThat(rankings.size()).isLessThanOrEqualTo(rankings.maxSize());
-    }
-
-    @DataProvider
-    public Object[][] simulatedRankingsData() {
-        return new Object[][] {
-                { Lists.newArrayList(A), Lists.newArrayList(A) },
-                { Lists.newArrayList(B, D, A, C), Lists.newArrayList(D, C, B, A) },
-                { Lists.newArrayList(B, F, A, C, D, E), Lists.newArrayList(F, E, D, C, B, A) },
-                { Lists.newArrayList(G, B, F, A, C, D, E, H), Lists.newArrayList(H, G, F, E, D, C, B, A) } };
-    }
-
-    @Test(dataProvider = "simulatedRankingsData")
-    public void shouldCorrectlyRankWhenUpdatedWithRankables(List<Rankable> unsorted, List<Rankable> expSorted) {
-        // given
-        Rankings rankings = new Rankings(unsorted.size());
-
-        // when
-        for (Rankable r : unsorted) {
-            rankings.updateWith(r);
-        }
-
-        // then
-        assertThat(rankings.getRankings()).isEqualTo(expSorted);
-    }
-
-    @Test(dataProvider = "simulatedRankingsData")
-    public void shouldCorrectlyRankWhenEmptyAndUpdatedWithOtherRankings(List<Rankable> unsorted,
-        List<Rankable> expSorted) {
-        // given
-        Rankings rankings = new Rankings(unsorted.size());
-        Rankings otherRankings = new Rankings(rankings.maxSize());
-        for (Rankable r : unsorted) {
-            otherRankings.updateWith(r);
-        }
-
-        // when
-        rankings.updateWith(otherRankings);
-
-        // then
-        assertThat(rankings.getRankings()).isEqualTo(expSorted);
-    }
-
-    @Test(dataProvider = "simulatedRankingsData")
-    public void shouldCorrectlyRankWhenUpdatedWithEmptyOtherRankings(List<Rankable> unsorted, List<Rankable> expSorted) {
-        // given
-        Rankings rankings = new Rankings(unsorted.size());
-        for (Rankable r : unsorted) {
-            rankings.updateWith(r);
-        }
-        Rankings emptyRankings = new Rankings(ANY_TOPN);
-
-        // when
-        rankings.updateWith(emptyRankings);
-
-        // then
-        assertThat(rankings.getRankings()).isEqualTo(expSorted);
-    }
-
-    @DataProvider
-    public Object[][] simulatedRankingsAndOtherRankingsData() {
-        return new Object[][] {
-                { Lists.newArrayList(A), Lists.newArrayList(A), Lists.newArrayList(A) },
-                { Lists.newArrayList(A, C), Lists.newArrayList(B, D), Lists.newArrayList(D, C, B, A) },
-                { Lists.newArrayList(B, F, A), Lists.newArrayList(C, D, E), Lists.newArrayList(F, E, D, C, B, A) },
-                {
-                        Lists.newArrayList(G, B, F, A, C),
-                        Lists.newArrayList(D, E, H),
-                        Lists.newArrayList(H, G, F, E, D, C, B, A) } };
-    }
-
-    @Test(dataProvider = "simulatedRankingsAndOtherRankingsData")
-    public void shouldCorrectlyRankWhenNotEmptyAndUpdatedWithOtherRankings(List<Rankable> unsorted,
-        List<Rankable> unsortedForOtherRankings, List<Rankable> expSorted) {
-        // given
-        Rankings rankings = new Rankings(expSorted.size());
-        for (Rankable r : unsorted) {
-            rankings.updateWith(r);
-        }
-        Rankings otherRankings = new Rankings(unsortedForOtherRankings.size());
-        for (Rankable r : unsortedForOtherRankings) {
-            otherRankings.updateWith(r);
-        }
-
-        // when
-        rankings.updateWith(otherRankings);
-
-        // then
-        assertThat(rankings.getRankings()).isEqualTo(expSorted);
-    }
+import java.util.List;
 
-    @DataProvider
-    public Object[][] duplicatesData() {
-        Rankable A1 = new RankableObjectWithFields("A", 1);
-        Rankable A2 = new RankableObjectWithFields("A", 2);
-        Rankable A3 = new RankableObjectWithFields("A", 3);
-        return new Object[][] {
-                { Lists.newArrayList(ANY_RANKABLE, ANY_RANKABLE, ANY_RANKABLE) },
-                { Lists.newArrayList(A1, A2, A3) }, };
-    }
+import static org.fest.assertions.api.Assertions.assertThat;
 
-    @Test(dataProvider = "duplicatesData")
-    public void shouldNotRankDuplicateObjectsMoreThanOnce(List<Rankable> duplicates) {
-        // given
-        Rankings rankings = new Rankings(duplicates.size());
+public class RankingsTest {
 
-        // when
-        for (Rankable r : duplicates) {
+  private static final int ANY_TOPN = 42;
+  private static final Rankable ANY_RANKABLE = new RankableObjectWithFields("someObject", ANY_TOPN);
+  private static final Rankable A = new RankableObjectWithFields("A", 1);
+  private static final Rankable B = new RankableObjectWithFields("B", 2);
+  private static final Rankable C = new RankableObjectWithFields("C", 3);
+  private static final Rankable D = new RankableObjectWithFields("D", 4);
+  private static final Rankable E = new RankableObjectWithFields("E", 5);
+  private static final Rankable F = new RankableObjectWithFields("F", 6);
+  private static final Rankable G = new RankableObjectWithFields("G", 7);
+  private static final Rankable H = new RankableObjectWithFields("H", 8);
+
+  @DataProvider
+  public Object[][] illegalTopNData() {
+    return new Object[][]{ { 0 }, { -1 }, { -2 }, { -10 } };
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalTopNData")
+  public void constructorWithNegativeOrZeroTopNShouldThrowIAE(int topN) {
+    new Rankings(topN);
+  }
+
+  @DataProvider
+  public Object[][] legalTopNData() {
+    return new Object[][]{ { 1 }, { 2 }, { 1000 }, { 1000000 } };
+  }
+
+  @Test(dataProvider = "legalTopNData")
+  public void constructorWithPositiveTopNShouldBeOk(int topN) {
+    // given/when
+    Rankings rankings = new Rankings(topN);
+
+    // then
+    assertThat(rankings.maxSize()).isEqualTo(topN);
+  }
+
+  @Test
+  public void shouldHaveDefaultConstructor() {
+    new Rankings();
+  }
+
+  @Test
+  public void defaultConstructorShouldSetPositiveTopN() {
+    // given/when
+    Rankings rankings = new Rankings();
+
+    // then
+    assertThat(rankings.maxSize()).isGreaterThan(0);
+  }
+
+  @DataProvider
+  public Object[][] rankingsGrowData() {
+    return new Object[][]{ { 2, Lists.newArrayList(new RankableObjectWithFields("A", 1), new RankableObjectWithFields(
+        "B", 2), new RankableObjectWithFields("C", 3)) }, { 2, Lists.newArrayList(new RankableObjectWithFields("A", 1),
+        new RankableObjectWithFields("B", 2), new RankableObjectWithFields("C", 3), new RankableObjectWithFields("D",
+        4)) } };
+  }
+
+  @Test(dataProvider = "rankingsGrowData")
+  public void sizeOfRankingsShouldNotGrowBeyondTopN(int topN, List<Rankable> rankables) {
+    // sanity check of the provided test data
+    assertThat(rankables.size()).overridingErrorMessage(
+        "The supplied test data is not correct: the number of rankables <%d> should be greater than <%d>",
+        rankables.size(), topN).isGreaterThan(topN);
+
+    // given
+    Rankings rankings = new Rankings(topN);
+
+    // when
+    for (Rankable r : rankables) {
+      rankings.updateWith(r);
+    }
+
+    // then
+    assertThat(rankings.size()).isLessThanOrEqualTo(rankings.maxSize());
+  }
+
+  @DataProvider
+  public Object[][] simulatedRankingsData() {
+    return new Object[][]{ { Lists.newArrayList(A), Lists.newArrayList(A) }, { Lists.newArrayList(B, D, A, C),
+        Lists.newArrayList(D, C, B, A) }, { Lists.newArrayList(B, F, A, C, D, E), Lists.newArrayList(F, E, D, C, B,
+        A) }, { Lists.newArrayList(G, B, F, A, C, D, E, H), Lists.newArrayList(H, G, F, E, D, C, B, A) } };
+  }
+
+  @Test(dataProvider = "simulatedRankingsData")
+  public void shouldCorrectlyRankWhenUpdatedWithRankables(List<Rankable> unsorted, List<Rankable> expSorted) {
+    // given
+    Rankings rankings = new Rankings(unsorted.size());
+
+    // when
+    for (Rankable r : unsorted) {
+      rankings.updateWith(r);
+    }
+
+    // then
+    assertThat(rankings.getRankings()).isEqualTo(expSorted);
+  }
+
+  @Test(dataProvider = "simulatedRankingsData")
+  public void shouldCorrectlyRankWhenEmptyAndUpdatedWithOtherRankings(List<Rankable> unsorted,
+      List<Rankable> expSorted) {
+    // given
+    Rankings rankings = new Rankings(unsorted.size());
+    Rankings otherRankings = new Rankings(rankings.maxSize());
+    for (Rankable r : unsorted) {
+      otherRankings.updateWith(r);
+    }
+
+    // when
+    rankings.updateWith(otherRankings);
+
+    // then
+    assertThat(rankings.getRankings()).isEqualTo(expSorted);
+  }
+
+  @Test(dataProvider = "simulatedRankingsData")
+  public void shouldCorrectlyRankWhenUpdatedWithEmptyOtherRankings(List<Rankable> unsorted, List<Rankable> expSorted) {
+    // given
+    Rankings rankings = new Rankings(unsorted.size());
+    for (Rankable r : unsorted) {
+      rankings.updateWith(r);
+    }
+    Rankings emptyRankings = new Rankings(ANY_TOPN);
+
+    // when
+    rankings.updateWith(emptyRankings);
+
+    // then
+    assertThat(rankings.getRankings()).isEqualTo(expSorted);
+  }
+
+  @DataProvider
+  public Object[][] simulatedRankingsAndOtherRankingsData() {
+    return new Object[][]{ { Lists.newArrayList(A), Lists.newArrayList(A), Lists.newArrayList(A) },
+        { Lists.newArrayList(A, C), Lists.newArrayList(B, D), Lists.newArrayList(D, C, B, A) }, { Lists.newArrayList(B,
+        F, A), Lists.newArrayList(C, D, E), Lists.newArrayList(F, E, D, C, B, A) }, { Lists.newArrayList(G, B, F, A, C),
+        Lists.newArrayList(D, E, H), Lists.newArrayList(H, G, F, E, D, C, B, A) } };
+  }
+
+  @Test(dataProvider = "simulatedRankingsAndOtherRankingsData")
+  public void shouldCorrectlyRankWhenNotEmptyAndUpdatedWithOtherRankings(List<Rankable> unsorted,
+      List<Rankable> unsortedForOtherRankings, List<Rankable> expSorted) {
+    // given
+    Rankings rankings = new Rankings(expSorted.size());
+    for (Rankable r : unsorted) {
+      rankings.updateWith(r);
+    }
+    Rankings otherRankings = new Rankings(unsortedForOtherRankings.size());
+    for (Rankable r : unsortedForOtherRankings) {
+      otherRankings.updateWith(r);
+    }
+
+    // when
+    rankings.updateWith(otherRankings);
+
+    // then
+    assertThat(rankings.getRankings()).isEqualTo(expSorted);
+  }
+
+  @DataProvider
+  public Object[][] duplicatesData() {
+    Rankable A1 = new RankableObjectWithFields("A", 1);
+    Rankable A2 = new RankableObjectWithFields("A", 2);
+    Rankable A3 = new RankableObjectWithFields("A", 3);
+    return new Object[][]{ { Lists.newArrayList(ANY_RANKABLE, ANY_RANKABLE, ANY_RANKABLE) }, { Lists.newArrayList(A1,
+        A2, A3) }, };
+  }
+
+  @Test(dataProvider = "duplicatesData")
+  public void shouldNotRankDuplicateObjectsMoreThanOnce(List<Rankable> duplicates) {
+    // given
+    Rankings rankings = new Rankings(duplicates.size());
+
+    // when
+    for (Rankable r : duplicates) {
+      rankings.updateWith(r);
+    }
+
+    // then
+    assertThat(rankings.size()).isEqualTo(1);
+  }
+
+  @Test
+  public void updatingWithNewRankablesShouldBeThreadSafe() throws InterruptedException {
+    // given
+    final List<Rankable> entries = ImmutableList.of(A, B, C, D);
+    final Rankings rankings = new Rankings(entries.size());
+
+    // We are capturing exceptions thrown in Blitzer's child threads into this data structure so that we can properly
+    // pass/fail this test.  The reason is that Blitzer doesn't report exceptions, which is a known bug in Blitzer
+    // (JMOCK-263).  See https://github.com/jmock-developers/jmock-library/issues/22 for more information.
+    final List<Exception> exceptions = Lists.newArrayList();
+    Blitzer blitzer = new Blitzer(1000);
+
+    // when
+    blitzer.blitz(new Runnable() {
+      public void run() {
+        for (Rankable r : entries) {
+          try {
             rankings.updateWith(r);
-        }
-
-        // then
-        assertThat(rankings.size()).isEqualTo(1);
-    }
-
-    @Test
-    public void updatingWithNewRankablesShouldBeThreadSafe() throws InterruptedException {
-        // given
-        final List<Rankable> entries = ImmutableList.of(A, B, C, D);
-        final Rankings rankings = new Rankings(entries.size());
-
-        // We are capturing exceptions thrown in Blitzer's child threads into this data structure so that we can properly
-        // pass/fail this test.  The reason is that Blitzer doesn't report exceptions, which is a known bug in Blitzer
-        // (JMOCK-263).  See https://github.com/jmock-developers/jmock-library/issues/22 for more information.
-        final List<Exception> exceptions = Lists.newArrayList();
-        Blitzer blitzer = new Blitzer(1000);
-
-        // when
-        blitzer.blitz(new Runnable() {
-            public void run() {
-                for (Rankable r : entries) {
-                    try {
-                        rankings.updateWith(r);
-                    }
-                    catch (RuntimeException e) {
-                        synchronized(exceptions) {
-                            exceptions.add(e);
-                        }
-                    }
-                }
-            }
-        });
-        blitzer.shutdown();
-
-        // then
-        //
-        if (!exceptions.isEmpty()) {
-            for (Exception e : exceptions) {
-                System.err.println(Throwables.getStackTraceAsString(e));
+          }
+          catch (RuntimeException e) {
+            synchronized(exceptions) {
+              exceptions.add(e);
             }
+          }
         }
-        assertThat(exceptions).isEmpty();
-    }
+      }
+    });
+    blitzer.shutdown();
+
+    // then
+    //
+    if (!exceptions.isEmpty()) {
+      for (Exception e : exceptions) {
+        System.err.println(Throwables.getStackTraceAsString(e));
+      }
+    }
+    assertThat(exceptions).isEmpty();
+  }
 }

http://git-wip-us.apache.org/repos/asf/incubator-storm/blob/a51c8247/test/jvm/storm/starter/tools/SlidingWindowCounterTest.java
----------------------------------------------------------------------
diff --git a/test/jvm/storm/starter/tools/SlidingWindowCounterTest.java b/test/jvm/storm/starter/tools/SlidingWindowCounterTest.java
index 7361ac8..1c883e5 100644
--- a/test/jvm/storm/starter/tools/SlidingWindowCounterTest.java
+++ b/test/jvm/storm/starter/tools/SlidingWindowCounterTest.java
@@ -1,93 +1,89 @@
 package storm.starter.tools;
 
-import static org.fest.assertions.api.Assertions.assertThat;
-
-import java.util.Map;
-
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-public class SlidingWindowCounterTest {
-
-    private static final int ANY_WINDOW_LENGTH_IN_SLOTS = 2;
-    private static final Object ANY_OBJECT = "ANY_OBJECT";
-
-    @DataProvider
-    public Object[][] illegalWindowLengths() {
-        return new Object[][] { { -10 }, { -3 }, { -2 }, { -1 }, { 0 }, { 1 } };
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalWindowLengths")
-    public void lessThanTwoSlotsShouldThrowIAE(int windowLengthInSlots) {
-        new SlidingWindowCounter<Object>(windowLengthInSlots);
-    }
-
-    @DataProvider
-    public Object[][] legalWindowLengths() {
-        return new Object[][] { { 2 }, { 3 }, { 20 } };
-    }
-
-    @Test(dataProvider = "legalWindowLengths")
-    public void twoOrMoreSlotsShouldBeValid(int windowLengthInSlots) {
-        new SlidingWindowCounter<Object>(windowLengthInSlots);
-    }
-
-    @Test
-    public void newInstanceShouldHaveEmptyCounts() {
-        // given
-        SlidingWindowCounter<Object> counter = new SlidingWindowCounter<Object>(ANY_WINDOW_LENGTH_IN_SLOTS);
-
-        // when
-        Map<Object, Long> counts = counter.getCountsThenAdvanceWindow();
+import java.util.Map;
 
-        // then
-        assertThat(counts).isEmpty();
-    }
+import static org.fest.assertions.api.Assertions.assertThat;
 
-    @DataProvider
-    public Object[][] simulatedCounterIterations() {
-        return new Object[][] {
-                { 2, new int[] { 3, 2, 0, 0, 1, 0, 0, 0 }, new long[] { 3, 5, 2, 0, 1, 1, 0, 0 } },
-                { 3, new int[] { 3, 2, 0, 0, 1, 0, 0, 0 }, new long[] { 3, 5, 5, 2, 1, 1, 1, 0 } },
-                { 4, new int[] { 3, 2, 0, 0, 1, 0, 0, 0 }, new long[] { 3, 5, 5, 5, 3, 1, 1, 1 } },
-                { 5, new int[] { 3, 2, 0, 0, 1, 0, 0, 0 }, new long[] { 3, 5, 5, 5, 6, 3, 1, 1 } },
-                {
-                        5,
-                        new int[] { 3, 11, 5, 13, 7, 17, 0, 3, 50, 600, 7000 },
-                        new long[] { 3, 14, 19, 32, 39, 53, 42, 40, 77, 670, 7653 } }, };
-    }
+public class SlidingWindowCounterTest {
 
-    @Test(dataProvider = "simulatedCounterIterations")
-    public void testCounterWithSimulatedRuns(int windowLengthInSlots, int[] incrementsPerIteration,
-        long[] expCountsPerIteration) {
-        // given
-        SlidingWindowCounter<Object> counter = new SlidingWindowCounter<Object>(windowLengthInSlots);
-        int numIterations = incrementsPerIteration.length;
-
-        for (int i = 0; i < numIterations; i++) {
-            int numIncrements = incrementsPerIteration[i];
-            long expCounts = expCountsPerIteration[i];
-            // Objects are absent if they were zero both this iteration
-            // and the last -- if only this one, we need to report zero.
-            boolean expAbsent = ((expCounts == 0) &&
-                ((i == 0) || (expCountsPerIteration[i-1] == 0)));
-
-            // given (for this iteration)
-            for (int j = 0; j < numIncrements; j++) {
-                counter.incrementCount(ANY_OBJECT);
-            }
-
-            // when (for this iteration)
-            Map<Object, Long> counts = counter.getCountsThenAdvanceWindow();
-
-            // then (for this iteration)
-            if (expAbsent) {
-                assertThat(counts).doesNotContainKey(ANY_OBJECT);
-            }
-            else {
-                assertThat(counts.get(ANY_OBJECT)).isEqualTo(expCounts);
-            }
-        }
+  private static final int ANY_WINDOW_LENGTH_IN_SLOTS = 2;
+  private static final Object ANY_OBJECT = "ANY_OBJECT";
+
+  @DataProvider
+  public Object[][] illegalWindowLengths() {
+    return new Object[][]{ { -10 }, { -3 }, { -2 }, { -1 }, { 0 }, { 1 } };
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalWindowLengths")
+  public void lessThanTwoSlotsShouldThrowIAE(int windowLengthInSlots) {
+    new SlidingWindowCounter<Object>(windowLengthInSlots);
+  }
+
+  @DataProvider
+  public Object[][] legalWindowLengths() {
+    return new Object[][]{ { 2 }, { 3 }, { 20 } };
+  }
+
+  @Test(dataProvider = "legalWindowLengths")
+  public void twoOrMoreSlotsShouldBeValid(int windowLengthInSlots) {
+    new SlidingWindowCounter<Object>(windowLengthInSlots);
+  }
+
+  @Test
+  public void newInstanceShouldHaveEmptyCounts() {
+    // given
+    SlidingWindowCounter<Object> counter = new SlidingWindowCounter<Object>(ANY_WINDOW_LENGTH_IN_SLOTS);
+
+    // when
+    Map<Object, Long> counts = counter.getCountsThenAdvanceWindow();
+
+    // then
+    assertThat(counts).isEmpty();
+  }
+
+  @DataProvider
+  public Object[][] simulatedCounterIterations() {
+    return new Object[][]{ { 2, new int[]{ 3, 2, 0, 0, 1, 0, 0, 0 }, new long[]{ 3, 5, 2, 0, 1, 1, 0, 0 } },
+        { 3, new int[]{ 3, 2, 0, 0, 1, 0, 0, 0 }, new long[]{ 3, 5, 5, 2, 1, 1, 1, 0 } },
+        { 4, new int[]{ 3, 2, 0, 0, 1, 0, 0, 0 }, new long[]{ 3, 5, 5, 5, 3, 1, 1, 1 } },
+        { 5, new int[]{ 3, 2, 0, 0, 1, 0, 0, 0 }, new long[]{ 3, 5, 5, 5, 6, 3, 1, 1 } },
+        { 5, new int[]{ 3, 11, 5, 13, 7, 17, 0, 3, 50, 600, 7000 },
+            new long[]{ 3, 14, 19, 32, 39, 53, 42, 40, 77, 670, 7653 } }, };
+  }
+
+  @Test(dataProvider = "simulatedCounterIterations")
+  public void testCounterWithSimulatedRuns(int windowLengthInSlots, int[] incrementsPerIteration,
+      long[] expCountsPerIteration) {
+    // given
+    SlidingWindowCounter<Object> counter = new SlidingWindowCounter<Object>(windowLengthInSlots);
+    int numIterations = incrementsPerIteration.length;
+
+    for (int i = 0; i < numIterations; i++) {
+      int numIncrements = incrementsPerIteration[i];
+      long expCounts = expCountsPerIteration[i];
+      // Objects are absent if they were zero both this iteration
+      // and the last -- if only this one, we need to report zero.
+      boolean expAbsent = ((expCounts == 0) && ((i == 0) || (expCountsPerIteration[i - 1] == 0)));
+
+      // given (for this iteration)
+      for (int j = 0; j < numIncrements; j++) {
+        counter.incrementCount(ANY_OBJECT);
+      }
+
+      // when (for this iteration)
+      Map<Object, Long> counts = counter.getCountsThenAdvanceWindow();
+
+      // then (for this iteration)
+      if (expAbsent) {
+        assertThat(counts).doesNotContainKey(ANY_OBJECT);
+      }
+      else {
+        assertThat(counts.get(ANY_OBJECT)).isEqualTo(expCounts);
+      }
     }
+  }
 
 }

http://git-wip-us.apache.org/repos/asf/incubator-storm/blob/a51c8247/test/jvm/storm/starter/tools/SlotBasedCounterTest.java
----------------------------------------------------------------------
diff --git a/test/jvm/storm/starter/tools/SlotBasedCounterTest.java b/test/jvm/storm/starter/tools/SlotBasedCounterTest.java
index be174d4..aeeec63 100644
--- a/test/jvm/storm/starter/tools/SlotBasedCounterTest.java
+++ b/test/jvm/storm/starter/tools/SlotBasedCounterTest.java
@@ -1,164 +1,164 @@
 package storm.starter.tools;
 
-import static org.fest.assertions.api.Assertions.assertThat;
-
-import java.util.Map;
-
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-public class SlotBasedCounterTest {
-
-    private static final int ANY_NUM_SLOTS = 1;
-    private static final int ANY_SLOT = 0;
-    private static final Object ANY_OBJECT = "ANY_OBJECT";
-
-    @DataProvider
-    public Object[][] illegalNumSlotsData() {
-        return new Object[][] { { -10 }, { -3 }, { -2 }, { -1 }, { 0 } };
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalNumSlotsData")
-    public void negativeOrZeroNumSlotsShouldThrowIAE(int numSlots) {
-        new SlotBasedCounter<Object>(numSlots);
-    }
-
-    @DataProvider
-    public Object[][] legalNumSlotsData() {
-        return new Object[][] { { 1 }, { 2 }, { 3 }, { 20 } };
-    }
-
-    @Test(dataProvider = "legalNumSlotsData")
-    public void positiveNumSlotsShouldBeOk(int numSlots) {
-        new SlotBasedCounter<Object>(numSlots);
-    }
-
-    @Test
-    public void newInstanceShouldHaveEmptyCounts() {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
-
-        // when
-        Map<Object, Long> counts = counter.getCounts();
-
-        // then
-        assertThat(counts).isEmpty();
-    }
-
-    @Test
-    public void shouldReturnNonEmptyCountsWhenAtLeastOneObjectWasCounted() {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
-        counter.incrementCount(ANY_OBJECT, ANY_SLOT);
-
-        // when
-        Map<Object, Long> counts = counter.getCounts();
-
-        // then
-        assertThat(counts).isNotEmpty();
-
-        // additional tests that go beyond what this test is primarily about
-        assertThat(counts.size()).isEqualTo(1);
-        assertThat(counts.get(ANY_OBJECT)).isEqualTo(1);
-    }
-
-    @DataProvider
-    public Object[][] incrementCountData() {
-        return new Object[][] { { new String[] { "foo", "bar" }, new int[] { 3, 2 } } };
-    }
-
-    @Test(dataProvider = "incrementCountData")
-    public void shouldIncrementCount(Object[] objects, int[] expCounts) {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
-
-        // when
-        for (int i = 0; i < objects.length; i++) {
-            Object obj = objects[i];
-            int numIncrements = expCounts[i];
-            for (int j = 0; j < numIncrements; j++) {
-                counter.incrementCount(obj, ANY_SLOT);
-            }
-        }
-
-        // then
-        for (int i = 0; i < objects.length; i++) {
-            assertThat(counter.getCount(objects[i], ANY_SLOT)).isEqualTo(expCounts[i]);
-        }
-        assertThat(counter.getCount("nonexistentObject", ANY_SLOT)).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldReturnZeroForNonexistentObject() {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
-
-        // when
-        counter.incrementCount("somethingElse", ANY_SLOT);
+import java.util.Map;
 
-        // then
-        assertThat(counter.getCount("nonexistentObject", ANY_SLOT)).isEqualTo(0);
-    }
+import static org.fest.assertions.api.Assertions.assertThat;
 
-    @Test
-    public void shouldIncrementCountOnlyOneSlotAtATime() {
-        // given
-        int numSlots = 3;
-        Object obj = Long.valueOf(10);
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(numSlots);
-
-        // when (empty)
-        // then
-        assertThat(counter.getCount(obj, 0)).isEqualTo(0);
-        assertThat(counter.getCount(obj, 1)).isEqualTo(0);
-        assertThat(counter.getCount(obj, 2)).isEqualTo(0);
-
-        // when
-        counter.incrementCount(obj, 1);
-
-        // then
-        assertThat(counter.getCount(obj, 0)).isEqualTo(0);
-        assertThat(counter.getCount(obj, 1)).isEqualTo(1);
-        assertThat(counter.getCount(obj, 2)).isEqualTo(0);
-    }
+public class SlotBasedCounterTest {
 
-    @Test
-    public void wipeSlotShouldSetAllCountsInSlotToZero() {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
-        Object countWasOne = "countWasOne";
-        Object countWasThree = "countWasThree";
-        counter.incrementCount(countWasOne, ANY_SLOT);
-        counter.incrementCount(countWasThree, ANY_SLOT);
-        counter.incrementCount(countWasThree, ANY_SLOT);
-        counter.incrementCount(countWasThree, ANY_SLOT);
-
-        // when
-        counter.wipeSlot(ANY_SLOT);
-
-        // then
-        assertThat(counter.getCount(countWasOne, ANY_SLOT)).isEqualTo(0);
-        assertThat(counter.getCount(countWasThree, ANY_SLOT)).isEqualTo(0);
+  private static final int ANY_NUM_SLOTS = 1;
+  private static final int ANY_SLOT = 0;
+  private static final Object ANY_OBJECT = "ANY_OBJECT";
+
+  @DataProvider
+  public Object[][] illegalNumSlotsData() {
+    return new Object[][]{ { -10 }, { -3 }, { -2 }, { -1 }, { 0 } };
+  }
+
+  @Test(expectedExceptions = IllegalArgumentException.class, dataProvider = "illegalNumSlotsData")
+  public void negativeOrZeroNumSlotsShouldThrowIAE(int numSlots) {
+    new SlotBasedCounter<Object>(numSlots);
+  }
+
+  @DataProvider
+  public Object[][] legalNumSlotsData() {
+    return new Object[][]{ { 1 }, { 2 }, { 3 }, { 20 } };
+  }
+
+  @Test(dataProvider = "legalNumSlotsData")
+  public void positiveNumSlotsShouldBeOk(int numSlots) {
+    new SlotBasedCounter<Object>(numSlots);
+  }
+
+  @Test
+  public void newInstanceShouldHaveEmptyCounts() {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
+
+    // when
+    Map<Object, Long> counts = counter.getCounts();
+
+    // then
+    assertThat(counts).isEmpty();
+  }
+
+  @Test
+  public void shouldReturnNonEmptyCountsWhenAtLeastOneObjectWasCounted() {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
+    counter.incrementCount(ANY_OBJECT, ANY_SLOT);
+
+    // when
+    Map<Object, Long> counts = counter.getCounts();
+
+    // then
+    assertThat(counts).isNotEmpty();
+
+    // additional tests that go beyond what this test is primarily about
+    assertThat(counts.size()).isEqualTo(1);
+    assertThat(counts.get(ANY_OBJECT)).isEqualTo(1);
+  }
+
+  @DataProvider
+  public Object[][] incrementCountData() {
+    return new Object[][]{ { new String[]{ "foo", "bar" }, new int[]{ 3, 2 } } };
+  }
+
+  @Test(dataProvider = "incrementCountData")
+  public void shouldIncrementCount(Object[] objects, int[] expCounts) {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
+
+    // when
+    for (int i = 0; i < objects.length; i++) {
+      Object obj = objects[i];
+      int numIncrements = expCounts[i];
+      for (int j = 0; j < numIncrements; j++) {
+        counter.incrementCount(obj, ANY_SLOT);
+      }
     }
 
-    @Test
-    public void wipeZerosShouldRemoveAnyObjectsWithZeroTotalCount() {
-        // given
-        SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(2);
-        int wipeSlot = 0;
-        int otherSlot = 1;
-        Object willBeRemoved = "willBeRemoved";
-        Object willContinueToBeTracked = "willContinueToBeTracked";
-        counter.incrementCount(willBeRemoved, wipeSlot);
-        counter.incrementCount(willContinueToBeTracked, wipeSlot);
-        counter.incrementCount(willContinueToBeTracked, otherSlot);
-
-        // when
-        counter.wipeSlot(wipeSlot);
-        counter.wipeZeros();
-
-        // then
-        assertThat(counter.getCounts()).doesNotContainKey(willBeRemoved);
-        assertThat(counter.getCounts()).containsKey(willContinueToBeTracked);
+    // then
+    for (int i = 0; i < objects.length; i++) {
+      assertThat(counter.getCount(objects[i], ANY_SLOT)).isEqualTo(expCounts[i]);
     }
+    assertThat(counter.getCount("nonexistentObject", ANY_SLOT)).isEqualTo(0);
+  }
+
+  @Test
+  public void shouldReturnZeroForNonexistentObject() {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
+
+    // when
+    counter.incrementCount("somethingElse", ANY_SLOT);
+
+    // then
+    assertThat(counter.getCount("nonexistentObject", ANY_SLOT)).isEqualTo(0);
+  }
+
+  @Test
+  public void shouldIncrementCountOnlyOneSlotAtATime() {
+    // given
+    int numSlots = 3;
+    Object obj = Long.valueOf(10);
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(numSlots);
+
+    // when (empty)
+    // then
+    assertThat(counter.getCount(obj, 0)).isEqualTo(0);
+    assertThat(counter.getCount(obj, 1)).isEqualTo(0);
+    assertThat(counter.getCount(obj, 2)).isEqualTo(0);
+
+    // when
+    counter.incrementCount(obj, 1);
+
+    // then
+    assertThat(counter.getCount(obj, 0)).isEqualTo(0);
+    assertThat(counter.getCount(obj, 1)).isEqualTo(1);
+    assertThat(counter.getCount(obj, 2)).isEqualTo(0);
+  }
+
+  @Test
+  public void wipeSlotShouldSetAllCountsInSlotToZero() {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(ANY_NUM_SLOTS);
+    Object countWasOne = "countWasOne";
+    Object countWasThree = "countWasThree";
+    counter.incrementCount(countWasOne, ANY_SLOT);
+    counter.incrementCount(countWasThree, ANY_SLOT);
+    counter.incrementCount(countWasThree, ANY_SLOT);
+    counter.incrementCount(countWasThree, ANY_SLOT);
+
+    // when
+    counter.wipeSlot(ANY_SLOT);
+
+    // then
+    assertThat(counter.getCount(countWasOne, ANY_SLOT)).isEqualTo(0);
+    assertThat(counter.getCount(countWasThree, ANY_SLOT)).isEqualTo(0);
+  }
+
+  @Test
+  public void wipeZerosShouldRemoveAnyObjectsWithZeroTotalCount() {
+    // given
+    SlotBasedCounter<Object> counter = new SlotBasedCounter<Object>(2);
+    int wipeSlot = 0;
+    int otherSlot = 1;
+    Object willBeRemoved = "willBeRemoved";
+    Object willContinueToBeTracked = "willContinueToBeTracked";
+    counter.incrementCount(willBeRemoved, wipeSlot);
+    counter.incrementCount(willContinueToBeTracked, wipeSlot);
+    counter.incrementCount(willContinueToBeTracked, otherSlot);
+
+    // when
+    counter.wipeSlot(wipeSlot);
+    counter.wipeZeros();
+
+    // then
+    assertThat(counter.getCounts()).doesNotContainKey(willBeRemoved);
+    assertThat(counter.getCounts()).containsKey(willContinueToBeTracked);
+  }
 }


Mime
View raw message