accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From els...@apache.org
Subject accumulo git commit: ACCUMULO-2817 Added decode(byte[], int, int) to Lexicoder and Encoder implementations, but not to the interfaces themselves.
Date Thu, 26 Feb 2015 03:17:22 GMT
Repository: accumulo
Updated Branches:
  refs/heads/master aac52a82e -> 6b94344d4


ACCUMULO-2817 Added decode(byte[], int, int) to Lexicoder and Encoder implementations, but not to the interfaces themselves.

* Added AbstractEncoder and AbstractLexicoder to refactor common 'decode' functionality.
* Refactored existing implementations of Lexicoder to extend AbstractLexicoder, and Encoders to extend AbstractEncoder.

Signed-off-by: Josh Elser <elserj@apache.org>


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

Branch: refs/heads/master
Commit: 6b94344d43fb08896cafdf83f907f7a4237b4dc0
Parents: aac52a8
Author: matt dailey <matthew.dailey1@gmail.com>
Authored: Tue Feb 17 18:58:50 2015 -0500
Committer: Josh Elser <elserj@apache.org>
Committed: Wed Feb 25 21:54:16 2015 -0500

----------------------------------------------------------------------
 .../core/client/lexicoder/AbstractEncoder.java  | 60 +++++++++++++
 .../client/lexicoder/BigIntegerLexicoder.java   | 21 ++---
 .../core/client/lexicoder/BytesLexicoder.java   | 20 ++++-
 .../core/client/lexicoder/DateLexicoder.java    |  8 +-
 .../core/client/lexicoder/DoubleLexicoder.java  |  8 +-
 .../core/client/lexicoder/IntegerLexicoder.java |  8 +-
 .../core/client/lexicoder/ListLexicoder.java    | 14 +--
 .../core/client/lexicoder/LongLexicoder.java    |  4 +-
 .../core/client/lexicoder/PairLexicoder.java    | 11 +--
 .../core/client/lexicoder/ReverseLexicoder.java | 15 ++--
 .../core/client/lexicoder/StringLexicoder.java  |  8 +-
 .../core/client/lexicoder/TextLexicoder.java    |  9 +-
 .../client/lexicoder/UIntegerLexicoder.java     | 16 ++--
 .../core/client/lexicoder/ULongLexicoder.java   | 16 ++--
 .../core/client/lexicoder/UUIDLexicoder.java    | 13 +--
 .../lexicoder/impl/AbstractLexicoder.java       | 23 +++++
 .../core/client/lexicoder/impl/ByteUtils.java   | 13 ++-
 .../accumulo/core/iterators/LongCombiner.java   | 27 ++++--
 .../core/iterators/user/BigDecimalCombiner.java |  7 +-
 .../iterators/user/SummingArrayCombiner.java    | 14 +--
 .../lexicoder/BigIntegerLexicoderTest.java      | 12 ++-
 .../client/lexicoder/BytesLexicoderTest.java    | 28 ++++++
 .../client/lexicoder/DateLexicoderTest.java     | 30 +++++++
 .../client/lexicoder/DoubleLexicoderTest.java   | 14 ++-
 .../client/lexicoder/IntegerLexicoderTest.java  | 12 ++-
 .../core/client/lexicoder/LexicoderTest.java    | 31 +++++--
 .../client/lexicoder/ListLexicoderTest.java     | 33 ++++---
 .../client/lexicoder/LongLexicoderTest.java     | 13 ++-
 .../client/lexicoder/PairLexicoderTest.java     | 12 ++-
 .../client/lexicoder/ReverseLexicoderTest.java  | 15 +++-
 .../client/lexicoder/StringLexicoderTest.java   | 28 ++++++
 .../client/lexicoder/TextLexicoderTest.java     | 28 ++++++
 .../client/lexicoder/UIntegerLexicoderTest.java | 12 ++-
 .../client/lexicoder/ULongLexicoderTest.java    | 13 ++-
 .../client/lexicoder/UUIDLexicoderTest.java     |  9 +-
 .../lexicoder/impl/AbstractLexicoderTest.java   | 94 ++++++++++++++++++++
 .../client/lexicoder/impl/ByteUtilsTest.java    | 71 +++++++++++++++
 .../core/iterators/user/CombinerTest.java       |  4 +
 .../server/replication/StatusCombiner.java      | 24 ++++-
 39 files changed, 682 insertions(+), 116 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/AbstractEncoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/AbstractEncoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/AbstractEncoder.java
new file mode 100644
index 0000000..b266e53
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/AbstractEncoder.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder;
+
+import com.google.common.base.Preconditions;
+import org.apache.accumulo.core.iterators.ValueFormatException;
+
+/**
+ * AbstractEncoder is an {@link org.apache.accumulo.core.client.lexicoder.Encoder} that implements all of Encoder's
+ * methods validating the input, but has those methods defer logic to to a new method,
+ * {@link #decodeUnchecked(byte[], int, int)}.
+ * @since 1.7.0
+ */
+public abstract class AbstractEncoder<T> implements Encoder<T> {
+
+  /**
+   * Decodes a byte array without checking if the offset and len exceed the bounds of the actual array.
+   */
+  protected abstract T decodeUnchecked(byte[] b, int offset, int len) throws ValueFormatException;
+
+  /**
+   * Calls {@link #decodeUnchecked(byte[], int, int)} as {@code decodeUnchecked(b, 0, b.length);}.
+   */
+  @Override
+  public T decode(byte[] b) {
+    Preconditions.checkNotNull(b, "cannot decode null byte array");
+    return decodeUnchecked(b, 0, b.length);
+  }
+
+  /**
+   * Checks if the byte array is null, or if parameters exceed the bounds of the byte array,
+   * then calls {@link #decodeUnchecked(byte[], int, int)}.
+   *
+   * @throws java.lang.NullPointerException if {@code b} is null
+   * @throws java.lang.IllegalArgumentException if {@code offset + len} exceeds the length of {@code b}
+   */
+  public T decode(byte[] b, int offset, int len) {
+    Preconditions.checkNotNull(b, "cannot decode null byte array");
+    Preconditions.checkArgument(offset >= 0, "offset %s cannot be negative", offset);
+    Preconditions.checkArgument(len >= 0, "length %s cannot be negative", len);
+    Preconditions.checkArgument(offset + len < b.length, "offset + length %s exceeds byte array length %s",
+            (offset + len), b.length);
+
+    return decodeUnchecked(b, offset, len);
+  }
+}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoder.java
index 838e3cd..577e33e 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoder.java
@@ -16,21 +16,22 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+import org.apache.accumulo.core.client.lexicoder.impl.FixedByteArrayOutputStream;
+import org.apache.accumulo.core.iterators.ValueFormatException;
+
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.math.BigInteger;
 
-import org.apache.accumulo.core.client.lexicoder.impl.FixedByteArrayOutputStream;
-import org.apache.accumulo.core.iterators.ValueFormatException;
-
 /**
  * A lexicoder to encode/decode a BigInteger to/from bytes that maintain its native Java sort order.
  *
  * @since 1.6.0
  */
