accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mmil...@apache.org
Subject [4/4] accumulo git commit: ACCUMULO-4525: replace meaningless method names
Date Tue, 29 Nov 2016 13:32:04 GMT
ACCUMULO-4525: replace meaningless method names


Project: http://git-wip-us.apache.org/repos/asf/accumulo/repo
Commit: http://git-wip-us.apache.org/repos/asf/accumulo/commit/a4a45398
Tree: http://git-wip-us.apache.org/repos/asf/accumulo/tree/a4a45398
Diff: http://git-wip-us.apache.org/repos/asf/accumulo/diff/a4a45398

Branch: refs/heads/1.7
Commit: a4a453986407132f2798b0e9c22fc26509f8d75e
Parents: 8a35b6d
Author: Mike Miller <mmiller@apache.org>
Authored: Tue Nov 22 10:59:44 2016 -0500
Committer: Mike Miller <mmiller@apache.org>
Committed: Tue Nov 22 14:16:49 2016 -0500

----------------------------------------------------------------------
 .../apache/accumulo/core/data/RangeTest.java    | 427 +++++++--------
 .../core/file/rfile/BlockIndexTest.java         |  22 +-
 .../core/file/rfile/CreateCompatTestFile.java   |  20 +-
 .../core/file/rfile/MultiThreadedRFileTest.java |   8 +-
 .../core/file/rfile/RFileMetricsTest.java       |  78 +--
 .../accumulo/core/file/rfile/RFileTest.java     | 514 ++++++++++---------
 .../core/file/rfile/RelativeKeyTest.java        |  14 +-
 .../core/iterators/AggregatingIteratorTest.java | 152 +++---
 .../core/iterators/FirstEntryInRowTest.java     |  46 +-
 .../core/iterators/IteratorUtilTest.java        |  38 +-
 .../ColumnFamilySkippingIteratorTest.java       |  44 +-
 .../core/iterators/system/ColumnFilterTest.java |  30 +-
 .../iterators/system/DeletingIteratorTest.java  |  62 +--
 .../iterators/system/MultiIteratorTest.java     | 124 ++---
 .../system/SourceSwitchingIteratorTest.java     |  45 +-
 .../iterators/user/BigDecimalCombinerTest.java  |  20 +-
 .../iterators/user/ColumnSliceFilterTest.java   |  18 +-
 .../core/iterators/user/CombinerTest.java       | 220 ++++----
 .../iterators/user/IndexedDocIteratorTest.java  |   4 +-
 .../core/iterators/user/RegExFilterTest.java    |  12 +-
 .../iterators/user/RowDeletingIteratorTest.java |  80 +--
 .../tserver/CheckTabletMetadataTest.java        |  14 +-
 .../accumulo/tserver/InMemoryMapTest.java       | 178 +++----
 .../accumulo/test/NativeMapPerformanceTest.java |  12 +-
 .../accumulo/test/functional/NativeMapIT.java   |  79 +--
 25 files changed, 1136 insertions(+), 1125 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/a4a45398/core/src/test/java/org/apache/accumulo/core/data/RangeTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/data/RangeTest.java b/core/src/test/java/org/apache/accumulo/core/data/RangeTest.java