-public class BigIntegerLexicoder implements Lexicoder<BigInteger> {
+public class BigIntegerLexicoder extends AbstractLexicoder<BigInteger> implements Lexicoder<BigInteger> {
 
   @Override
   public byte[] encode(BigInteger v) {
@@ -63,15 +64,15 @@ public class BigIntegerLexicoder implements Lexicoder<BigInteger> {
   }
 
   @Override
-  public BigInteger decode(byte[] b) throws ValueFormatException {
+  protected BigInteger decodeUnchecked(byte[] b, int offset, int origLen) throws ValueFormatException {
 
     try {
-      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b));
-      int len = dis.readInt();
-      len = len ^ 0x80000000;
-      len = Math.abs(len);
+      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b, offset, origLen));
+      int newLen = dis.readInt();
+      newLen = newLen ^ 0x80000000;
+      newLen = Math.abs(newLen);
 
-      byte[] bytes = new byte[len];
+      byte[] bytes = new byte[newLen];
       dis.readFully(bytes);
 
       bytes[0] = (byte) (0x80 ^ bytes[0]);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoder.java
index e018e0c..8e0f5e2 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoder.java
@@ -16,13 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 /**
  * For each of the methods, this lexicoder just passes the input through untouched. It is meant to be combined with other lexicoders like the
  * {@link ReverseLexicoder}.
  *
  * @since 1.6.0
  */
-public class BytesLexicoder implements Lexicoder<byte[]> {
+public class BytesLexicoder extends AbstractLexicoder<byte[]> implements Lexicoder<byte[]> {
 
   @Override
   public byte[] encode(byte[] data) {
@@ -31,7 +33,23 @@ public class BytesLexicoder implements Lexicoder<byte[]> {
 
   @Override
   public byte[] decode(byte[] data) {
+    // overrides AbstractLexicoder since this simply returns the array
     return data;
   }
 
+  /**
+   * If offset == 0 and len == data.length, returns data.  Otherwise, returns a new
+   * byte array with contents starting at data[offset] with length len.
+   */
+  @Override
+  protected byte[] decodeUnchecked(byte[] data, int offset, int len) {
+    if (offset == 0 && len == data.length) {
+      return data;
+    }
+
+    byte[] copy = new byte[len];
+    System.arraycopy(data, offset, copy, 0, len);
+    return copy;
+  }
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DateLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DateLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DateLexicoder.java
index 8533bfe..2d17d37 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DateLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DateLexicoder.java
@@ -16,6 +16,8 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 import java.util.Date;
 
 /**
@@ -23,7 +25,7 @@ import java.util.Date;
  *
  * @since 1.6.0
  */
-public class DateLexicoder implements Lexicoder<Date> {
+public class DateLexicoder extends AbstractLexicoder<Date> implements Lexicoder<Date> {
 
   private LongLexicoder longEncoder = new LongLexicoder();
 
@@ -33,8 +35,8 @@ public class DateLexicoder implements Lexicoder<Date> {
   }
 
   @Override
-  public Date decode(byte[] data) {
-    return new Date(longEncoder.decode(data));
+  protected Date decodeUnchecked(byte[] data, int offset, int len) {
+    return new Date(longEncoder.decodeUnchecked(data, offset, len));
   }
 
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoder.java
index 6310645..14413c0 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoder.java
@@ -16,12 +16,14 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 /**
  * A lexicoder for preserving the native Java sort order of Double values.
  *
  * @since 1.6.0
  */
-public class DoubleLexicoder implements Lexicoder<Double> {
+public class DoubleLexicoder extends AbstractLexicoder<Double> implements Lexicoder<Double> {
 
   private ULongLexicoder longEncoder = new ULongLexicoder();
 
@@ -37,8 +39,8 @@ public class DoubleLexicoder implements Lexicoder<Double> {
   }
 
   @Override
-  public Double decode(byte[] data) {
-    long l = longEncoder.decode(data);
+  protected Double decodeUnchecked(byte[] data, int offset, int len) {
+    long l = longEncoder.decodeUnchecked(data, offset, len);
     if (l < 0)
       l = l ^ 0x8000000000000000l;
     else

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoder.java
index 12b515a..f96b41d 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoder.java
@@ -16,13 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 /**
  * A lexicoder for signed integers. The encoding sorts Integer.MIN_VALUE first and Integer.MAX_VALUE last. The encoding sorts -2 before -1. It corresponds to
  * the sort order of Integer.
  *
  * @since 1.6.0
  */
-public class IntegerLexicoder implements Lexicoder<Integer> {
+public class IntegerLexicoder extends AbstractLexicoder<Integer> implements Lexicoder<Integer> {
 
   private UIntegerLexicoder uil = new UIntegerLexicoder();
 
@@ -32,8 +34,8 @@ public class IntegerLexicoder implements Lexicoder<Integer> {
   }
 
   @Override
-  public Integer decode(byte[] data) {
-    return uil.decode(data) ^ 0x80000000;
+  protected Integer decodeUnchecked(byte[] data, int offset, int len) {
+    return uil.decodeUnchecked(data, offset, len) ^ 0x80000000;
   }
 
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ListLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ListLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ListLexicoder.java
index 5ecee88..a92f4c6 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ListLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ListLexicoder.java
@@ -16,20 +16,22 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
+import java.util.ArrayList;
+import java.util.List;
+
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.concat;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.escape;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.split;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.unescape;
 
-import java.util.ArrayList;
-import java.util.List;
-
 /**
  * A lexicoder to encode/decode a Java List to/from a byte array where the concatenation of each encoded element sorts lexicographically.
  *
  * @since 1.6.0
  */
-public class ListLexicoder<LT> implements Lexicoder<List<LT>> {
+public class ListLexicoder<LT> extends AbstractLexicoder<List<LT>> implements Lexicoder<List<LT>> {
 
   private Lexicoder<LT> lexicoder;
 
@@ -53,9 +55,9 @@ public class ListLexicoder<LT> implements Lexicoder<List<LT>> {
   }
 
   @Override
-  public List<LT> decode(byte[] b) {
+  protected List<LT> decodeUnchecked(byte[] b, int offset, int len) {
 
-    byte[][] escapedElements = split(b);
+    byte[][] escapedElements = split(b, offset, len);
     ArrayList<LT> ret = new ArrayList<LT>(escapedElements.length);
 
     for (byte[] escapedElement : escapedElements) {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/LongLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/LongLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/LongLexicoder.java
index f70a83c..ec850a3 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/LongLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/LongLexicoder.java
@@ -29,7 +29,7 @@ public class LongLexicoder extends ULongLexicoder {
   }
 
   @Override
-  public Long decode(byte[] data) {
-    return super.decode(data) ^ 0x8000000000000000l;
+  protected Long decodeUnchecked(byte[] data, int offset, int len) {
+    return super.decodeUnchecked(data, offset, len) ^ 0x8000000000000000l;
   }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/PairLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/PairLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/PairLexicoder.java
index 22af289..dff946f 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/PairLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/PairLexicoder.java
@@ -16,13 +16,14 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+import org.apache.accumulo.core.util.ComparablePair;
+
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.concat;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.escape;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.split;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.unescape;
 
-import org.apache.accumulo.core.util.ComparablePair;
-
 /**
  * This class is a lexicoder that sorts a ComparablePair. Each item in the pair is encoded with the given lexicoder and concatenated together. This makes it
  * easy to construct a sortable key based on two components. There are many examples of this- but a key/value relationship is a great one.
@@ -48,7 +49,7 @@ import org.apache.accumulo.core.util.ComparablePair;
  * @since 1.6.0
  */
 
-public class PairLexicoder<A extends Comparable<A>,B extends Comparable<B>> implements Lexicoder<ComparablePair<A,B>> {
+public class PairLexicoder<A extends Comparable<A>,B extends Comparable<B>> extends AbstractLexicoder<ComparablePair<A,B>> implements Lexicoder<ComparablePair<A,B>> {
 
   private Lexicoder<A> firstLexicoder;
   private Lexicoder<B> secondLexicoder;
@@ -64,9 +65,9 @@ public class PairLexicoder<A extends Comparable<A>,B extends Comparable<B>> impl
   }
 
   @Override
-  public ComparablePair<A,B> decode(byte[] data) {
+  protected ComparablePair<A,B> decodeUnchecked(byte[] data, int offset, int len) {
 
-    byte[][] fields = split(data);
+    byte[][] fields = split(data, offset, len);
     if (fields.length != 2) {
       throw new RuntimeException("Data does not have 2 fields, it has " + fields.length);
     }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoder.java
index 1a6999b..3a422d5 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoder.java
@@ -16,6 +16,8 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.escape;
 import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.unescape;
 
@@ -27,7 +29,7 @@ import static org.apache.accumulo.core.client.lexicoder.impl.ByteUtils.unescape;
  * @since 1.6.0
  */
 
-public class ReverseLexicoder<T> implements Lexicoder<T> {
+public class ReverseLexicoder<T> extends AbstractLexicoder<T> implements Lexicoder<T> {
 
   private Lexicoder<T> lexicoder;
 
@@ -53,11 +55,14 @@ public class ReverseLexicoder<T> implements Lexicoder<T> {
   }
 
   @Override
-  public T decode(byte[] data) {
-    byte ret[] = new byte[data.length - 1];
+  protected T decodeUnchecked(byte[] data, int offset, int len) {
+    byte ret[] = new byte[len - 1];
 
-    for (int i = 0; i < ret.length; i++)
-      ret[i] = (byte) (0xff - (0xff & data[i]));
+    int dataIndex;
+    for (int i = 0; i < ret.length; i++) {
+      dataIndex = offset + i;
+      ret[i] = (byte) (0xff - (0xff & data[dataIndex]));
+    }
 
     return lexicoder.decode(unescape(ret));
   }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/StringLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/StringLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/StringLexicoder.java
index 9d5e07e..f7b1877 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/StringLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/StringLexicoder.java
@@ -16,6 +16,8 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 /**
@@ -25,7 +27,7 @@ import static java.nio.charset.StandardCharsets.UTF_8;
  * @since 1.6.0
  */
 
-public class StringLexicoder implements Lexicoder<String> {
+public class StringLexicoder extends AbstractLexicoder<String> implements Lexicoder<String> {
 
   @Override
   public byte[] encode(String data) {
@@ -33,8 +35,8 @@ public class StringLexicoder implements Lexicoder<String> {
   }
 
   @Override
-  public String decode(byte[] data) {
-    return new String(data, UTF_8);
+  protected String decodeUnchecked(byte[] data, int offset, int len) {
+    return new String(data, offset, len, UTF_8);
   }
 
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/TextLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/TextLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/TextLexicoder.java
index 08837a5..bb29857 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/TextLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/TextLexicoder.java
@@ -16,6 +16,7 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
 import org.apache.accumulo.core.util.TextUtil;
 import org.apache.hadoop.io.Text;
 
@@ -26,7 +27,7 @@ import org.apache.hadoop.io.Text;
  * @since 1.6.0
  */
 
-public class TextLexicoder implements Lexicoder<Text> {
+public class TextLexicoder extends AbstractLexicoder<Text> implements Lexicoder<Text> {
 
   @Override
   public byte[] encode(Text data) {
@@ -34,8 +35,10 @@ public class TextLexicoder implements Lexicoder<Text> {
   }
 
   @Override
-  public Text decode(byte[] data) {
-    return new Text(data);
+  protected Text decodeUnchecked(byte[] data, int offset, int len) {
+    Text text = new Text();
+    text.set(data, offset, len);
+    return text;
   }
 
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoder.java
index f8842a9..e99c3b1 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoder.java
@@ -16,13 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 /**
  * A lexicoder for an unsigned integer. It sorts 0 before -1 and does not preserve the native sort order of a Java integer because Java does not contain an
  * unsigned integer. If Java had an unsigned integer type, this would correspond to its sort order.
  *
  * @since 1.6.0
  */
-public class UIntegerLexicoder implements Lexicoder<Integer> {
+public class UIntegerLexicoder extends AbstractLexicoder<Integer> implements Lexicoder<Integer> {
 
   @Override
   public byte[] encode(Integer i) {
@@ -52,22 +54,22 @@ public class UIntegerLexicoder implements Lexicoder<Integer> {
   }
 
   @Override
-  public Integer decode(byte[] data) {
+  protected Integer decodeUnchecked(byte[] data, int offset, int len) {
 
-    if (data[0] < 0 || data[0] > 8)
-      throw new IllegalArgumentException("Unexpected length " + (0xff & data[0]));
+    if (data[offset] < 0 || data[offset] > 8)
+      throw new IllegalArgumentException("Unexpected length " + (0xff & data[offset]));
 
     int i = 0;
     int shift = 0;
 
-    for (int idx = data.length - 1; idx >= 1; idx--) {
+    for (int idx = (offset + len) - 1; idx >= offset + 1; idx--) {
       i += (data[idx] & 0xffl) << shift;
       shift += 8;
     }
 
     // fill in 0xff prefix
-    if (data[0] > 4)
-      i |= -1 << ((8 - data[0]) << 3);
+    if (data[offset] > 4)
+      i |= -1 << ((8 - data[offset]) << 3);
 
     return i;
   }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoder.java
index a3dcab5..a69ed34 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoder.java
@@ -16,13 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+
 /**
  * Unsigned long lexicoder. The lexicographic encoding sorts first 0l and -1l last. This encoding does not correspond to the sort of Long because it does not
  * consider the sign bit. If Java had an unsigned long type, this encoder would correspond to its sort order.
  *
  * @since 1.6.0
  */
-public class ULongLexicoder implements Lexicoder<Long> {
+public class ULongLexicoder extends AbstractLexicoder<Long> implements Lexicoder<Long> {
 
   @Override
   public byte[] encode(Long l) {
@@ -52,22 +54,22 @@ public class ULongLexicoder implements Lexicoder<Long> {
   }
 
   @Override
-  public Long decode(byte[] data) {
+  protected Long decodeUnchecked(byte[] data, int offset, int len) {
 
     long l = 0;
     int shift = 0;
 
-    if (data[0] < 0 || data[0] > 16)
-      throw new IllegalArgumentException("Unexpected length " + (0xff & data[0]));
+    if (data[offset] < 0 || data[offset] > 16)
+      throw new IllegalArgumentException("Unexpected length " + (0xff & data[offset]));
 
-    for (int i = data.length - 1; i >= 1; i--) {
+    for (int i = (offset + len) - 1; i >= offset + 1; i--) {
       l += (data[i] & 0xffl) << shift;
       shift += 8;
     }
 
     // fill in 0xff prefix
-    if (data[0] > 8)
-      l |= -1l << ((16 - data[0]) << 3);
+    if (data[offset] > 8)
+      l |= -1l << ((16 - data[offset]) << 3);
 
     return l;
   }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoder.java
index 43fa1a4..98ee467 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoder.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoder.java
@@ -16,21 +16,22 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
+import org.apache.accumulo.core.client.lexicoder.impl.FixedByteArrayOutputStream;
+import org.apache.accumulo.core.iterators.ValueFormatException;
+
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.UUID;
 
-import org.apache.accumulo.core.client.lexicoder.impl.FixedByteArrayOutputStream;
-import org.apache.accumulo.core.iterators.ValueFormatException;
-
 /**
  * A lexicoder for a UUID that maintains its lexicographic sorting order.
  *
  * @since 1.6.0
  */
-public class UUIDLexicoder implements Lexicoder<UUID> {
+public class UUIDLexicoder extends AbstractLexicoder<UUID> implements Lexicoder<UUID> {
 
   /**
    * @see <a href="http://www.ietf.org/rfc/rfc4122.txt"> RFC 4122: A Universally Unique IDentifier (UUID) URN Namespace, "Rules for Lexical Equivalence" in
@@ -54,9 +55,9 @@ public class UUIDLexicoder implements Lexicoder<UUID> {
   }
 
   @Override
-  public UUID decode(byte[] b) throws ValueFormatException {
+  protected UUID decodeUnchecked(byte[] b, int offset, int len) throws ValueFormatException {
     try {
-      DataInputStream in = new DataInputStream(new ByteArrayInputStream(b));
+      DataInputStream in = new DataInputStream(new ByteArrayInputStream(b, offset, len));
       return new UUID(in.readLong() ^ 0x8000000000000000l, in.readLong() ^ 0x8000000000000000l);
     } catch (IOException e) {
       throw new RuntimeException(e);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoder.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoder.java
new file mode 100644
index 0000000..e568f25
--- /dev/null
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoder.java
@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder.impl;
+
+import org.apache.accumulo.core.client.lexicoder.AbstractEncoder;
+import org.apache.accumulo.core.client.lexicoder.Lexicoder;
+
+public abstract class AbstractLexicoder<T> extends AbstractEncoder<T> implements Lexicoder<T> {
+}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtils.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtils.java b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtils.java
index 4973de8..b168807 100644
--- a/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtils.java
+++ b/core/src/main/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtils.java
@@ -90,19 +90,26 @@ public class ByteUtils {
    * Splits a byte array by 0x00
    */
   public static byte[][] split(byte[] data) {
+    return split(data, 0, data.length);
+  }
+
+  /**
+   * Splits a byte array by 0x00
+   */
+  public static byte[][] split(byte[] data, int dataOffset, int len) {
     ArrayList<Integer> offsets = new ArrayList<Integer>();
 
-    for (int i = 0; i < data.length; i++) {
+    for (int i = dataOffset; i < (dataOffset + len); i++) {
       if (data[i] == 0x00) {
         offsets.add(i);
       }
     }
 
-    offsets.add(data.length);
+    offsets.add(dataOffset + len);
 
     byte[][] ret = new byte[offsets.size()][];
 
-    int index = 0;
+    int index = dataOffset;
     for (int i = 0; i < offsets.size(); i++) {
       ret[i] = new byte[offsets.get(i) - index];
       System.arraycopy(data, index, ret[i], 0, ret[i].length);

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/iterators/LongCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/LongCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/LongCombiner.java
index ad98968..2a225fd 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/LongCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/LongCombiner.java
@@ -26,6 +26,7 @@ import java.io.IOException;
 import java.util.Map;
 
 import org.apache.accumulo.core.client.IteratorSetting;
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Value;
 import org.apache.hadoop.io.WritableUtils;
@@ -117,7 +118,7 @@ public abstract class LongCombiner extends TypedValueCombiner<Long> {
   /**
    * An Encoder that uses a variable-length encoding for Longs. It uses WritableUtils.writeVLong and WritableUtils.readVLong for encoding and decoding.
    */
-  public static class VarLenEncoder implements Encoder<Long> {
+  public static class VarLenEncoder extends AbstractLexicoder<Long> implements Encoder<Long> {
     @Override
     public byte[] encode(Long v) {
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
@@ -133,8 +134,8 @@ public abstract class LongCombiner extends TypedValueCombiner<Long> {
     }
 
     @Override
-    public Long decode(byte[] b) {
-      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b));
+    protected Long decodeUnchecked(byte[] b, int offset, int len) {
+      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b, offset, len));
       try {
         return WritableUtils.readVLong(dis);
       } catch (IOException e) {
@@ -146,7 +147,7 @@ public abstract class LongCombiner extends TypedValueCombiner<Long> {
   /**
    * An Encoder that uses an 8-byte encoding for Longs.
    */
-  public static class FixedLenEncoder implements Encoder<Long> {
+  public static class FixedLenEncoder extends AbstractLexicoder<Long> implements Encoder<Long> {
     @Override
     public byte[] encode(Long l) {
       byte[] b = new byte[8];
@@ -162,31 +163,39 @@ public abstract class LongCombiner extends TypedValueCombiner<Long> {
     }
 
     @Override
-    public Long decode(byte[] b) {
-      return decode(b, 0);
+    protected Long decodeUnchecked(byte[] b, int offset, int len) {
+      return decodeStatic(b, offset, len);
     }
 
+    // refactor?  it's public, so cannot remove
     public static long decode(byte[] b, int offset) {
       if (b.length < offset + 8)
         throw new ValueFormatException("trying to convert to long, but byte array isn't long enough, wanted " + (offset + 8) + " found " + b.length);
       return (((long) b[offset + 0] << 56) + ((long) (b[offset + 1] & 255) << 48) + ((long) (b[offset + 2] & 255) << 40) + ((long) (b[offset + 3] & 255) << 32)
           + ((long) (b[offset + 4] & 255) << 24) + ((b[offset + 5] & 255) << 16) + ((b[offset + 6] & 255) << 8) + ((b[offset + 7] & 255) << 0));
     }
+
+    public static long decodeStatic(byte[] b, int offset, int len) {
+      if (b.length < offset + 8 || len < 8)
+        throw new ValueFormatException("trying to convert to long, but byte array isn't long enough, wanted " + (offset + 8) + " found " + len);
+      return (((long) b[offset + 0] << 56) + ((long) (b[offset + 1] & 255) << 48) + ((long) (b[offset + 2] & 255) << 40) + ((long) (b[offset + 3] & 255) << 32)
+              + ((long) (b[offset + 4] & 255) << 24) + ((b[offset + 5] & 255) << 16) + ((b[offset + 6] & 255) << 8) + ((b[offset + 7] & 255) << 0));
+    }
   }
 
   /**
    * An Encoder that uses a String representation of Longs. It uses Long.toString and Long.parseLong for encoding and decoding.
    */
-  public static class StringEncoder implements Encoder<Long> {
+  public static class StringEncoder extends AbstractLexicoder<Long> implements Encoder<Long> {
     @Override
     public byte[] encode(Long v) {
       return Long.toString(v).getBytes(UTF_8);
     }
 
     @Override
-    public Long decode(byte[] b) {
+    protected Long decodeUnchecked(byte[] b, int offset, int len) {
       try {
-        return Long.parseLong(new String(b, UTF_8));
+        return Long.parseLong(new String(b, offset, len, UTF_8));
       } catch (NumberFormatException nfe) {
         throw new ValueFormatException(nfe);
       }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
index 86c9e73..3a6dbcb 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/BigDecimalCombiner.java
@@ -23,6 +23,7 @@ import java.math.BigDecimal;
 import java.util.Iterator;
 import java.util.Map;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Value;
 import org.apache.accumulo.core.iterators.IteratorEnvironment;
@@ -100,16 +101,16 @@ public abstract class BigDecimalCombiner extends TypedValueCombiner<BigDecimal>
    * Provides the ability to encode scientific notation.
    *
    */
-  public static class BigDecimalEncoder implements org.apache.accumulo.core.iterators.TypedValueCombiner.Encoder<BigDecimal> {
+  public static class BigDecimalEncoder extends AbstractLexicoder<BigDecimal> implements org.apache.accumulo.core.iterators.TypedValueCombiner.Encoder<BigDecimal> {
     @Override
     public byte[] encode(BigDecimal v) {
       return v.toString().getBytes(UTF_8);
     }
 
     @Override
-    public BigDecimal decode(byte[] b) throws ValueFormatException {
+    protected BigDecimal decodeUnchecked(byte[] b, int offset, int len) throws ValueFormatException {
       try {
-        return new BigDecimal(new String(b, UTF_8));
+        return new BigDecimal(new String(b, offset, len, UTF_8));
       } catch (NumberFormatException nfe) {
         throw new ValueFormatException(nfe);
       }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/main/java/org/apache/accumulo/core/iterators/user/SummingArrayCombiner.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/accumulo/core/iterators/user/SummingArrayCombiner.java b/core/src/main/java/org/apache/accumulo/core/iterators/user/SummingArrayCombiner.java
index 2217d13..04c0af1 100644
--- a/core/src/main/java/org/apache/accumulo/core/iterators/user/SummingArrayCombiner.java
+++ b/core/src/main/java/org/apache/accumulo/core/iterators/user/SummingArrayCombiner.java
@@ -30,6 +30,8 @@ import java.util.List;
 import java.util.Map;
 
 import org.apache.accumulo.core.client.IteratorSetting;
+import org.apache.accumulo.core.client.lexicoder.AbstractEncoder;
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoder;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Value;
 import org.apache.accumulo.core.iterators.IteratorEnvironment;
@@ -140,7 +142,7 @@ public class SummingArrayCombiner extends TypedValueCombiner<List<Long>> {
     return true;
   }
 
-  public abstract static class DOSArrayEncoder<V> implements Encoder<List<V>> {
+  public abstract static class DOSArrayEncoder<V> extends AbstractLexicoder<List<V>> implements Encoder<List<V>> {
     public abstract void write(DataOutputStream dos, V v) throws IOException;
 
     public abstract V read(DataInputStream dis) throws IOException;
@@ -161,8 +163,8 @@ public class SummingArrayCombiner extends TypedValueCombiner<List<Long>> {
     }
 
     @Override
-    public List<V> decode(byte[] b) {
-      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b));
+    protected List<V> decodeUnchecked(byte[] b, int offset, int origLen) {
+      DataInputStream dis = new DataInputStream(new ByteArrayInputStream(b, offset, origLen));
       try {
         int len = WritableUtils.readVInt(dis);
         List<V> vl = new ArrayList<V>(len);
@@ -200,7 +202,7 @@ public class SummingArrayCombiner extends TypedValueCombiner<List<Long>> {
     }
   }
 
-  public static class StringArrayEncoder implements Encoder<List<Long>> {
+  public static class StringArrayEncoder extends AbstractEncoder<List<Long>> implements Encoder<List<Long>> {
     @Override
     public byte[] encode(List<Long> la) {
       if (la.size() == 0)
@@ -214,8 +216,8 @@ public class SummingArrayCombiner extends TypedValueCombiner<List<Long>> {
     }
 
     @Override
-    public List<Long> decode(byte[] b) {
-      String[] longstrs = new String(b, UTF_8).split(",");
+    protected List<Long> decodeUnchecked(byte[] b, int offset, int len) {
+      String[] longstrs = new String(b, offset, len, UTF_8).split(",");
       List<Long> la = new ArrayList<Long>(longstrs.length);
       for (String s : longstrs) {
         if (s.length() == 0)

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoderTest.java
index 9d453e3..9165fe5 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BigIntegerLexicoderTest.java
@@ -16,13 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.math.BigInteger;
 import java.util.Arrays;
 
 /**
  *
  */
-public class BigIntegerLexicoderTest extends LexicoderTest {
+public class BigIntegerLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
     assertSortOrder(new BigIntegerLexicoder(), Arrays.asList(new BigInteger("-1"), new BigInteger("0"), new BigInteger("1"), new BigInteger("-257"),
         new BigInteger("-256"), new BigInteger("-255"), new BigInteger("255"), new BigInteger("256"), new BigInteger("257"), new BigInteger("65534"),
@@ -33,4 +35,12 @@ public class BigIntegerLexicoderTest extends LexicoderTest {
         new BigInteger("128"), new BigInteger("129"), new BigInteger("-126"), new BigInteger("-127"), new BigInteger("-128"), new BigInteger("-129")));
 
   }
+
+  public void testDecode() {
+    assertDecodes(new BigIntegerLexicoder(), new BigInteger("-2147483649"));
+    assertDecodes(new BigIntegerLexicoder(), new BigInteger("-1"));
+    assertDecodes(new BigIntegerLexicoder(), BigInteger.ZERO);
+    assertDecodes(new BigIntegerLexicoder(), BigInteger.ONE);
+    assertDecodes(new BigIntegerLexicoder(), new BigInteger("2147483647"));
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoderTest.java
new file mode 100644
index 0000000..3f5b991
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/BytesLexicoderTest.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder;
+
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
+public class BytesLexicoderTest extends AbstractLexicoderTest {
+
+  public void testDecodes() {
+    BytesLexicoder lexicoder = new BytesLexicoder();
+    assertDecodesB(lexicoder, new byte[0]);
+    assertDecodesB(lexicoder, "accumulo".getBytes());
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DateLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DateLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DateLexicoderTest.java
new file mode 100644
index 0000000..98d3ed1
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DateLexicoderTest.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder;
+
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
+import java.util.Date;
+
+public class DateLexicoderTest extends AbstractLexicoderTest {
+
+  public void testDecode() throws Exception {
+    assertDecodes(new DateLexicoder(), new Date());
+    assertDecodes(new DateLexicoder(), new Date(0));
+    assertDecodes(new DateLexicoder(), new Date(Long.MAX_VALUE));
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoderTest.java
index fc37f04..1b082b4 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/DoubleLexicoderTest.java
@@ -16,12 +16,14 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.util.Arrays;
 
 /**
  *
  */
-public class DoubleLexicoderTest extends LexicoderTest {
+public class DoubleLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
     assertSortOrder(new DoubleLexicoder(), Arrays.asList(Double.MIN_VALUE, Double.MAX_VALUE, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0.0, 0.01,
         0.001, 1.0, -1.0, -1.1, -1.01, Math.nextUp(Double.NEGATIVE_INFINITY), Math.nextAfter(0.0, Double.NEGATIVE_INFINITY),
@@ -29,4 +31,14 @@ public class DoubleLexicoderTest extends LexicoderTest {
         Math.pow(10.0, -30.0)));
 
   }
+
+  public void testDecode() {
+    assertDecodes(new DoubleLexicoder(), Double.MIN_VALUE);
+    assertDecodes(new DoubleLexicoder(), -1.0);
+    assertDecodes(new DoubleLexicoder(), -Math.pow(10.0, -30.0));
+    assertDecodes(new DoubleLexicoder(), 0.0);
+    assertDecodes(new DoubleLexicoder(), Math.pow(10.0, -30.0));
+    assertDecodes(new DoubleLexicoder(), 1.0);
+    assertDecodes(new DoubleLexicoder(), Double.MAX_VALUE);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoderTest.java
index 0af4792..4ca9235 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/IntegerLexicoderTest.java
@@ -16,11 +16,21 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.util.Arrays;
 
-public class IntegerLexicoderTest extends LexicoderTest {
+public class IntegerLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
     assertSortOrder(new IntegerLexicoder(),
         Arrays.asList(Integer.MIN_VALUE, 0xff123456, 0xffff3456, 0xffffff56, -1, 0, 1, 0x12, 0x1234, 0x123456, 0x1234678, Integer.MAX_VALUE));
   }
+
+  public void testDecode() {
+    assertDecodes(new IntegerLexicoder(), Integer.MIN_VALUE);
+    assertDecodes(new IntegerLexicoder(), -1);
+    assertDecodes(new IntegerLexicoder(), 0);
+    assertDecodes(new IntegerLexicoder(), 1);
+    assertDecodes(new IntegerLexicoder(), Integer.MAX_VALUE);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LexicoderTest.java
index 4b798b6..6d06f97 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LexicoderTest.java
@@ -16,19 +16,18 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import junit.framework.TestCase;
+import org.apache.accumulo.core.util.TextUtil;
+import org.apache.hadoop.io.Text;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
-import junit.framework.TestCase;
-
-import org.apache.accumulo.core.util.TextUtil;
-import org.apache.hadoop.io.Text;
-
 public abstract class LexicoderTest extends TestCase {
 
-  void assertEqualsB(byte[] ba1, byte[] ba2) {
+  protected void assertEqualsB(byte[] ba1, byte[] ba2) {
     assertEquals(new Text(ba2), new Text(ba1));
   }
 
@@ -61,4 +60,24 @@ public abstract class LexicoderTest extends TestCase {
     assertSortOrder(lexicoder, null, data);
   }
 
+  public static final byte[] START_PAD = "start".getBytes();
+  public static final byte[] END_PAD = "end".getBytes();
+
+  /** Asserts a value can be encoded and decoded back to original value */
+  public static <T> void assertDecodes(Lexicoder<T> lexicoder, T expected) {
+    byte[] encoded = lexicoder.encode(expected);
+
+    // decode full array
+    T result = lexicoder.decode(encoded);
+    assertEquals(expected, result);
+  }
+
+  public void assertDecodesB(Lexicoder<byte[]> lexicoder, byte[] expected) {
+    byte[] encoded = lexicoder.encode(expected);
+
+    // decode full array
+    byte[] result = lexicoder.decode(encoded);
+    assertEqualsB(expected, result);
+  }
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ListLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ListLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ListLexicoderTest.java
index 60a9f79..41084e6 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ListLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ListLexicoderTest.java
@@ -16,35 +16,40 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+import org.apache.accumulo.core.util.TextUtil;
+import org.apache.hadoop.io.Text;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.TreeSet;
 
-import org.apache.accumulo.core.util.TextUtil;
-import org.apache.hadoop.io.Text;
+public class ListLexicoderTest extends AbstractLexicoderTest {
+
+  private List<Long> data1 = new ArrayList<Long>();
+  private List<Long> data2 = new ArrayList<Long>();
+  private List<Long> data3 = new ArrayList<Long>();
+  private List<Long> data4 = new ArrayList<Long>();
+  private List<Long> data5 = new ArrayList<Long>();
+
+  public void setUp() {
 
-public class ListLexicoderTest extends LexicoderTest {
-  public void testSortOrder() {
-    List<Long> data1 = new ArrayList<Long>();
     data1.add(1l);
     data1.add(2l);
 
-    List<Long> data2 = new ArrayList<Long>();
     data2.add(1l);
 
-    List<Long> data3 = new ArrayList<Long>();
     data3.add(1l);
     data3.add(3l);
 
-    List<Long> data4 = new ArrayList<Long>();
     data4.add(1l);
     data4.add(2l);
     data4.add(3l);
 
-    List<Long> data5 = new ArrayList<Long>();
     data5.add(2l);
     data5.add(1l);
-
+  }
+  public void testSortOrder() {
     List<List<Long>> data = new ArrayList<List<Long>>();
 
     // add list in expected sort order
@@ -71,4 +76,12 @@ public class ListLexicoderTest extends LexicoderTest {
     assertEquals(data, unenc);
 
   }
+
+  public void testDecodes() {
+    assertDecodes(new ListLexicoder<Long>(new LongLexicoder()), data1);
+    assertDecodes(new ListLexicoder<Long>(new LongLexicoder()), data2);
+    assertDecodes(new ListLexicoder<Long>(new LongLexicoder()), data3);
+    assertDecodes(new ListLexicoder<Long>(new LongLexicoder()), data4);
+    assertDecodes(new ListLexicoder<Long>(new LongLexicoder()), data5);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LongLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LongLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LongLexicoderTest.java
index bf9a3a7..c1e2d41 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LongLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/LongLexicoderTest.java
@@ -16,13 +16,24 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.util.Arrays;
 
-public class LongLexicoderTest extends LexicoderTest {
+public class LongLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
 
     assertSortOrder(new LongLexicoder(), Arrays.asList(Long.MIN_VALUE, 0xff1234567890abcdl, 0xffff1234567890abl, 0xffffff567890abcdl, 0xffffffff7890abcdl,
         0xffffffffff90abcdl, 0xffffffffffffabcdl, 0xffffffffffffffcdl, -1l, 0l, 0x01l, 0x1234l, 0x123456l, 0x12345678l, 0x1234567890l, 0x1234567890abl,
         0x1234567890abcdl, 0x1234567890abcdefl, Long.MAX_VALUE));
   }
+
+  public void testDecodes() {
+    assertDecodes(new LongLexicoder(), Long.MIN_VALUE);
+    assertDecodes(new LongLexicoder(), -1l);
+    assertDecodes(new LongLexicoder(), 0l);
+    assertDecodes(new LongLexicoder(), 1l);
+    assertDecodes(new LongLexicoder(), 2l);
+    assertDecodes(new LongLexicoder(), Long.MAX_VALUE);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/PairLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/PairLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/PairLexicoderTest.java
index 434a603..0979801 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/PairLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/PairLexicoderTest.java
@@ -16,14 +16,15 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
-import java.util.Arrays;
-
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
 import org.apache.accumulo.core.util.ComparablePair;
 
+import java.util.Arrays;
+
 /**
  *
  */
-public class PairLexicoderTest extends LexicoderTest {
+public class PairLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
     PairLexicoder<String,String> plexc = new PairLexicoder<String,String>(new StringLexicoder(), new StringLexicoder());
 
@@ -36,4 +37,9 @@ public class PairLexicoderTest extends LexicoderTest {
     assertSortOrder(plexc2, Arrays.asList(new ComparablePair<Long,String>(0x100l, "a"), new ComparablePair<Long,String>(0x100l, "ab"),
         new ComparablePair<Long,String>(0xf0l, "a"), new ComparablePair<Long,String>(0xf0l, "ab")));
   }
+
+  public void testDecodes() {
+    PairLexicoder<String,String> plexc = new PairLexicoder<String,String>(new StringLexicoder(), new StringLexicoder());
+    assertDecodes(plexc, new ComparablePair<String,String>("a", "b"));
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoderTest.java
index bde8a3f..a49409f 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ReverseLexicoderTest.java
@@ -16,6 +16,9 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+import org.junit.Test;
+
 import java.io.UnsupportedEncodingException;
 import java.util.Arrays;
 import java.util.Calendar;
@@ -23,9 +26,7 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.Date;
 
-import org.junit.Test;
-
-public class ReverseLexicoderTest extends LexicoderTest {
+public class ReverseLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
     Comparator<Long> comp = Collections.reverseOrder();
     assertSortOrder(new ReverseLexicoder<Long>(new LongLexicoder()), comp, Arrays.asList(Long.MIN_VALUE, 0xff1234567890abcdl, 0xffff1234567890abl,
@@ -62,4 +63,12 @@ public class ReverseLexicoderTest extends LexicoderTest {
     System.out.println(date);
 
   }
+
+  public void testDecodes() {
+    assertDecodes(new ReverseLexicoder<Long>(new LongLexicoder()), Long.MIN_VALUE);
+    assertDecodes(new ReverseLexicoder<Long>(new LongLexicoder()), -1l);
+    assertDecodes(new ReverseLexicoder<Long>(new LongLexicoder()), 0l);
+    assertDecodes(new ReverseLexicoder<Long>(new LongLexicoder()), 1l);
+    assertDecodes(new ReverseLexicoder<Long>(new LongLexicoder()), Long.MAX_VALUE);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/StringLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/StringLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/StringLexicoderTest.java
new file mode 100644
index 0000000..686ee46
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/StringLexicoderTest.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder;
+
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
+public class StringLexicoderTest extends AbstractLexicoderTest {
+
+  public void testDecode() throws Exception {
+    assertDecodes(new StringLexicoder(), "");
+    assertDecodes(new StringLexicoder(), "0");
+    assertDecodes(new StringLexicoder(), "accumulo");
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/TextLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/TextLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/TextLexicoderTest.java
new file mode 100644
index 0000000..74558de
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/TextLexicoderTest.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder;
+
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+import org.apache.hadoop.io.Text;
+
+public class TextLexicoderTest extends AbstractLexicoderTest {
+
+  public void testDecode() throws Exception {
+    assertDecodes(new TextLexicoder(), new Text(""));
+    assertDecodes(new TextLexicoder(), new Text("accumulo"));
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoderTest.java
index bd59237..8c33d98 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UIntegerLexicoderTest.java
@@ -16,7 +16,9 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
-public class UIntegerLexicoderTest extends LexicoderTest {
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
+public class UIntegerLexicoderTest extends AbstractLexicoderTest {
   public void testEncoding() {
     UIntegerLexicoder uil = new UIntegerLexicoder();
 
@@ -30,4 +32,12 @@ public class UIntegerLexicoderTest extends LexicoderTest {
     assertEqualsB(uil.encode(0xffffff04), new byte[] {0x07, 0x04});
     assertEqualsB(uil.encode(-1), new byte[] {0x08});
   }
+
+  public void testDecode() {
+    assertDecodes(new UIntegerLexicoder(), Integer.MIN_VALUE);
+    assertDecodes(new UIntegerLexicoder(), -1);
+    assertDecodes(new UIntegerLexicoder(), 0);
+    assertDecodes(new UIntegerLexicoder(), 1);
+    assertDecodes(new UIntegerLexicoder(), Integer.MAX_VALUE);
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoderTest.java
index acf0fb3..bca8b1d 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/ULongLexicoderTest.java
@@ -16,9 +16,11 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.util.Arrays;
 
-public class ULongLexicoderTest extends LexicoderTest {
+public class ULongLexicoderTest extends AbstractLexicoderTest {
 
   public void testEncoding() {
     ULongLexicoder ull = new ULongLexicoder();
@@ -50,4 +52,13 @@ public class ULongLexicoderTest extends LexicoderTest {
         Arrays.asList(0l, 0x01l, 0x1234l, 0x123456l, 0x12345678l, 0x1234567890l, 0x1234567890abl, 0x1234567890abcdl, 0x1234567890abcdefl, Long.MAX_VALUE));
   }
 
+  public void testDecodes() {
+    assertDecodes(new ULongLexicoder(), Long.MIN_VALUE);
+    assertDecodes(new ULongLexicoder(), -1l);
+    assertDecodes(new ULongLexicoder(), 0l);
+    assertDecodes(new ULongLexicoder(), 1l);
+    assertDecodes(new ULongLexicoder(), 2l);
+    assertDecodes(new ULongLexicoder(), Long.MAX_VALUE);
+  }
+
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoderTest.java
index 26c1476..60c89a3 100644
--- a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoderTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/UUIDLexicoderTest.java
@@ -16,11 +16,13 @@
  */
 package org.apache.accumulo.core.client.lexicoder;
 
+import org.apache.accumulo.core.client.lexicoder.impl.AbstractLexicoderTest;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.UUID;
 
-public class UUIDLexicoderTest extends LexicoderTest {
+public class UUIDLexicoderTest extends AbstractLexicoderTest {
   public void testSortOrder() {
 
     assertSortOrder(new UUIDLexicoder(),
@@ -36,4 +38,9 @@ public class UUIDLexicoderTest extends LexicoderTest {
 
     assertSortOrder(new UUIDLexicoder(), uuids);
   }
+
+  public void testDecodes() {
+    assertDecodes(new UUIDLexicoder(), UUID.randomUUID());
+
+  }
 }

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoderTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoderTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoderTest.java
new file mode 100644
index 0000000..502d132
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/AbstractLexicoderTest.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder.impl;
+
+import org.apache.accumulo.core.client.lexicoder.LexicoderTest;
+import org.apache.commons.lang.ArrayUtils;
+
+/**
+ * Assists in Testing classes that extend {@link org.apache.accumulo.core.client.lexicoder.AbstractEncoder}.  It
+ * references methods not formally defined in the {@link org.apache.accumulo.core.client.lexicoder.Lexicoder} interface.
+ * @since 1.7.0
+ */
+public abstract class AbstractLexicoderTest extends LexicoderTest {
+
+  public static <T> void assertDecodes(AbstractLexicoder<T> lexicoder, T expected) {
+    LexicoderTest.assertDecodes(lexicoder, expected);
+
+    byte[] encoded = lexicoder.encode(expected);
+
+    assertOutOfBoundsFails(lexicoder, encoded);
+
+    // munge bytes at start and end, then use offset and length to decode
+    final byte[] combined = ArrayUtils.addAll(ArrayUtils.addAll(START_PAD, encoded), END_PAD);
+
+    int offset = START_PAD.length;
+    int len = encoded.length;
+    T result = lexicoder.decode(combined, offset, len);
+    assertEquals(expected, result);
+  }
+
+  public void assertDecodesB(AbstractLexicoder<byte[]> lexicoder, byte[] expected) {
+    super.assertDecodesB(lexicoder, expected);
+
+    byte[] encoded = lexicoder.encode(expected);
+
+    assertOutOfBoundsFails(lexicoder, encoded);
+
+    // munge bytes at start and end, then use offset and length to decode
+    final byte[] combined = ArrayUtils.addAll(ArrayUtils.addAll(START_PAD, encoded), END_PAD);
+
+    int offset = START_PAD.length;
+    int len = encoded.length;
+    byte[] result = lexicoder.decode(combined, offset, len);
+    assertEqualsB(expected, result);
+  }
+
+  protected static <T> void assertOutOfBoundsFails(AbstractLexicoder<T> lexicoder, byte[] encoded) {
+    // decode null; should fail
+    try {
+      lexicoder.decode(null, 0, encoded.length);
+      fail("Should throw on null bytes.");
+    } catch (NullPointerException e) {}
+
+    // decode out of bounds, expect an exception
+    try {
+      lexicoder.decode(encoded, 0, encoded.length + 1);
+      fail("Should throw on exceeding length.");
+    } catch (IllegalArgumentException e) {}
+
+    try {
+      lexicoder.decode(encoded, -1, encoded.length);
+      fail("Should throw on negative offset.");
+    } catch (IllegalArgumentException e) {}
+
+    try {
+      lexicoder.decode(encoded, encoded.length, 0);
+      fail("Should throw on offset==length.");
+    } catch (IllegalArgumentException e) {}
+
+    try {
+      lexicoder.decode(encoded, 0, -1);
+      fail("Should throw on negative length.");
+    } catch (IllegalArgumentException e) {}
+
+    try {
+      lexicoder.decode(encoded, 1, -1);
+      fail("Should throw on negative length, even if (offset+len) is within bounds.");
+    } catch (IllegalArgumentException e) {}
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtilsTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtilsTest.java b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtilsTest.java
new file mode 100644
index 0000000..1304797
--- /dev/null
+++ b/core/src/test/java/org/apache/accumulo/core/client/lexicoder/impl/ByteUtilsTest.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.core.client.lexicoder.impl;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ByteUtilsTest {
+
+  private final byte[] empty = new byte[0];
+  private final byte[] noSplits = "nosplits".getBytes();
+  private final byte[] splitAt5 = ("1234" + (char)0x00 + "56789").getBytes();
+
+  @Test
+  public void testSplit() throws Exception {
+    byte[][] result;
+
+    // always returns the original array itself
+    result = ByteUtils.split(empty);
+    Assert.assertEquals(1, result.length);
+    Assert.assertArrayEquals(empty, result[0]);
+
+    result = ByteUtils.split(noSplits);
+    Assert.assertEquals(1, result.length);
+    Assert.assertArrayEquals(noSplits, result[0]);
+
+    result = ByteUtils.split(splitAt5);
+    Assert.assertEquals(2, result.length);
+    Assert.assertArrayEquals("1234".getBytes(), result[0]);
+    Assert.assertArrayEquals("56789".getBytes(), result[1]);
+  }
+
+  public void testSplitWithOffset() {
+    int offset;
+    byte[][] result;
+
+    // still see both splits
+    offset = 4;
+    result = ByteUtils.split(splitAt5, offset, splitAt5.length - offset);
+    Assert.assertEquals(2, result.length);
+    Assert.assertArrayEquals(empty, result[0]);
+    Assert.assertArrayEquals("56789".getBytes(), result[1]);
+
+    // should only see 1 split at this offset
+    offset = 5;
+    result = ByteUtils.split(splitAt5, offset, splitAt5.length - offset);
+    Assert.assertEquals(1, result.length);
+    Assert.assertArrayEquals("56789".getBytes(), result[0]);
+
+    // still one split, but smaller ending
+    offset = 5;
+    int len = splitAt5.length - offset - 1;
+    result = ByteUtils.split(splitAt5, offset, len);
+    Assert.assertEquals(1, result.length);
+    Assert.assertArrayEquals("5678".getBytes(), result[0]);
+  }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/core/src/test/java/org/apache/accumulo/core/iterators/user/CombinerTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/accumulo/core/iterators/user/CombinerTest.java b/core/src/test/java/org/apache/accumulo/core/iterators/user/CombinerTest.java
index cdac2fb..26326a5 100644
--- a/core/src/test/java/org/apache/accumulo/core/iterators/user/CombinerTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/iterators/user/CombinerTest.java
@@ -746,6 +746,10 @@ public class CombinerTest {
       return new ArrayList<Long>();
     }
 
+    public List<Long> decode(byte[] b, int offset, int len) {
+      return new ArrayList<Long>();
+    }
+
   }
 
   @Test

http://git-wip-us.apache.org/repos/asf/accumulo/blob/6b94344d/server/base/src/main/java/org/apache/accumulo/server/replication/StatusCombiner.java
----------------------------------------------------------------------
diff --git a/server/base/src/main/java/org/apache/accumulo/server/replication/StatusCombiner.java b/server/base/src/main/java/org/apache/accumulo/server/replication/StatusCombiner.java
index 5317c4d..e4c90a4 100644
--- a/server/base/src/main/java/org/apache/accumulo/server/replication/StatusCombiner.java
+++ b/server/base/src/main/java/org/apache/accumulo/server/replication/StatusCombiner.java
@@ -20,6 +20,8 @@ import java.io.IOException;
 import java.util.Iterator;
 import java.util.Map;
 
+import com.google.common.base.Preconditions;
+import org.apache.accumulo.core.client.lexicoder.AbstractEncoder;
 import org.apache.accumulo.core.data.Key;
 import org.apache.accumulo.core.data.Value;
 import org.apache.accumulo.core.iterators.IteratorEnvironment;
@@ -41,7 +43,7 @@ import com.google.protobuf.InvalidProtocolBufferException;
 public class StatusCombiner extends TypedValueCombiner<Status> {
   private static final Logger log = Logger.getLogger(StatusCombiner.class);
 
-  public static class StatusEncoder implements Encoder<Status> {
+  public static class StatusEncoder extends AbstractEncoder<Status> implements Encoder<Status> {
     private static final Logger log = Logger.getLogger(StatusEncoder.class);
 
     @Override
@@ -50,7 +52,9 @@ public class StatusCombiner extends TypedValueCombiner<Status> {
     }
 
     @Override
-    public Status decode(byte[] b) throws ValueFormatException {
+    public Status decode(byte[] b) {
+      // Override super because it calls decodeUnchecked, which is not as performant
+      Preconditions.checkNotNull(b, "cannot decode null byte array");
       try {
         return Status.parseFrom(b);
       } catch (InvalidProtocolBufferException e) {
@@ -58,6 +62,22 @@ public class StatusCombiner extends TypedValueCombiner<Status> {
         throw new ValueFormatException(e);
       }
     }
+
+    /**
+     * Makes a copy of the subarray of {@code b}, then passes it through {@link Status#parseFrom(byte[])}
+     */
+    @Override
+    protected Status decodeUnchecked(byte[] b, int offset, int len) throws ValueFormatException {
+      try {
+        // have to make a copy because Status lacks the method to do this efficiently
+        byte[] boundedArr = new byte[len];
+        System.arraycopy(b, offset, boundedArr, 0, len);
+        return Status.parseFrom(boundedArr);
+      } catch (InvalidProtocolBufferException e) {
+        log.error("Failed to parse Status protocol buffer", e);
+        throw new ValueFormatException(e);
+      }
+    }
   }
 
   @Override


Mime
View raw message