index 129f2ba..115aa7a 100644
--- a/core/src/test/java/org/apache/accumulo/core/data/RangeTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/data/RangeTest.java
@@ -32,7 +32,7 @@ import org.apache.accumulo.core.data.thrift.TRange;
 import org.apache.hadoop.io.Text;
 
 public class RangeTest extends TestCase {
-  private Range nr(String k1, String k2) {
+  private Range newRange(String k1, String k2) {
     Key ik1 = null;
     if (k1 != null)
       ik1 = new Key(new Text(k1), 0l);
@@ -44,7 +44,7 @@ public class RangeTest extends TestCase {
     return new Range(ik1, ik2);
   }
 
-  private List<Range> nrl(Range... ranges) {
+  private List<Range> newRangeList(Range... ranges) {
     return Arrays.asList(ranges);
   }
 
@@ -56,135 +56,135 @@ public class RangeTest extends TestCase {
   }
 
   public void testMergeOverlapping1() {
-    List<Range> rl = nrl(nr("a", "c"), nr("a", "b"));
-    List<Range> expected = nrl(nr("a", "c"));
+    List<Range> rl = newRangeList(newRange("a", "c"), newRange("a", "b"));
+    List<Range> expected = newRangeList(newRange("a", "c"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping2() {
-    List<Range> rl = nrl(nr("a", "c"), nr("d", "f"));
-    List<Range> expected = nrl(nr("a", "c"), nr("d", "f"));
+    List<Range> rl = newRangeList(newRange("a", "c"), newRange("d", "f"));
+    List<Range> expected = newRangeList(newRange("a", "c"), newRange("d", "f"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping3() {
-    List<Range> rl = nrl(nr("a", "e"), nr("b", "f"), nr("c", "r"), nr("g", "j"), nr("t", "x"));
-    List<Range> expected = nrl(nr("a", "r"), nr("t", "x"));
+    List<Range> rl = newRangeList(newRange("a", "e"), newRange("b", "f"), newRange("c", "r"), newRange("g", "j"), newRange("t", "x"));
+    List<Range> expected = newRangeList(newRange("a", "r"), newRange("t", "x"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping4() {
-    List<Range> rl = nrl(nr("a", "e"), nr("b", "f"), nr("c", "r"), nr("g", "j"));
-    List<Range> expected = nrl(nr("a", "r"));
+    List<Range> rl = newRangeList(newRange("a", "e"), newRange("b", "f"), newRange("c", "r"), newRange("g", "j"));
+    List<Range> expected = newRangeList(newRange("a", "r"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping5() {
-    List<Range> rl = nrl(nr("a", "e"));
-    List<Range> expected = nrl(nr("a", "e"));
+    List<Range> rl = newRangeList(newRange("a", "e"));
+    List<Range> expected = newRangeList(newRange("a", "e"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping6() {
-    List<Range> rl = nrl();
-    List<Range> expected = nrl();
+    List<Range> rl = newRangeList();
+    List<Range> expected = newRangeList();
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping7() {
-    List<Range> rl = nrl(nr("a", "e"), nr("g", "q"), nr("r", "z"));
-    List<Range> expected = nrl(nr("a", "e"), nr("g", "q"), nr("r", "z"));
+    List<Range> rl = newRangeList(newRange("a", "e"), newRange("g", "q"), newRange("r", "z"));
+    List<Range> expected = newRangeList(newRange("a", "e"), newRange("g", "q"), newRange("r", "z"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping8() {
-    List<Range> rl = nrl(nr("a", "c"), nr("a", "c"));
-    List<Range> expected = nrl(nr("a", "c"));
+    List<Range> rl = newRangeList(newRange("a", "c"), newRange("a", "c"));
+    List<Range> expected = newRangeList(newRange("a", "c"));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping9() {
-    List<Range> rl = nrl(nr(null, null));
-    List<Range> expected = nrl(nr(null, null));
+    List<Range> rl = newRangeList(newRange(null, null));
+    List<Range> expected = newRangeList(newRange(null, null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping10() {
-    List<Range> rl = nrl(nr(null, null), nr("a", "c"));
-    List<Range> expected = nrl(nr(null, null));
+    List<Range> rl = newRangeList(newRange(null, null), newRange("a", "c"));
+    List<Range> expected = newRangeList(newRange(null, null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping11() {
-    List<Range> rl = nrl(nr("a", "c"), nr(null, null));
-    List<Range> expected = nrl(nr(null, null));
+    List<Range> rl = newRangeList(newRange("a", "c"), newRange(null, null));
+    List<Range> expected = newRangeList(newRange(null, null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping12() {
-    List<Range> rl = nrl(nr("b", "d"), nr("c", null));
-    List<Range> expected = nrl(nr("b", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("c", null));
+    List<Range> expected = newRangeList(newRange("b", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping13() {
-    List<Range> rl = nrl(nr("b", "d"), nr("a", null));
-    List<Range> expected = nrl(nr("a", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("a", null));
+    List<Range> expected = newRangeList(newRange("a", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping14() {
-    List<Range> rl = nrl(nr("b", "d"), nr("e", null));
-    List<Range> expected = nrl(nr("b", "d"), nr("e", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("e", null));
+    List<Range> expected = newRangeList(newRange("b", "d"), newRange("e", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping15() {
-    List<Range> rl = nrl(nr("b", "d"), nr("e", null), nr("c", "f"));
-    List<Range> expected = nrl(nr("b", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("e", null), newRange("c", "f"));
+    List<Range> expected = newRangeList(newRange("b", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping16() {
-    List<Range> rl = nrl(nr("b", "d"), nr("f", null), nr("c", "e"));
-    List<Range> expected = nrl(nr("b", "e"), nr("f", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("f", null), newRange("c", "e"));
+    List<Range> expected = newRangeList(newRange("b", "e"), newRange("f", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping17() {
-    List<Range> rl = nrl(nr("b", "d"), nr("r", null), nr("c", "e"), nr("g", "t"));
-    List<Range> expected = nrl(nr("b", "e"), nr("g", null));
+    List<Range> rl = newRangeList(newRange("b", "d"), newRange("r", null), newRange("c", "e"), newRange("g", "t"));
+    List<Range> expected = newRangeList(newRange("b", "e"), newRange("g", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping18() {
-    List<Range> rl = nrl(nr(null, "d"), nr("r", null), nr("c", "e"), nr("g", "t"));
-    List<Range> expected = nrl(nr(null, "e"), nr("g", null));
+    List<Range> rl = newRangeList(newRange(null, "d"), newRange("r", null), newRange("c", "e"), newRange("g", "t"));
+    List<Range> expected = newRangeList(newRange(null, "e"), newRange("g", null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping19() {
-    List<Range> rl = nrl(nr(null, "d"), nr("r", null), nr("c", "e"), nr("g", "t"), nr("d", "h"));
-    List<Range> expected = nrl(nr(null, null));
+    List<Range> rl = newRangeList(newRange(null, "d"), newRange("r", null), newRange("c", "e"), newRange("g", "t"), newRange("d", "h"));
+    List<Range> expected = newRangeList(newRange(null, null));
     check(Range.mergeOverlapping(rl), expected);
   }
 
   public void testMergeOverlapping20() {
 
-    List<Range> rl = nrl(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), false, new Text("c"), false));
-    List<Range> expected = nrl(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), false, new Text("c"), false));
+    List<Range> rl = newRangeList(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), false, new Text("c"), false));
+    List<Range> expected = newRangeList(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), false, new Text("c"), false));
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), true, new Text("c"), false));
-    expected = nrl(new Range(new Text("a"), true, new Text("c"), false));
+    rl = newRangeList(new Range(new Text("a"), true, new Text("b"), false), new Range(new Text("b"), true, new Text("c"), false));
+    expected = newRangeList(new Range(new Text("a"), true, new Text("c"), false));
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(new Range(new Text("a"), true, new Text("b"), true), new Range(new Text("b"), false, new Text("c"), false));
-    expected = nrl(new Range(new Text("a"), true, new Text("c"), false));
+    rl = newRangeList(new Range(new Text("a"), true, new Text("b"), true), new Range(new Text("b"), false, new Text("c"), false));
+    expected = newRangeList(new Range(new Text("a"), true, new Text("c"), false));
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(new Range(new Text("a"), true, new Text("b"), true), new Range(new Text("b"), true, new Text("c"), false));
-    expected = nrl(new Range(new Text("a"), true, new Text("c"), false));
+    rl = newRangeList(new Range(new Text("a"), true, new Text("b"), true), new Range(new Text("b"), true, new Text("c"), false));
+    expected = newRangeList(new Range(new Text("a"), true, new Text("c"), false));
     check(Range.mergeOverlapping(rl), expected);
 
   }
@@ -197,25 +197,25 @@ public class RangeTest extends TestCase {
     Range ke4 = new KeyExtent(new Text("tab1"), new Text("bails"), new Text("Sam")).toMetadataRange();
     Range ke5 = new KeyExtent(new Text("tab1"), null, new Text("bails")).toMetadataRange();
 
-    List<Range> rl = nrl(ke1, ke2, ke3, ke4, ke5);
-    List<Range> expected = nrl(new KeyExtent(new Text("tab1"), null, null).toMetadataRange());
+    List<Range> rl = newRangeList(ke1, ke2, ke3, ke4, ke5);
+    List<Range> expected = newRangeList(new KeyExtent(new Text("tab1"), null, null).toMetadataRange());
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(ke1, ke2, ke4, ke5);
-    expected = nrl(new KeyExtent(new Text("tab1"), new Text("Fails"), null).toMetadataRange(),
+    rl = newRangeList(ke1, ke2, ke4, ke5);
+    expected = newRangeList(new KeyExtent(new Text("tab1"), new Text("Fails"), null).toMetadataRange(),
         new KeyExtent(new Text("tab1"), null, new Text("Sam")).toMetadataRange());
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(ke2, ke3, ke4, ke5);
-    expected = nrl(new KeyExtent(new Text("tab1"), null, new Text("Bank")).toMetadataRange());
+    rl = newRangeList(ke2, ke3, ke4, ke5);
+    expected = newRangeList(new KeyExtent(new Text("tab1"), null, new Text("Bank")).toMetadataRange());
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(ke1, ke2, ke3, ke4);
-    expected = nrl(new KeyExtent(new Text("tab1"), new Text("bails"), null).toMetadataRange());
+    rl = newRangeList(ke1, ke2, ke3, ke4);
+    expected = newRangeList(new KeyExtent(new Text("tab1"), new Text("bails"), null).toMetadataRange());
     check(Range.mergeOverlapping(rl), expected);
 
-    rl = nrl(ke2, ke3, ke4);
-    expected = nrl(new KeyExtent(new Text("tab1"), new Text("bails"), new Text("Bank")).toMetadataRange());
+    rl = newRangeList(ke2, ke3, ke4);
+    expected = newRangeList(new KeyExtent(new Text("tab1"), new Text("bails"), new Text("Bank")).toMetadataRange());
     check(Range.mergeOverlapping(rl), expected);
   }
 
@@ -227,21 +227,24 @@ public class RangeTest extends TestCase {
 
             // System.out.println("b1:"+b1+" b2:"+b2+" b3:"+b3+" b4:"+b4);
 
-            List<Range> rl = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("m")), b2), new Range(new Key(new Text("b")), b3,
-                new Key(new Text("n")), b4));
-            List<Range> expected = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b4));
+            List<Range> rl = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("m")), b2), new Range(new Key(new Text("b")), b3, new Key(
+                new Text("n")), b4));
+            List<Range> expected = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b4));
             check(Range.mergeOverlapping(rl), expected);
 
-            rl = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("m")), b2), new Range(new Key(new Text("a")), b3, new Key(new Text("n")), b4));
-            expected = nrl(new Range(new Key(new Text("a")), b1 || b3, new Key(new Text("n")), b4));
+            rl = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("m")), b2), new Range(new Key(new Text("a")), b3, new Key(new Text("n")),
+                b4));
+            expected = newRangeList(new Range(new Key(new Text("a")), b1 || b3, new Key(new Text("n")), b4));
             check(Range.mergeOverlapping(rl), expected);
 
-            rl = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2), new Range(new Key(new Text("b")), b3, new Key(new Text("n")), b4));
-            expected = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2 || b4));
+            rl = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2), new Range(new Key(new Text("b")), b3, new Key(new Text("n")),
+                b4));
+            expected = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2 || b4));
             check(Range.mergeOverlapping(rl), expected);
 
-            rl = nrl(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2), new Range(new Key(new Text("a")), b3, new Key(new Text("n")), b4));
-            expected = nrl(new Range(new Key(new Text("a")), b1 || b3, new Key(new Text("n")), b2 || b4));
+            rl = newRangeList(new Range(new Key(new Text("a")), b1, new Key(new Text("n")), b2), new Range(new Key(new Text("a")), b3, new Key(new Text("n")),
+                b4));
+            expected = newRangeList(new Range(new Key(new Text("a")), b1 || b3, new Key(new Text("n")), b2 || b4));
             check(Range.mergeOverlapping(rl), expected);
           }
 
@@ -249,33 +252,33 @@ public class RangeTest extends TestCase {
 
   public void testEqualsNull() {
 
-    assertTrue(nr(null, "d").equals(nr(null, "d")));
+    assertTrue(newRange(null, "d").equals(newRange(null, "d")));
 
-    assertTrue(nr(null, null).equals(nr(null, null)));
+    assertTrue(newRange(null, null).equals(newRange(null, null)));
 
-    assertTrue(nr("a", null).equals(nr("a", null)));
+    assertTrue(newRange("a", null).equals(newRange("a", null)));
 
-    assertFalse(nr(null, "d").equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr(null, "d")));
+    assertFalse(newRange(null, "d").equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange(null, "d")));
 
-    assertFalse(nr(null, null).equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr(null, null)));
+    assertFalse(newRange(null, null).equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange(null, null)));
 
-    assertFalse(nr("a", null).equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr("a", null)));
+    assertFalse(newRange("a", null).equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange("a", null)));
   }
 
   public void testEquals() {
-    assertFalse(nr("b", "d").equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr("b", "d")));
+    assertFalse(newRange("b", "d").equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange("b", "d")));
 
-    assertFalse(nr("x", "y").equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr("x", "y")));
+    assertFalse(newRange("x", "y").equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange("x", "y")));
 
-    assertFalse(nr("a", "z").equals(nr("a", "d")));
-    assertFalse(nr("a", "d").equals(nr("a", "z")));
+    assertFalse(newRange("a", "z").equals(newRange("a", "d")));
+    assertFalse(newRange("a", "d").equals(newRange("a", "z")));
 
-    assertTrue(nr("a", "z").equals(nr("a", "z")));
+    assertTrue(newRange("a", "z").equals(newRange("a", "z")));
   }
 
   public void testRow1() {
@@ -416,7 +419,7 @@ public class RangeTest extends TestCase {
     assertTrue(rowRange.contains(new Key(new Text("r2")).followingKey(PartialKey.ROW)));
   }
 
-  private static Range nr(String r1, boolean r1i, String r2, boolean r2i) {
+  private static Range newRange(String r1, boolean r1i, String r2, boolean r2i) {
     Text tr1 = null;
     Text tr2 = null;
 
@@ -430,98 +433,98 @@ public class RangeTest extends TestCase {
 
   }
 
-  private static Key nk(String r) {
+  private static Key newKey(String r) {
     return new Key(new Text(r));
   }
 
   public void testClip1() {
-    Range fence = nr("a", false, "c", false);
+    Range fence = newRange("a", false, "c", false);
 
-    runClipTest(fence, nr("a", false, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", false, "c", true), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", true), nr("a", false, "c", false));
+    runClipTest(fence, newRange("a", false, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", false, "c", true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", true), newRange("a", false, "c", false));
 
-    fence = nr("a", true, "c", false);
+    fence = newRange("a", true, "c", false);
 
-    runClipTest(fence, nr("a", false, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", false), nr("a", true, "c", false));
-    runClipTest(fence, nr("a", false, "c", true), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", true), nr("a", true, "c", false));
+    runClipTest(fence, newRange("a", false, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", false), newRange("a", true, "c", false));
+    runClipTest(fence, newRange("a", false, "c", true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", true), newRange("a", true, "c", false));
 
-    fence = nr("a", false, "c", true);
+    fence = newRange("a", false, "c", true);
 
-    runClipTest(fence, nr("a", false, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", false, "c", true), nr("a", false, "c", true));
-    runClipTest(fence, nr("a", true, "c", true), nr("a", false, "c", true));
+    runClipTest(fence, newRange("a", false, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", false, "c", true), newRange("a", false, "c", true));
+    runClipTest(fence, newRange("a", true, "c", true), newRange("a", false, "c", true));
 
-    fence = nr("a", true, "c", true);
+    fence = newRange("a", true, "c", true);
 
-    runClipTest(fence, nr("a", false, "c", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", false), nr("a", true, "c", false));
-    runClipTest(fence, nr("a", false, "c", true), nr("a", false, "c", true));
-    runClipTest(fence, nr("a", true, "c", true), nr("a", true, "c", true));
+    runClipTest(fence, newRange("a", false, "c", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", false), newRange("a", true, "c", false));
+    runClipTest(fence, newRange("a", false, "c", true), newRange("a", false, "c", true));
+    runClipTest(fence, newRange("a", true, "c", true), newRange("a", true, "c", true));
   }
 
   public void testClip2() {
-    Range fence = nr("a", false, "c", false);
+    Range fence = newRange("a", false, "c", false);
 
-    runClipTest(fence, nr(null, true, null, true), nr("a", false, "c", false));
-    runClipTest(fence, nr(null, true, "c", true), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, null, true), nr("a", false, "c", false));
-    runClipTest(fence, nr("a", true, "c", true), nr("a", false, "c", false));
+    runClipTest(fence, newRange(null, true, null, true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange(null, true, "c", true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, null, true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("a", true, "c", true), newRange("a", false, "c", false));
   }
 
   public void testClip3() {
-    Range fence = nr("a", false, "c", false);
+    Range fence = newRange("a", false, "c", false);
 
-    runClipTest(fence, nr("0", false, "z", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("0", true, "z", false), nr("a", false, "c", false));
-    runClipTest(fence, nr("0", false, "z", true), nr("a", false, "c", false));
-    runClipTest(fence, nr("0", true, "z", true), nr("a", false, "c", false));
+    runClipTest(fence, newRange("0", false, "z", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("0", true, "z", false), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("0", false, "z", true), newRange("a", false, "c", false));
+    runClipTest(fence, newRange("0", true, "z", true), newRange("a", false, "c", false));
 
-    runClipTest(fence, nr("0", false, "b", false), nr("a", false, "b", false));
-    runClipTest(fence, nr("0", true, "b", false), nr("a", false, "b", false));
-    runClipTest(fence, nr("0", false, "b", true), nr("a", false, "b", true));
-    runClipTest(fence, nr("0", true, "b", true), nr("a", false, "b", true));
+    runClipTest(fence, newRange("0", false, "b", false), newRange("a", false, "b", false));
+    runClipTest(fence, newRange("0", true, "b", false), newRange("a", false, "b", false));
+    runClipTest(fence, newRange("0", false, "b", true), newRange("a", false, "b", true));
+    runClipTest(fence, newRange("0", true, "b", true), newRange("a", false, "b", true));
 
-    runClipTest(fence, nr("a1", false, "z", false), nr("a1", false, "c", false));
-    runClipTest(fence, nr("a1", true, "z", false), nr("a1", true, "c", false));
-    runClipTest(fence, nr("a1", false, "z", true), nr("a1", false, "c", false));
-    runClipTest(fence, nr("a1", true, "z", true), nr("a1", true, "c", false));
+    runClipTest(fence, newRange("a1", false, "z", false), newRange("a1", false, "c", false));
+    runClipTest(fence, newRange("a1", true, "z", false), newRange("a1", true, "c", false));
+    runClipTest(fence, newRange("a1", false, "z", true), newRange("a1", false, "c", false));
+    runClipTest(fence, newRange("a1", true, "z", true), newRange("a1", true, "c", false));
 
-    runClipTest(fence, nr("a1", false, "b", false), nr("a1", false, "b", false));
-    runClipTest(fence, nr("a1", true, "b", false), nr("a1", true, "b", false));
-    runClipTest(fence, nr("a1", false, "b", true), nr("a1", false, "b", true));
-    runClipTest(fence, nr("a1", true, "b", true), nr("a1", true, "b", true));
+    runClipTest(fence, newRange("a1", false, "b", false), newRange("a1", false, "b", false));
+    runClipTest(fence, newRange("a1", true, "b", false), newRange("a1", true, "b", false));
+    runClipTest(fence, newRange("a1", false, "b", true), newRange("a1", false, "b", true));
+    runClipTest(fence, newRange("a1", true, "b", true), newRange("a1", true, "b", true));
   }
 
   public void testClip4() {
-    Range fence = new Range(nk("c"), false, nk("n"), false);
+    Range fence = new Range(newKey("c"), false, newKey("n"), false);
 
-    runClipTest(fence, new Range(nk("a"), false, nk("c"), false));
-    runClipTest(fence, new Range(nk("a"), false, nk("c"), true));
-    runClipTest(fence, new Range(nk("n"), false, nk("r"), false));
-    runClipTest(fence, new Range(nk("n"), true, nk("r"), false));
-    runClipTest(fence, new Range(nk("a"), true, nk("b"), false));
-    runClipTest(fence, new Range(nk("a"), true, nk("b"), true));
+    runClipTest(fence, new Range(newKey("a"), false, newKey("c"), false));
+    runClipTest(fence, new Range(newKey("a"), false, newKey("c"), true));
+    runClipTest(fence, new Range(newKey("n"), false, newKey("r"), false));
+    runClipTest(fence, new Range(newKey("n"), true, newKey("r"), false));
+    runClipTest(fence, new Range(newKey("a"), true, newKey("b"), false));
+    runClipTest(fence, new Range(newKey("a"), true, newKey("b"), true));
 
-    fence = new Range(nk("c"), true, nk("n"), true);
+    fence = new Range(newKey("c"), true, newKey("n"), true);
 
-    runClipTest(fence, new Range(nk("a"), false, nk("c"), false));
-    runClipTest(fence, new Range(nk("a"), false, nk("c"), true), new Range(nk("c"), true, nk("c"), true));
-    runClipTest(fence, new Range(nk("n"), false, nk("r"), false));
-    runClipTest(fence, new Range(nk("n"), true, nk("r"), false), new Range(nk("n"), true, nk("n"), true));
-    runClipTest(fence, new Range(nk("q"), false, nk("r"), false));
-    runClipTest(fence, new Range(nk("q"), true, nk("r"), false));
+    runClipTest(fence, new Range(newKey("a"), false, newKey("c"), false));
+    runClipTest(fence, new Range(newKey("a"), false, newKey("c"), true), new Range(newKey("c"), true, newKey("c"), true));
+    runClipTest(fence, new Range(newKey("n"), false, newKey("r"), false));
+    runClipTest(fence, new Range(newKey("n"), true, newKey("r"), false), new Range(newKey("n"), true, newKey("n"), true));
+    runClipTest(fence, new Range(newKey("q"), false, newKey("r"), false));
+    runClipTest(fence, new Range(newKey("q"), true, newKey("r"), false));
 
-    fence = nr("b", true, "b", true);
+    fence = newRange("b", true, "b", true);
 
-    runClipTest(fence, nr("b", false, "c", false));
-    runClipTest(fence, nr("b", true, "c", false), nr("b", true, "b", true));
-    runClipTest(fence, nr("a", false, "b", false));
-    runClipTest(fence, nr("a", false, "b", true), nr("b", true, "b", true));
+    runClipTest(fence, newRange("b", false, "c", false));
+    runClipTest(fence, newRange("b", true, "c", false), newRange("b", true, "b", true));
+    runClipTest(fence, newRange("a", false, "b", false));
+    runClipTest(fence, newRange("a", false, "b", true), newRange("b", true, "b", true));
 
   }
 
@@ -559,95 +562,95 @@ public class RangeTest extends TestCase {
     assertEquals(expected, clipped);
   }
 
-  private static Key nk(String r, String cf, String cq) {
+  private static Key newKey(String r, String cf, String cq) {
     return new Key(new Text(r), new Text(cf), new Text(cq));
   }
 
-  private static Key nk(String r, String cf, String cq, String cv) {
+  private static Key newKey(String r, String cf, String cq, String cv) {
     return new Key(new Text(r), new Text(cf), new Text(cq), new Text(cv));
   }
 
-  private static Column nc(String cf, String cq) {
+  private static Column newColumn(String cf, String cq) {
     return new Column(cf.getBytes(), cq == null ? null : cq.getBytes(), null);
   }
 
-  private static Column nc(String cf) {
-    return nc(cf, null);
+  private static Column newColumn(String cf) {
+    return newColumn(cf, null);
   }
 
-  private static Range nr(String row) {
+  private static Range newRange(String row) {
     return new Range(new Text(row));
   }
 
   public void testBound1() {
-    Range range1 = nr("row1");
+    Range range1 = newRange("row1");
 
-    Range range2 = range1.bound(nc("b"), nc("e"));
+    Range range2 = range1.bound(newColumn("b"), newColumn("e"));
 
-    assertFalse(range2.contains(nk("row1")));
-    assertFalse(range2.contains(nk("row1", "a", "z")));
-    assertTrue(range2.contains(nk("row1", "b", "")));
-    assertTrue(range2.contains(nk("row1", "b", "z")));
-    assertTrue(range2.contains(nk("row1", "c", "z")));
-    assertTrue(range2.contains(nk("row1", "e", "")));
-    assertTrue(range2.contains(nk("row1", "e", "z")));
-    assertFalse(range2.contains(nk("row1", "e", "").followingKey(PartialKey.ROW_COLFAM)));
-    assertFalse(range2.contains(nk("row1", "f", "")));
-    assertFalse(range2.contains(nk("row1", "f", "z")));
+    assertFalse(range2.contains(newKey("row1")));
+    assertFalse(range2.contains(newKey("row1", "a", "z")));
+    assertTrue(range2.contains(newKey("row1", "b", "")));
+    assertTrue(range2.contains(newKey("row1", "b", "z")));
+    assertTrue(range2.contains(newKey("row1", "c", "z")));
+    assertTrue(range2.contains(newKey("row1", "e", "")));
+    assertTrue(range2.contains(newKey("row1", "e", "z")));
+    assertFalse(range2.contains(newKey("row1", "e", "").followingKey(PartialKey.ROW_COLFAM)));
+    assertFalse(range2.contains(newKey("row1", "f", "")));
+    assertFalse(range2.contains(newKey("row1", "f", "z")));
 
   }
 
   public void testBound2() {
-    Range range1 = new Range(nk("row1", "b", "x"), true, nk("row1", "f", "x"), true);
+    Range range1 = new Range(newKey("row1", "b", "x"), true, newKey("row1", "f", "x"), true);
 
-    Range range2 = range1.bound(nc("a"), nc("g"));
+    Range range2 = range1.bound(newColumn("a"), newColumn("g"));
     assertEquals(range1, range2);
-    assertFalse(range2.contains(nk("row1", "a", "x")));
-    assertTrue(range2.contains(nk("row1", "b", "x")));
-    assertTrue(range2.contains(nk("row1", "f", "x")));
-    assertFalse(range2.contains(nk("row1", "g", "")));
-
-    Range range3 = range1.bound(nc("c"), nc("d"));
-    assertFalse(range3.contains(nk("row1", "b", "x")));
-    assertTrue(range3.contains(nk("row1", "c", "")));
-    assertTrue(range3.contains(nk("row1", "c", "z")));
-    assertTrue(range3.contains(nk("row1", "d", "")));
-    assertTrue(range3.contains(nk("row1", "d", "z")));
-    assertFalse(range3.contains(nk("row1", "e", "")));
-    assertFalse(range3.contains(nk("row1", "f", "x")));
-
-    Range range4 = range1.bound(nc("c", "w"), nc("d", "z"));
-    assertFalse(range4.contains(nk("row1", "b", "x")));
-    assertTrue(range4.contains(nk("row1", "c", "w")));
-    assertTrue(range4.contains(nk("row1", "c", "w", "")));
-    assertTrue(range4.contains(nk("row1", "c", "w", "a")));
-    assertTrue(range4.contains(nk("row1", "d", "z", "")));
-    assertTrue(range4.contains(nk("row1", "d", "z", "a")));
-    assertFalse(range4.contains(nk("row1", "d", "{", "")));
-    assertFalse(range4.contains(nk("row1", "d", "z", "a").followingKey(PartialKey.ROW_COLFAM_COLQUAL)));
-    assertFalse(range4.contains(nk("row1", "f", "x")));
-
-    Range range5 = range1.bound(nc("b", "w"), nc("f", "z"));
+    assertFalse(range2.contains(newKey("row1", "a", "x")));
+    assertTrue(range2.contains(newKey("row1", "b", "x")));
+    assertTrue(range2.contains(newKey("row1", "f", "x")));
+    assertFalse(range2.contains(newKey("row1", "g", "")));
+
+    Range range3 = range1.bound(newColumn("c"), newColumn("d"));
+    assertFalse(range3.contains(newKey("row1", "b", "x")));
+    assertTrue(range3.contains(newKey("row1", "c", "")));
+    assertTrue(range3.contains(newKey("row1", "c", "z")));
+    assertTrue(range3.contains(newKey("row1", "d", "")));
+    assertTrue(range3.contains(newKey("row1", "d", "z")));
+    assertFalse(range3.contains(newKey("row1", "e", "")));
+    assertFalse(range3.contains(newKey("row1", "f", "x")));
+
+    Range range4 = range1.bound(newColumn("c", "w"), newColumn("d", "z"));
+    assertFalse(range4.contains(newKey("row1", "b", "x")));
+    assertTrue(range4.contains(newKey("row1", "c", "w")));
+    assertTrue(range4.contains(newKey("row1", "c", "w", "")));
+    assertTrue(range4.contains(newKey("row1", "c", "w", "a")));
+    assertTrue(range4.contains(newKey("row1", "d", "z", "")));
+    assertTrue(range4.contains(newKey("row1", "d", "z", "a")));
+    assertFalse(range4.contains(newKey("row1", "d", "{", "")));
+    assertFalse(range4.contains(newKey("row1", "d", "z", "a").followingKey(PartialKey.ROW_COLFAM_COLQUAL)));
+    assertFalse(range4.contains(newKey("row1", "f", "x")));
+
+    Range range5 = range1.bound(newColumn("b", "w"), newColumn("f", "z"));
     assertEquals(range1, range5);
-    assertFalse(range5.contains(nk("row1", "b", "w")));
-    assertTrue(range5.contains(nk("row1", "b", "x")));
-    assertTrue(range5.contains(nk("row1", "f", "x")));
-    assertFalse(range5.contains(nk("row1", "f", "z")));
-
-    Range range6 = range1.bound(nc("b", "y"), nc("f", "w"));
-    assertFalse(range6.contains(nk("row1", "b", "x")));
-    assertTrue(range6.contains(nk("row1", "b", "y")));
-    assertTrue(range6.contains(nk("row1", "f", "w")));
-    assertTrue(range6.contains(nk("row1", "f", "w", "a")));
-    assertFalse(range6.contains(nk("row1", "f", "w").followingKey(PartialKey.ROW_COLFAM_COLQUAL)));
-    assertFalse(range6.contains(nk("row1", "f", "x")));
-
-    Range range7 = range1.bound(nc("a", "y"), nc("g", "w"));
+    assertFalse(range5.contains(newKey("row1", "b", "w")));
+    assertTrue(range5.contains(newKey("row1", "b", "x")));
+    assertTrue(range5.contains(newKey("row1", "f", "x")));
+    assertFalse(range5.contains(newKey("row1", "f", "z")));
+
+    Range range6 = range1.bound(newColumn("b", "y"), newColumn("f", "w"));
+    assertFalse(range6.contains(newKey("row1", "b", "x")));
+    assertTrue(range6.contains(newKey("row1", "b", "y")));
+    assertTrue(range6.contains(newKey("row1", "f", "w")));
+    assertTrue(range6.contains(newKey("row1", "f", "w", "a")));
+    assertFalse(range6.contains(newKey("row1", "f", "w").followingKey(PartialKey.ROW_COLFAM_COLQUAL)));
+    assertFalse(range6.contains(newKey("row1", "f", "x")));
+
+    Range range7 = range1.bound(newColumn("a", "y"), newColumn("g", "w"));
     assertEquals(range1, range7);
-    assertFalse(range7.contains(nk("row1", "b", "w")));
-    assertTrue(range7.contains(nk("row1", "b", "x")));
-    assertTrue(range7.contains(nk("row1", "f", "x")));
-    assertFalse(range7.contains(nk("row1", "f", "z")));
+    assertFalse(range7.contains(newKey("row1", "b", "w")));
+    assertTrue(range7.contains(newKey("row1", "b", "x")));
+    assertTrue(range7.contains(newKey("row1", "f", "x")));
+    assertFalse(range7.contains(newKey("row1", "f", "z")));
   }
 
   public void testString() {
@@ -770,7 +773,7 @@ public class RangeTest extends TestCase {
   }
 
   public void testReadFields() throws Exception {
-    Range r = nr("nuts", "soup");
+    Range r = newRange("nuts", "soup");
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     DataOutputStream dos = new DataOutputStream(baos);
     r.write(dos);
@@ -804,7 +807,7 @@ public class RangeTest extends TestCase {
   }
 
   public void testThrift() {
-    Range r = nr("nuts", "soup");
+    Range r = newRange("nuts", "soup");
     TRange tr = r.toThrift();
     Range r2 = new Range(tr);
     assertEquals(r, r2);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a4a45398/core/src/test/java/org/apache/accumulo/core/file/rfile/BlockIndexTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/file/rfile/BlockIndexTest.java b/core/src/test/java/org/apache/accumulo/core/file/rfile/BlockIndexTest.java
index 1b2b2a6..2985591 100644
--- a/core/src/test/java/org/apache/accumulo/core/file/rfile/BlockIndexTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/file/rfile/BlockIndexTest.java
@@ -69,7 +69,7 @@ public class BlockIndexTest {
     int num = 1000;
 
     for (int i = 0; i < num; i++) {
-      Key key = new Key(RFileTest.nf("", i), "cf1", "cq1");
+      Key key = new Key(RFileTest.formatString("", i), "cf1", "cq1");
       new RelativeKey(prevKey, key).write(out);
       new Value(new byte[0]).write(out);
       prevKey = key;
@@ -93,22 +93,22 @@ public class BlockIndexTest {
 
       BlockIndexEntry bie;
 
-      bie = blockIndex.seekBlock(new Key(RFileTest.nf("", row), "cf1", "cq1"), cacheBlock);
+      bie = blockIndex.seekBlock(new Key(RFileTest.formatString("", row), "cf1", "cq1"), cacheBlock);
       if (i == 0)
         Assert.assertSame(null, bie);
       else
         Assert.assertSame(indexEntries[i - 1], bie);
 
-      Assert.assertSame(bie, blockIndex.seekBlock(new Key(RFileTest.nf("", row - 1), "cf1", "cq1"), cacheBlock));
+      Assert.assertSame(bie, blockIndex.seekBlock(new Key(RFileTest.formatString("", row - 1), "cf1", "cq1"), cacheBlock));
 
-      bie = blockIndex.seekBlock(new Key(RFileTest.nf("", row + 1), "cf1", "cq1"), cacheBlock);
+      bie = blockIndex.seekBlock(new Key(RFileTest.formatString("", row + 1), "cf1", "cq1"), cacheBlock);
       Assert.assertSame(indexEntries[i], bie);
 
       RelativeKey rk = new RelativeKey();
       rk.setPrevKey(bie.getPrevKey());
       rk.readFields(cacheBlock);
 
-      Assert.assertEquals(rk.getKey(), new Key(RFileTest.nf("", row + 1), "cf1", "cq1"));
+      Assert.assertEquals(rk.getKey(), new Key(RFileTest.formatString("", row + 1), "cf1", "cq1"));
 
     }
     cacheBlock.close();
@@ -124,21 +124,21 @@ public class BlockIndexTest {
     int num = 1000;
 
     for (int i = 0; i < num; i++) {
-      Key key = new Key(RFileTest.nf("", 1), "cf1", "cq1");
+      Key key = new Key(RFileTest.formatString("", 1), "cf1", "cq1");
       new RelativeKey(prevKey, key).write(out);
       new Value(new byte[0]).write(out);
       prevKey = key;
     }
 
     for (int i = 0; i < num; i++) {
-      Key key = new Key(RFileTest.nf("", 3), "cf1", "cq1");
+      Key key = new Key(RFileTest.formatString("", 3), "cf1", "cq1");
       new RelativeKey(prevKey, key).write(out);
       new Value(new byte[0]).write(out);
       prevKey = key;
     }
 
     for (int i = 0; i < num; i++) {
-      Key key = new Key(RFileTest.nf("", 5), "cf1", "cq1");
+      Key key = new Key(RFileTest.formatString("", 5), "cf1", "cq1");
       new RelativeKey(prevKey, key).write(out);
       new Value(new byte[0]).write(out);
       prevKey = key;
@@ -155,11 +155,11 @@ public class BlockIndexTest {
     for (int i = 0; i < 257; i++)
       blockIndex = BlockIndex.getIndex(cacheBlock, new IndexEntry(prevKey, num, 0, 0, 0));
 
-    Assert.assertSame(null, blockIndex.seekBlock(new Key(RFileTest.nf("", 0), "cf1", "cq1"), cacheBlock));
-    Assert.assertSame(null, blockIndex.seekBlock(new Key(RFileTest.nf("", 1), "cf1", "cq1"), cacheBlock));
+    Assert.assertSame(null, blockIndex.seekBlock(new Key(RFileTest.formatString("", 0), "cf1", "cq1"), cacheBlock));
+    Assert.assertSame(null, blockIndex.seekBlock(new Key(RFileTest.formatString("", 1), "cf1", "cq1"), cacheBlock));
 
     for (int i = 2; i < 6; i++) {
-      Key seekKey = new Key(RFileTest.nf("", i), "cf1", "cq1");
+      Key seekKey = new Key(RFileTest.formatString("", i), "cf1", "cq1");
       BlockIndexEntry bie = blockIndex.seekBlock(seekKey, cacheBlock);
 
       Assert.assertTrue(bie.getPrevKey().compareTo(seekKey) < 0);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a4a45398/core/src/test/java/org/apache/accumulo/core/file/rfile/CreateCompatTestFile.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/file/rfile/CreateCompatTestFile.java b/core/src/test/java/org/apache/accumulo/core/file/rfile/CreateCompatTestFile.java
index 53c33d4..eec4e71 100644
--- a/core/src/test/java/org/apache/accumulo/core/file/rfile/CreateCompatTestFile.java
+++ b/core/src/test/java/org/apache/accumulo/core/file/rfile/CreateCompatTestFile.java
@@ -31,7 +31,7 @@ import org.apache.hadoop.fs.Path;
 
 public class CreateCompatTestFile {
 
-  public static Set<ByteSequence> ncfs(String... colFams) {
+  public static Set<ByteSequence> newColFamSequence(String... colFams) {
     HashSet<ByteSequence> cfs = new HashSet<>();
 
     for (String cf : colFams) {
@@ -41,15 +41,15 @@ public class CreateCompatTestFile {
     return cfs;
   }
 
-  private static Key nk(String row, String cf, String cq, String cv, long ts) {
+  private static Key newKey(String row, String cf, String cq, String cv, long ts) {
     return new Key(row.getBytes(), cf.getBytes(), cq.getBytes(), cv.getBytes(), ts);
   }
 
-  private static Value nv(String val) {
+  private static Value newValue(String val) {
     return new Value(val.getBytes());
   }
 
-  private static String nf(String prefix, int i) {
+  private static String formatStr(String prefix, int i) {
     return String.format(prefix + "%06d", i);
   }
 
@@ -59,23 +59,23 @@ public class CreateCompatTestFile {
     CachableBlockFile.Writer _cbw = new CachableBlockFile.Writer(fs, new Path(args[0]), "gz", conf, AccumuloConfiguration.getDefaultConfiguration());
     RFile.Writer writer = new RFile.Writer(_cbw, 1000);
 
-    writer.startNewLocalityGroup("lg1", ncfs(nf("cf_", 1), nf("cf_", 2)));
+    writer.startNewLocalityGroup("lg1", newColFamSequence(formatStr("cf_", 1), formatStr("cf_", 2)));
 
     for (int i = 0; i < 1000; i++) {
-      writer.append(nk(nf("r_", i), nf("cf_", 1), nf("cq_", 0), "", 1000 - i), nv(i + ""));
-      writer.append(nk(nf("r_", i), nf("cf_", 2), nf("cq_", 0), "", 1000 - i), nv(i + ""));
+      writer.append(newKey(formatStr("r_", i), formatStr("cf_", 1), formatStr("cq_", 0), "", 1000 - i), newValue(i + ""));
+      writer.append(newKey(formatStr("r_", i), formatStr("cf_", 2), formatStr("cq_", 0), "", 1000 - i), newValue(i + ""));
     }
 
-    writer.startNewLocalityGroup("lg2", ncfs(nf("cf_", 3)));
+    writer.startNewLocalityGroup("lg2", newColFamSequence(formatStr("cf_", 3)));
 
     for (int i = 0; i < 1000; i++) {
-      writer.append(nk(nf("r_", i), nf("cf_", 3), nf("cq_", 0), "", 1000 - i), nv(i + ""));
+      writer.append(newKey(formatStr("r_", i), formatStr("cf_", 3), formatStr("cq_", 0), "", 1000 - i), newValue(i + ""));
     }
 
     writer.startDefaultLocalityGroup();
 
     for (int i = 0; i < 1000; i++) {
-      writer.append(nk(nf("r_", i), nf("cf_", 4), nf("cq_", 0), "", 1000 - i), nv(i + ""));
+      writer.append(newKey(formatStr("r_", i), formatStr("cf_", 4), formatStr("cq_", 0), "", 1000 - i), newValue(i + ""));
     }
 
     writer.close();

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a4a45398/core/src/test/java/org/apache/accumulo/core/file/rfile/MultiThreadedRFileTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/file/rfile/MultiThreadedRFileTest.java b/core/src/test/java/org/apache/accumulo/core/file/rfile/MultiThreadedRFileTest.java
index 69ff2d4..51558c5 100644
--- a/core/src/test/java/org/apache/accumulo/core/file/rfile/MultiThreadedRFileTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/file/rfile/MultiThreadedRFileTest.java
@@ -180,11 +180,11 @@ public class MultiThreadedRFileTest {
     }
   }
 
-  static Key nk(String row, String cf, String cq, String cv, long ts) {
+  static Key newKey(String row, String cf, String cq, String cv, long ts) {
     return new Key(row.getBytes(), cf.getBytes(), cq.getBytes(), cv.getBytes(), ts);
   }
 
-  static Value nv(String val) {
+  static Value newValue(String val) {
     return new Value(val.getBytes());
   }
 
@@ -352,7 +352,7 @@ public class MultiThreadedRFileTest {
     String cf = getCf(locality);
     String cq = "cq" + pad(index);
 
-    return nk(row, cf, cq, "", 1);
+    return newKey(row, cf, cq, "", 1);
   }
 
   private String pad(int val) {
@@ -370,7 +370,7 @@ public class MultiThreadedRFileTest {
   }
 
   private Value getValue(int index) {
-    return nv("" + index);
+    return newValue("" + index);
   }
 
   private String getCf(int locality) {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a4a45398/core/src/test/java/org/apache/accumulo/core/file/rfile/RFileMetricsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/file/rfile/RFileMetricsTest.java b/core/src/test/java/org/apache/accumulo/core/file/rfile/RFileMetricsTest.java
index 7f8c087..89a63d1 100644
--- a/core/src/test/java/org/apache/accumulo/core/file/rfile/RFileMetricsTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/file/rfile/RFileMetricsTest.java
@@ -129,7 +129,7 @@ public class RFileMetricsTest {
     // test an rfile with one entry in the default locality group
 
     trf.openWriter();
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -153,8 +153,8 @@ public class RFileMetricsTest {
     // test an rfile with two entries in the default locality group
 
     trf.openWriter();
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L2", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -185,7 +185,7 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf1"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -214,8 +214,8 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf1"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L2", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -246,15 +246,15 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf1"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L2", 55), RFileTest.newValue("foo"));
 
     Set<ByteSequence> lg2 = new HashSet<>();
     lg2.add(new ArrayByteSequence("cf2"));
 
     trf.writer.startNewLocalityGroup("lg2", lg2);
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "L2", 55), RFileTest.newValue("foo"));
 
     trf.closeWriter();
 
@@ -297,13 +297,13 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf1"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L2", 55), RFileTest.newValue("foo"));
 
     trf.writer.startDefaultLocalityGroup();
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "A", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "B", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "A", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "B", 55), RFileTest.newValue("foo"));
 
     trf.closeWriter();
 
@@ -347,16 +347,16 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf3"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq2", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq2", "L2", 55), RFileTest.newValue("foo"));
 
     trf.writer.startDefaultLocalityGroup();
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "A", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "B", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf4", "cq1", "A", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf4", "cq1", "B", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "A", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "B", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf4", "cq1", "A", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf4", "cq1", "B", 55), RFileTest.newValue("foo"));
 
     trf.closeWriter();
 
@@ -395,10 +395,10 @@ public class RFileMetricsTest {
     // test an rfile with four blocks in the default locality group
 
     trf.openWriter(20);// Each entry is a block
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq2", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq2", "L2", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -430,10 +430,10 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf3"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq2", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq2", "L2", 55), RFileTest.newValue("foo"));
     trf.closeWriter();
 
     trf.openReader(false);
@@ -465,16 +465,16 @@ public class RFileMetricsTest {
     lg1.add(new ArrayByteSequence("cf3"));
 
     trf.writer.startNewLocalityGroup("lg1", lg1);
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf1", "cq2", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq1", "L1", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf3", "cq2", "L2", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf1", "cq2", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq1", "L1", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf3", "cq2", "L2", 55), RFileTest.newValue("foo"));
 
     trf.writer.startDefaultLocalityGroup();
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "A", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf2", "cq1", "B", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf4", "cq1", "A", 55), RFileTest.nv("foo"));
-    trf.writer.append(RFileTest.nk("r1", "cf4", "cq1", "B", 55), RFileTest.nv("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "A", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf2", "cq1", "B", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf4", "cq1", "A", 55), RFileTest.newValue("foo"));
+    trf.writer.append(RFileTest.newKey("r1", "cf4", "cq1", "B", 55), RFileTest.newValue("foo"));
 
     trf.closeWriter();
 


Mime
View raw message