accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From e..@apache.org
Subject [06/13] git commit: ACCUMULO-1986 merge to 1.5.1-SNAPSHOT
Date Wed, 18 Dec 2013 14:53:36 GMT
ACCUMULO-1986 merge to 1.5.1-SNAPSHOT


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

Branch: refs/heads/master
Commit: a5e3ed3bb249d287d67f9079297ee5936ac2c914
Parents: 144d9d5 adee0f1
Author: Eric Newton <eric.newton@gmail.com>
Authored: Wed Dec 18 09:38:17 2013 -0500
Committer: Eric Newton <eric.newton@gmail.com>
Committed: Wed Dec 18 09:38:17 2013 -0500

----------------------------------------------------------------------
 .../java/org/apache/accumulo/core/data/Key.java |  13 ++
 .../org/apache/accumulo/core/data/KeyTest.java  |  30 +++-
 .../apache/accumulo/core/data/MutationTest.java | 143 ++++++++++++-------
 .../apache/accumulo/core/data/OldMutation.java  |   7 +
 4 files changed, 136 insertions(+), 57 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/a5e3ed3b/core/src/main/java/org/apache/accumulo/core/data/Key.java
----------------------------------------------------------------------
diff --cc core/src/main/java/org/apache/accumulo/core/data/Key.java
index de9e22d,0000000..4b6867f
mode 100644,000000..100644
--- a/core/src/main/java/org/apache/accumulo/core/data/Key.java
+++ b/core/src/main/java/org/apache/accumulo/core/data/Key.java
@@@ -1,850 -1,0 +1,863 @@@
 +/*
 + * 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.data;
 +
 +/**
 + * This is the Key used to store and access individual values in Accumulo.  A Key is a tuple composed of a row, column family, column qualifier, 
 + * column visibility, timestamp, and delete marker.
 + * 
 + * Keys are comparable and therefore have a sorted order defined by {@link #compareTo(Key)}.
 + * 
 + */
 +
 +import static org.apache.accumulo.core.util.ByteBufferUtil.toBytes;
 +
 +import java.io.DataInput;
 +import java.io.DataOutput;
 +import java.io.IOException;
 +import java.nio.ByteBuffer;
 +import java.util.Arrays;
 +import java.util.List;
 +
 +import org.apache.accumulo.core.Constants;
 +import org.apache.accumulo.core.data.thrift.TKey;
 +import org.apache.accumulo.core.data.thrift.TKeyValue;
 +import org.apache.accumulo.core.security.ColumnVisibility;
 +import org.apache.hadoop.io.Text;
 +import org.apache.hadoop.io.WritableComparable;
 +import org.apache.hadoop.io.WritableComparator;
 +import org.apache.hadoop.io.WritableUtils;
 +
 +public class Key implements WritableComparable<Key>, Cloneable {
 +  
 +  protected byte[] row;
 +  protected byte[] colFamily;
 +  protected byte[] colQualifier;
 +  protected byte[] colVisibility;
 +  protected long timestamp;
 +  protected boolean deleted;
 +  
 +  @Override
 +  public boolean equals(Object o) {
 +    if (o instanceof Key)
 +      return this.equals((Key) o, PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL);
 +    return false;
 +  }
 +  
 +  private static final byte EMPTY_BYTES[] = new byte[0];
 +  
 +  private byte[] copyIfNeeded(byte ba[], int off, int len, boolean copyData) {
 +    if (len == 0)
 +      return EMPTY_BYTES;
 +    
 +    if (!copyData && ba.length == len && off == 0)
 +      return ba;
 +    
 +    byte[] copy = new byte[len];
 +    System.arraycopy(ba, off, copy, 0, len);
 +    return copy;
 +  }
 +  
 +  private final void init(byte r[], int rOff, int rLen, byte cf[], int cfOff, int cfLen, byte cq[], int cqOff, int cqLen, byte cv[], int cvOff, int cvLen,
 +      long ts, boolean del, boolean copy) {
 +    row = copyIfNeeded(r, rOff, rLen, copy);
 +    colFamily = copyIfNeeded(cf, cfOff, cfLen, copy);
 +    colQualifier = copyIfNeeded(cq, cqOff, cqLen, copy);
 +    colVisibility = copyIfNeeded(cv, cvOff, cvLen, copy);
 +    timestamp = ts;
 +    deleted = del;
 +  }
 +  
 +  /**
 +   * Creates a key with empty row, empty column family, empty column qualifier, empty column visibility, timestamp {@link Long#MAX_VALUE}, and delete marker
 +   * false.
 +   */
 +  public Key() {
 +    row = EMPTY_BYTES;
 +    colFamily = EMPTY_BYTES;
 +    colQualifier = EMPTY_BYTES;
 +    colVisibility = EMPTY_BYTES;
 +    timestamp = Long.MAX_VALUE;
 +    deleted = false;
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, empty column family, empty column qualifier, empty column visibility, timestamp {@link Long#MAX_VALUE}, and delete
 +   * marker false.
 +   */
 +  public Key(Text row) {
 +    init(row.getBytes(), 0, row.getLength(), EMPTY_BYTES, 0, 0, EMPTY_BYTES, 0, 0, EMPTY_BYTES, 0, 0, Long.MAX_VALUE, false, true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, empty column family, empty column qualifier, empty column visibility, the specified timestamp, and delete marker
 +   * false.
 +   */
 +  public Key(Text row, long ts) {
 +    this(row);
 +    timestamp = ts;
 +  }
 +  
 +  public Key(byte row[], int rOff, int rLen, byte cf[], int cfOff, int cfLen, byte cq[], int cqOff, int cqLen, byte cv[], int cvOff, int cvLen, long ts) {
 +    init(row, rOff, rLen, cf, cfOff, cfLen, cq, cqOff, cqLen, cv, cvOff, cvLen, ts, false, true);
 +  }
 +  
 +  public Key(byte[] row, byte[] colFamily, byte[] colQualifier, byte[] colVisibility, long timestamp) {
 +    this(row, colFamily, colQualifier, colVisibility, timestamp, false, true);
 +  }
 +  
 +  public Key(byte[] row, byte[] cf, byte[] cq, byte[] cv, long ts, boolean deleted) {
 +    this(row, cf, cq, cv, ts, deleted, true);
 +  }
 +  
 +  public Key(byte[] row, byte[] cf, byte[] cq, byte[] cv, long ts, boolean deleted, boolean copy) {
 +    init(row, 0, row.length, cf, 0, cf.length, cq, 0, cq.length, cv, 0, cv.length, ts, deleted, copy);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, empty column qualifier, empty column visibility, timestamp {@link Long#MAX_VALUE}, and
 +   * delete marker false.
 +   */
 +  public Key(Text row, Text cf) {
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), EMPTY_BYTES, 0, 0, EMPTY_BYTES, 0, 0, Long.MAX_VALUE, false, true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, the specified column qualifier, empty column visibility, timestamp
 +   * {@link Long#MAX_VALUE}, and delete marker false.
 +   */
 +  public Key(Text row, Text cf, Text cq) {
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), cq.getBytes(), 0, cq.getLength(), EMPTY_BYTES, 0, 0, Long.MAX_VALUE, false, true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, the specified column qualifier, the specified column visibility, timestamp
 +   * {@link Long#MAX_VALUE}, and delete marker false.
 +   */
 +  public Key(Text row, Text cf, Text cq, Text cv) {
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), cq.getBytes(), 0, cq.getLength(), cv.getBytes(), 0, cv.getLength(),
 +        Long.MAX_VALUE, false, true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, the specified column qualifier, empty column visibility, the specified timestamp, and
 +   * delete marker false.
 +   */
 +  public Key(Text row, Text cf, Text cq, long ts) {
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), cq.getBytes(), 0, cq.getLength(), EMPTY_BYTES, 0, 0, ts, false, true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, the specified column qualifier, the specified column visibility, the specified
 +   * timestamp, and delete marker false.
 +   */
 +  public Key(Text row, Text cf, Text cq, Text cv, long ts) {
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), cq.getBytes(), 0, cq.getLength(), cv.getBytes(), 0, cv.getLength(), ts, false,
 +        true);
 +  }
 +  
 +  /**
 +   * Creates a key with the specified row, the specified column family, the specified column qualifier, the specified column visibility, the specified
 +   * timestamp, and delete marker false.
 +   */
 +  public Key(Text row, Text cf, Text cq, ColumnVisibility cv, long ts) {
 +    byte[] expr = cv.getExpression();
 +    init(row.getBytes(), 0, row.getLength(), cf.getBytes(), 0, cf.getLength(), cq.getBytes(), 0, cq.getLength(), expr, 0, expr.length, ts, false, true);
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text)}.
 +   */
 +  public Key(CharSequence row) {
 +    this(new Text(row.toString()));
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf) {
 +    this(new Text(row.toString()), new Text(cf.toString()));
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text,Text)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf, CharSequence cq) {
 +    this(new Text(row.toString()), new Text(cf.toString()), new Text(cq.toString()));
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text,Text,Text)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf, CharSequence cq, CharSequence cv) {
 +    this(new Text(row.toString()), new Text(cf.toString()), new Text(cq.toString()), new Text(cv.toString()));
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text,Text,long)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf, CharSequence cq, long ts) {
 +    this(new Text(row.toString()), new Text(cf.toString()), new Text(cq.toString()), ts);
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text,Text,Text,long)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf, CharSequence cq, CharSequence cv, long ts) {
 +    this(new Text(row.toString()), new Text(cf.toString()), new Text(cq.toString()), new Text(cv.toString()), ts);
 +  }
 +  
 +  /**
 +   * Converts CharSequence to Text and creates a Key using {@link #Key(Text,Text,Text,ColumnVisibility,long)}.
 +   */
 +  public Key(CharSequence row, CharSequence cf, CharSequence cq, ColumnVisibility cv, long ts) {
 +    this(new Text(row.toString()), new Text(cf.toString()), new Text(cq.toString()), new Text(cv.getExpression()), ts);
 +  }
 +  
 +  private byte[] followingArray(byte ba[]) {
 +    byte[] fba = new byte[ba.length + 1];
 +    System.arraycopy(ba, 0, fba, 0, ba.length);
 +    fba[ba.length] = (byte) 0x00;
 +    return fba;
 +  }
 +  
 +  /**
 +   * Returns a key that will sort immediately after this key.
 +   * 
 +   * @param part
 +   *          PartialKey except {@link PartialKey#ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL}
 +   */
 +  public Key followingKey(PartialKey part) {
 +    Key returnKey = new Key();
 +    switch (part) {
 +      case ROW:
 +        returnKey.row = followingArray(row);
 +        break;
 +      case ROW_COLFAM:
 +        returnKey.row = row;
 +        returnKey.colFamily = followingArray(colFamily);
 +        break;
 +      case ROW_COLFAM_COLQUAL:
 +        returnKey.row = row;
 +        returnKey.colFamily = colFamily;
 +        returnKey.colQualifier = followingArray(colQualifier);
 +        break;
 +      case ROW_COLFAM_COLQUAL_COLVIS:
 +        // This isn't useful for inserting into accumulo, but may be useful for lookups.
 +        returnKey.row = row;
 +        returnKey.colFamily = colFamily;
 +        returnKey.colQualifier = colQualifier;
 +        returnKey.colVisibility = followingArray(colVisibility);
 +        break;
 +      case ROW_COLFAM_COLQUAL_COLVIS_TIME:
 +        returnKey.row = row;
 +        returnKey.colFamily = colFamily;
 +        returnKey.colQualifier = colQualifier;
 +        returnKey.colVisibility = colVisibility;
 +        returnKey.setTimestamp(timestamp - 1);
 +        returnKey.deleted = false;
 +        break;
 +      default:
 +        throw new IllegalArgumentException("Partial key specification " + part + " disallowed");
 +    }
 +    return returnKey;
 +  }
 +  
 +  /**
 +   * Creates a key with the same row, column family, column qualifier, column visibility, timestamp, and delete marker as the given key.
 +   */
 +  public Key(Key other) {
 +    set(other);
 +  }
 +  
 +  public Key(TKey tkey) {
 +    this.row = toBytes(tkey.row);
 +    this.colFamily = toBytes(tkey.colFamily);
 +    this.colQualifier = toBytes(tkey.colQualifier);
 +    this.colVisibility = toBytes(tkey.colVisibility);
 +    this.timestamp = tkey.timestamp;
 +    this.deleted = false;
++
++    if (row == null) {
++      throw new IllegalArgumentException("null row");
++    }
++    if (colFamily == null) {
++      throw new IllegalArgumentException("null column family");
++    }
++    if (colQualifier == null) {
++      throw new IllegalArgumentException("null column qualifier");
++    }
++    if (colVisibility == null) {
++      throw new IllegalArgumentException("null column visibility");
++    }
 +  }
 +  
 +  /**
 +   * This method gives users control over allocation of Text objects by copying into the passed in text.
 +   * 
 +   * @param r
 +   *          the key's row will be copied into this Text
 +   * @return the Text that was passed in
 +   */
 +  
 +  public Text getRow(Text r) {
 +    r.set(row, 0, row.length);
 +    return r;
 +  }
 +  
 +  /**
 +   * This method returns a pointer to the keys internal data and does not copy it.
 +   * 
 +   * @return ByteSequence that points to the internal key row data.
 +   */
 +  
 +  public ByteSequence getRowData() {
 +    return new ArrayByteSequence(row);
 +  }
 +  
 +  /**
 +   * This method allocates a Text object and copies into it.
 +   * 
 +   * @return Text containing the row field
 +   */
 +  
 +  public Text getRow() {
 +    return getRow(new Text());
 +  }
 +  
 +  /**
 +   * Efficiently compare the the row of a key w/o allocating a text object and copying the row into it.
 +   * 
 +   * @param r
 +   *          row to compare to keys row
 +   * @return same as {@link #getRow()}.compareTo(r)
 +   */
 +  
 +  public int compareRow(Text r) {
 +    return WritableComparator.compareBytes(row, 0, row.length, r.getBytes(), 0, r.getLength());
 +  }
 +  
 +  /**
 +   * This method returns a pointer to the keys internal data and does not copy it.
 +   * 
 +   * @return ByteSequence that points to the internal key column family data.
 +   */
 +  
 +  public ByteSequence getColumnFamilyData() {
 +    return new ArrayByteSequence(colFamily);
 +  }
 +  
 +  /**
 +   * This method gives users control over allocation of Text objects by copying into the passed in text.
 +   * 
 +   * @param cf
 +   *          the key's column family will be copied into this Text
 +   * @return the Text that was passed in
 +   */
 +  
 +  public Text getColumnFamily(Text cf) {
 +    cf.set(colFamily, 0, colFamily.length);
 +    return cf;
 +  }
 +  
 +  /**
 +   * This method allocates a Text object and copies into it.
 +   * 
 +   * @return Text containing the column family field
 +   */
 +  
 +  public Text getColumnFamily() {
 +    return getColumnFamily(new Text());
 +  }
 +  
 +  /**
 +   * Efficiently compare the the column family of a key w/o allocating a text object and copying the column qualifier into it.
 +   * 
 +   * @param cf
 +   *          column family to compare to keys column family
 +   * @return same as {@link #getColumnFamily()}.compareTo(cf)
 +   */
 +  
 +  public int compareColumnFamily(Text cf) {
 +    return WritableComparator.compareBytes(colFamily, 0, colFamily.length, cf.getBytes(), 0, cf.getLength());
 +  }
 +  
 +  /**
 +   * This method returns a pointer to the keys internal data and does not copy it.
 +   * 
 +   * @return ByteSequence that points to the internal key column qualifier data.
 +   */
 +  
 +  public ByteSequence getColumnQualifierData() {
 +    return new ArrayByteSequence(colQualifier);
 +  }
 +  
 +  /**
 +   * This method gives users control over allocation of Text objects by copying into the passed in text.
 +   * 
 +   * @param cq
 +   *          the key's column qualifier will be copied into this Text
 +   * @return the Text that was passed in
 +   */
 +  
 +  public Text getColumnQualifier(Text cq) {
 +    cq.set(colQualifier, 0, colQualifier.length);
 +    return cq;
 +  }
 +  
 +  /**
 +   * This method allocates a Text object and copies into it.
 +   * 
 +   * @return Text containing the column qualifier field
 +   */
 +  
 +  public Text getColumnQualifier() {
 +    return getColumnQualifier(new Text());
 +  }
 +  
 +  /**
 +   * Efficiently compare the the column qualifier of a key w/o allocating a text object and copying the column qualifier into it.
 +   * 
 +   * @param cq
 +   *          column family to compare to keys column qualifier
 +   * @return same as {@link #getColumnQualifier()}.compareTo(cq)
 +   */
 +  
 +  public int compareColumnQualifier(Text cq) {
 +    return WritableComparator.compareBytes(colQualifier, 0, colQualifier.length, cq.getBytes(), 0, cq.getLength());
 +  }
 +  
 +  public void setTimestamp(long ts) {
 +    this.timestamp = ts;
 +  }
 +  
 +  public long getTimestamp() {
 +    return timestamp;
 +  }
 +  
 +  public boolean isDeleted() {
 +    return deleted;
 +  }
 +  
 +  public void setDeleted(boolean deleted) {
 +    this.deleted = deleted;
 +  }
 +  
 +  /**
 +   * This method returns a pointer to the keys internal data and does not copy it.
 +   * 
 +   * @return ByteSequence that points to the internal key column visibility data.
 +   */
 +  
 +  public ByteSequence getColumnVisibilityData() {
 +    return new ArrayByteSequence(colVisibility);
 +  }
 +  
 +  /**
 +   * This method allocates a Text object and copies into it.
 +   * 
 +   * @return Text containing the column visibility field
 +   */
 +  
 +  public final Text getColumnVisibility() {
 +    return getColumnVisibility(new Text());
 +  }
 +  
 +  /**
 +   * This method gives users control over allocation of Text objects by copying into the passed in text.
 +   * 
 +   * @param cv
 +   *          the key's column visibility will be copied into this Text
 +   * @return the Text that was passed in
 +   */
 +  
 +  public final Text getColumnVisibility(Text cv) {
 +    cv.set(colVisibility, 0, colVisibility.length);
 +    return cv;
 +  }
 +  
 +  /**
 +   * This method creates a new ColumnVisibility representing the column visibility for this key
 +   * 
 +   * WARNING: using this method may inhibit performance since a new ColumnVisibility object is created on every call.
 +   * 
 +   * @return A new object representing the column visibility field
 +   * @since 1.5.0
 +   */
 +  public final ColumnVisibility getColumnVisibilityParsed() {
 +    return new ColumnVisibility(colVisibility);
 +  }
 +  
 +  /**
 +   * Sets this key's row, column family, column qualifier, column visibility, timestamp, and delete marker to be the same as another key's.
 +   */
 +  public void set(Key k) {
 +    row = k.row;
 +    colFamily = k.colFamily;
 +    colQualifier = k.colQualifier;
 +    colVisibility = k.colVisibility;
 +    timestamp = k.timestamp;
 +    deleted = k.deleted;
 +    
 +  }
 +  
 +  public void readFields(DataInput in) throws IOException {
 +    // this method is a little screwy so it will be compatible with older
 +    // code that serialized data
 +    
 +    int colFamilyOffset = WritableUtils.readVInt(in);
 +    int colQualifierOffset = WritableUtils.readVInt(in);
 +    int colVisibilityOffset = WritableUtils.readVInt(in);
 +    int totalLen = WritableUtils.readVInt(in);
 +    
 +    row = new byte[colFamilyOffset];
 +    colFamily = new byte[colQualifierOffset - colFamilyOffset];
 +    colQualifier = new byte[colVisibilityOffset - colQualifierOffset];
 +    colVisibility = new byte[totalLen - colVisibilityOffset];
 +    
 +    in.readFully(row);
 +    in.readFully(colFamily);
 +    in.readFully(colQualifier);
 +    in.readFully(colVisibility);
 +    
 +    timestamp = WritableUtils.readVLong(in);
 +    deleted = in.readBoolean();
 +  }
 +  
 +  public void write(DataOutput out) throws IOException {
 +    
 +    int colFamilyOffset = row.length;
 +    int colQualifierOffset = colFamilyOffset + colFamily.length;
 +    int colVisibilityOffset = colQualifierOffset + colQualifier.length;
 +    int totalLen = colVisibilityOffset + colVisibility.length;
 +    
 +    WritableUtils.writeVInt(out, colFamilyOffset);
 +    WritableUtils.writeVInt(out, colQualifierOffset);
 +    WritableUtils.writeVInt(out, colVisibilityOffset);
 +    
 +    WritableUtils.writeVInt(out, totalLen);
 +    
 +    out.write(row);
 +    out.write(colFamily);
 +    out.write(colQualifier);
 +    out.write(colVisibility);
 +    
 +    WritableUtils.writeVLong(out, timestamp);
 +    out.writeBoolean(deleted);
 +  }
 +  
 +  /**
 +   * Compare part of a key. For example compare just the row and column family, and if those are equal then return true.
 +   * 
 +   */
 +  
 +  public boolean equals(Key other, PartialKey part) {
 +    switch (part) {
 +      case ROW:
 +        return isEqual(row, other.row);
 +      case ROW_COLFAM:
 +        return isEqual(row, other.row) && isEqual(colFamily, other.colFamily);
 +      case ROW_COLFAM_COLQUAL:
 +        return isEqual(row, other.row) && isEqual(colFamily, other.colFamily) && isEqual(colQualifier, other.colQualifier);
 +      case ROW_COLFAM_COLQUAL_COLVIS:
 +        return isEqual(row, other.row) && isEqual(colFamily, other.colFamily) && isEqual(colQualifier, other.colQualifier)
 +            && isEqual(colVisibility, other.colVisibility);
 +      case ROW_COLFAM_COLQUAL_COLVIS_TIME:
 +        return isEqual(row, other.row) && isEqual(colFamily, other.colFamily) && isEqual(colQualifier, other.colQualifier)
 +            && isEqual(colVisibility, other.colVisibility) && timestamp == other.timestamp;
 +      case ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL:
 +        return isEqual(row, other.row) && isEqual(colFamily, other.colFamily) && isEqual(colQualifier, other.colQualifier)
 +            && isEqual(colVisibility, other.colVisibility) && timestamp == other.timestamp && deleted == other.deleted;
 +      default:
 +        throw new IllegalArgumentException("Unrecognized partial key specification " + part);
 +    }
 +  }
 +  
 +  /**
 +   * Compare elements of a key given by a {@link PartialKey}. For example, for {@link PartialKey#ROW_COLFAM}, compare just the row and column family. If the
 +   * rows are not equal, return the result of the row comparison; otherwise, return the result of the column family comparison.
 +   * 
 +   * @see #compareTo(Key)
 +   */
 +  
 +  public int compareTo(Key other, PartialKey part) {
 +    // check for matching row
 +    int result = WritableComparator.compareBytes(row, 0, row.length, other.row, 0, other.row.length);
 +    if (result != 0 || part.equals(PartialKey.ROW))
 +      return result;
 +    
 +    // check for matching column family
 +    result = WritableComparator.compareBytes(colFamily, 0, colFamily.length, other.colFamily, 0, other.colFamily.length);
 +    if (result != 0 || part.equals(PartialKey.ROW_COLFAM))
 +      return result;
 +    
 +    // check for matching column qualifier
 +    result = WritableComparator.compareBytes(colQualifier, 0, colQualifier.length, other.colQualifier, 0, other.colQualifier.length);
 +    if (result != 0 || part.equals(PartialKey.ROW_COLFAM_COLQUAL))
 +      return result;
 +    
 +    // check for matching column visibility
 +    result = WritableComparator.compareBytes(colVisibility, 0, colVisibility.length, other.colVisibility, 0, other.colVisibility.length);
 +    if (result != 0 || part.equals(PartialKey.ROW_COLFAM_COLQUAL_COLVIS))
 +      return result;
 +    
 +    // check for matching timestamp
 +    if (timestamp < other.timestamp)
 +      result = 1;
 +    else if (timestamp > other.timestamp)
 +      result = -1;
 +    else
 +      result = 0;
 +    
 +    if (result != 0 || part.equals(PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME))
 +      return result;
 +    
 +    // check for matching deleted flag
 +    if (deleted)
 +      result = other.deleted ? 0 : -1;
 +    else
 +      result = other.deleted ? 1 : 0;
 +    
 +    return result;
 +  }
 +  
 +  /**
 +   * Compare all elements of a key. The elements (row, column family, column qualifier, column visibility, timestamp, and delete marker) are compared in order
 +   * until an unequal element is found. If the row is equal, then compare the column family, etc. The row, column family, column qualifier, and column
 +   * visibility are compared lexographically and sorted ascending. The timestamps are compared numerically and sorted descending so that the most recent data
 +   * comes first. Lastly, a delete marker of true sorts before a delete marker of false.
 +   */
 +  
 +  public int compareTo(Key other) {
 +    return compareTo(other, PartialKey.ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL);
 +  }
 +  
 +  @Override
 +  public int hashCode() {
 +    return WritableComparator.hashBytes(row, row.length) + WritableComparator.hashBytes(colFamily, colFamily.length)
 +        + WritableComparator.hashBytes(colQualifier, colQualifier.length) + WritableComparator.hashBytes(colVisibility, colVisibility.length)
 +        + (int) (timestamp ^ (timestamp >>> 32));
 +  }
 +  
 +  public static String toPrintableString(byte ba[], int offset, int len, int maxLen) {
 +    return appendPrintableString(ba, offset, len, maxLen, new StringBuilder()).toString();
 +  }
 +  
 +  public static StringBuilder appendPrintableString(byte ba[], int offset, int len, int maxLen, StringBuilder sb) {
 +    int plen = Math.min(len, maxLen);
 +    
 +    for (int i = 0; i < plen; i++) {
 +      int c = 0xff & ba[offset + i];
 +      if (c >= 32 && c <= 126)
 +        sb.append((char) c);
 +      else
 +        sb.append("%" + String.format("%02x;", c));
 +    }
 +    
 +    if (len > maxLen) {
 +      sb.append("... TRUNCATED");
 +    }
 +    
 +    return sb;
 +  }
 +  
 +  private StringBuilder rowColumnStringBuilder() {
 +    StringBuilder sb = new StringBuilder();
 +    appendPrintableString(row, 0, row.length, Constants.MAX_DATA_TO_PRINT, sb);
 +    sb.append(" ");
 +    appendPrintableString(colFamily, 0, colFamily.length, Constants.MAX_DATA_TO_PRINT, sb);
 +    sb.append(":");
 +    appendPrintableString(colQualifier, 0, colQualifier.length, Constants.MAX_DATA_TO_PRINT, sb);
 +    sb.append(" [");
 +    appendPrintableString(colVisibility, 0, colVisibility.length, Constants.MAX_DATA_TO_PRINT, sb);
 +    sb.append("]");
 +    return sb;
 +  }
 +  
 +  public String toString() {
 +    StringBuilder sb = rowColumnStringBuilder();
 +    sb.append(" ");
 +    sb.append(Long.toString(timestamp));
 +    sb.append(" ");
 +    sb.append(deleted);
 +    return sb.toString();
 +  }
 +  
 +  public String toStringNoTime() {
 +    return rowColumnStringBuilder().toString();
 +  }
 +  
 +  /**
 +   * Returns the sums of the lengths of the row, column family, column qualifier, and visibility.
 +   * 
 +   * @return row.length + colFamily.length + colQualifier.length + colVisibility.length;
 +   */
 +  public int getLength() {
 +    return row.length + colFamily.length + colQualifier.length + colVisibility.length;
 +  }
 +  
 +  /**
 +   * Same as {@link #getLength()}.
 +   */
 +  public int getSize() {
 +    return getLength();
 +  }
 +  
 +  private static boolean isEqual(byte a1[], byte a2[]) {
 +    if (a1 == a2)
 +      return true;
 +    
 +    int last = a1.length;
 +    
 +    if (last != a2.length)
 +      return false;
 +    
 +    if (last == 0)
 +      return true;
 +    
 +    // since sorted data is usually compared in accumulo,
 +    // the prefixes will normally be the same... so compare
 +    // the last two charachters first.. the most likely place
 +    // to have disorder is at end of the strings when the
 +    // data is sorted... if those are the same compare the rest
 +    // of the data forward... comparing backwards is slower
 +    // (compiler and cpu optimized for reading data forward)..
 +    // do not want slower comparisons when data is equal...
 +    // sorting brings equals data together
 +    
 +    last--;
 +    
 +    if (a1[last] == a2[last]) {
 +      for (int i = 0; i < last; i++)
 +        if (a1[i] != a2[i])
 +          return false;
 +    } else {
 +      return false;
 +    }
 +    
 +    return true;
 +    
 +  }
 +  
 +  /**
 +   * Use this to compress a list of keys before sending them via thrift.
 +   * 
 +   * @param param
 +   *          a list of key/value pairs
 +   */
 +  public static List<TKeyValue> compress(List<? extends KeyValue> param) {
 +    
 +    List<TKeyValue> tkvl = Arrays.asList(new TKeyValue[param.size()]);
 +    
 +    if (param.size() > 0)
 +      tkvl.set(0, new TKeyValue(param.get(0).key.toThrift(), ByteBuffer.wrap(param.get(0).value)));
 +    
 +    for (int i = param.size() - 1; i > 0; i--) {
 +      Key prevKey = param.get(i - 1).key;
 +      KeyValue kv = param.get(i);
 +      Key key = kv.key;
 +      
 +      TKey newKey = null;
 +      
 +      if (isEqual(prevKey.row, key.row)) {
 +        newKey = key.toThrift();
 +        newKey.row = null;
 +      }
 +      
 +      if (isEqual(prevKey.colFamily, key.colFamily)) {
 +        if (newKey == null)
 +          newKey = key.toThrift();
 +        newKey.colFamily = null;
 +      }
 +      
 +      if (isEqual(prevKey.colQualifier, key.colQualifier)) {
 +        if (newKey == null)
 +          newKey = key.toThrift();
 +        newKey.colQualifier = null;
 +      }
 +      
 +      if (isEqual(prevKey.colVisibility, key.colVisibility)) {
 +        if (newKey == null)
 +          newKey = key.toThrift();
 +        newKey.colVisibility = null;
 +      }
 +      
 +      if (newKey == null)
 +        newKey = key.toThrift();
 +      
 +      tkvl.set(i, new TKeyValue(newKey, ByteBuffer.wrap(kv.value)));
 +    }
 +    
 +    return tkvl;
 +  }
 +  
 +  /**
 +   * Use this to decompress a list of keys received from thrift.
 +   * 
 +   * @param param
 +   */
 +  
 +  public static void decompress(List<TKeyValue> param) {
 +    for (int i = 1; i < param.size(); i++) {
 +      TKey prevKey = param.get(i - 1).key;
 +      TKey key = param.get(i).key;
 +      
 +      if (key.row == null) {
 +        key.row = prevKey.row;
 +      }
 +      if (key.colFamily == null) {
 +        key.colFamily = prevKey.colFamily;
 +      }
 +      if (key.colQualifier == null) {
 +        key.colQualifier = prevKey.colQualifier;
 +      }
 +      if (key.colVisibility == null) {
 +        key.colVisibility = prevKey.colVisibility;
 +      }
 +    }
 +  }
 +  
 +  byte[] getRowBytes() {
 +    return row;
 +  }
 +  
 +  byte[] getColFamily() {
 +    return colFamily;
 +  }
 +  
 +  byte[] getColQualifier() {
 +    return colQualifier;
 +  }
 +  
 +  byte[] getColVisibility() {
 +    return colVisibility;
 +  }
 +  
 +  public TKey toThrift() {
 +    return new TKey(ByteBuffer.wrap(row), ByteBuffer.wrap(colFamily), ByteBuffer.wrap(colQualifier), ByteBuffer.wrap(colVisibility), timestamp);
 +  }
 +  
 +  @Override
 +  public Object clone() throws CloneNotSupportedException {
 +    Key r = (Key) super.clone();
 +    r.row = Arrays.copyOf(row, row.length);
 +    r.colFamily = Arrays.copyOf(colFamily, colFamily.length);
 +    r.colQualifier = Arrays.copyOf(colQualifier, colQualifier.length);
 +    r.colVisibility = Arrays.copyOf(colVisibility, colVisibility.length);
 +    return r;
 +  }
 +}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a5e3ed3b/core/src/test/java/org/apache/accumulo/core/data/KeyTest.java
----------------------------------------------------------------------
diff --cc core/src/test/java/org/apache/accumulo/core/data/KeyTest.java
index a13f2bd,0000000..56442a1
mode 100644,000000..100644
--- a/core/src/test/java/org/apache/accumulo/core/data/KeyTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/data/KeyTest.java
@@@ -1,110 -1,0 +1,136 @@@
 +/*
 + * 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.data;
 +
- import junit.framework.TestCase;
++import static org.junit.Assert.assertEquals;
++import static org.junit.Assert.assertNotSame;
++import static org.junit.Assert.assertSame;
++import static org.junit.Assert.assertTrue;
 +
++import org.apache.accumulo.core.data.thrift.TKey;
 +import org.apache.accumulo.core.security.ColumnVisibility;
 +import org.apache.hadoop.io.Text;
++import org.junit.Test;
 +
- public class KeyTest extends TestCase {
++public class KeyTest {
++
++  @Test
 +  public void testDeletedCompare() {
 +    Key k1 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, false);
 +    Key k2 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, false);
 +    Key k3 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, true);
 +    Key k4 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, true);
 +    
 +    assertTrue(k1.equals(k2));
 +    assertTrue(k3.equals(k4));
 +    assertTrue(k1.compareTo(k3) > 0);
 +    assertTrue(k3.compareTo(k1) < 0);
 +  }
 +  
++  @Test
 +  public void testCopyData() {
 +    byte row[] = "r".getBytes();
 +    byte cf[] = "cf".getBytes();
 +    byte cq[] = "cq".getBytes();
 +    byte cv[] = "cv".getBytes();
 +    
 +    Key k1 = new Key(row, cf, cq, cv, 5l, false, false);
 +    Key k2 = new Key(row, cf, cq, cv, 5l, false, true);
 +    
 +    assertSame(row, k1.getRowBytes());
 +    assertSame(cf, k1.getColFamily());
 +    assertSame(cq, k1.getColQualifier());
 +    assertSame(cv, k1.getColVisibility());
 +    
 +    assertSame(row, k1.getRowData().getBackingArray());
 +    assertSame(cf, k1.getColumnFamilyData().getBackingArray());
 +    assertSame(cq, k1.getColumnQualifierData().getBackingArray());
 +    assertSame(cv, k1.getColumnVisibilityData().getBackingArray());
 +    
 +    assertNotSame(row, k2.getRowBytes());
 +    assertNotSame(cf, k2.getColFamily());
 +    assertNotSame(cq, k2.getColQualifier());
 +    assertNotSame(cv, k2.getColVisibility());
 +    
 +    assertNotSame(row, k2.getRowData().getBackingArray());
 +    assertNotSame(cf, k2.getColumnFamilyData().getBackingArray());
 +    assertNotSame(cq, k2.getColumnQualifierData().getBackingArray());
 +    assertNotSame(cv, k2.getColumnVisibilityData().getBackingArray());
 +    
 +    assertEquals(k1, k2);
 +    
 +  }
 +  
++  @Test
 +  public void testString() {
 +    Key k1 = new Key("r1");
 +    Key k2 = new Key(new Text("r1"));
 +    assertEquals(k2, k1);
 +    
 +    k1 = new Key("r1", "cf1");
 +    k2 = new Key(new Text("r1"), new Text("cf1"));
 +    assertEquals(k2, k1);
 +    
 +    k1 = new Key("r1", "cf2", "cq2");
 +    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"));
 +    assertEquals(k2, k1);
 +    
 +    k1 = new Key("r1", "cf2", "cq2", "cv");
 +    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), new Text("cv"));
 +    assertEquals(k2, k1);
 +    
 +    k1 = new Key("r1", "cf2", "cq2", "cv", 89);
 +    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), new Text("cv"), 89);
 +    assertEquals(k2, k1);
 +    
 +    k1 = new Key("r1", "cf2", "cq2", 89);
 +    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), 89);
 +    assertEquals(k2, k1);
 +    
 +  }
 +  
++  @Test
 +  public void testVisibilityFollowingKey() {
 +    Key k = new Key("r", "f", "q", "v");
 +    assertEquals(k.followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS).toString(), "r f:q [v%00;] " + Long.MAX_VALUE + " false");
 +  }
 +  
 +  public void testVisibilityGetters() {
 +    Key k = new Key("r", "f", "q", "v1|(v2&v3)");
 +    
 +    Text expression = k.getColumnVisibility();
 +    ColumnVisibility parsed = k.getColumnVisibilityParsed();
 +    
 +    assertEquals(expression, new Text(parsed.getExpression()));
 +  }
++
++  @Test
++  public void testThrift() {
++    Key k = new Key("r1", "cf2", "cq2", "cv");
++    TKey tk = k.toThrift();
++    Key k2 = new Key(tk);
++    assertEquals(k, k2);
++  }
++
++  @Test(expected=IllegalArgumentException.class)
++  public void testThrift_Invalid() {
++    Key k = new Key("r1", "cf2", "cq2", "cv");
++    TKey tk = k.toThrift();
++    tk.setRow((byte[]) null);
++    new Key(tk);
++  }
 +}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a5e3ed3b/core/src/test/java/org/apache/accumulo/core/data/MutationTest.java
----------------------------------------------------------------------
diff --cc core/src/test/java/org/apache/accumulo/core/data/MutationTest.java
index 09026f7,0000000..33b060e
mode 100644,000000..100644
--- a/core/src/test/java/org/apache/accumulo/core/data/MutationTest.java
+++ b/core/src/test/java/org/apache/accumulo/core/data/MutationTest.java
@@@ -1,579 -1,0 +1,612 @@@
 +/*
 + * 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.data;
 +
 +import java.io.ByteArrayInputStream;
 +import java.io.ByteArrayOutputStream;
 +import java.io.DataInputStream;
 +import java.io.DataOutputStream;
 +import java.io.IOException;
 +import java.util.Arrays;
 +import java.util.List;
 +
- import junit.framework.TestCase;
++import org.junit.Test;
++import static org.junit.Assert.assertEquals;
++import static org.junit.Assert.assertFalse;
++import static org.junit.Assert.assertTrue;
 +
++import org.apache.accumulo.core.data.thrift.TMutation;
 +import org.apache.accumulo.core.security.ColumnVisibility;
 +import org.apache.hadoop.io.Text;
 +
- public class MutationTest extends TestCase {
++public class MutationTest  {
 +  
 +  private static String toHexString(byte[] ba) {
 +    StringBuilder str = new StringBuilder();
 +    for (int i = 0; i < ba.length; i++) {
 +      str.append(String.format("%x", ba[i]));
 +    }
 +    return str.toString();
 +  }
 +
 +  /* Test constructing a Mutation using a byte buffer. The byte array
 +   * returned as the row is converted to a hexadecimal string for easy
 +   * comparision.
 +   */
 +  public void testByteConstructor() {
 +    Mutation m = new Mutation("0123456789".getBytes());
 +    assertEquals("30313233343536373839", toHexString(m.getRow()));
 +  }
 +  
 +  public void testLimitedByteConstructor() {
 +    Mutation m = new Mutation("0123456789".getBytes(), 2, 5);
 +    assertEquals("3233343536", toHexString(m.getRow()));
 +  }
 +  
++  @Test
 +  public void test1() {
 +    Mutation m = new Mutation(new Text("r1"));
 +    m.put(new Text("cf1"), new Text("cq1"), new Value("v1".getBytes()));
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(1, updates.size());
 +    
 +    ColumnUpdate cu = updates.get(0);
 +    
 +    assertEquals("cf1", new String(cu.getColumnFamily()));
 +    assertEquals("cq1", new String(cu.getColumnQualifier()));
 +    assertEquals("", new String(cu.getColumnVisibility()));
 +    assertFalse(cu.hasTimestamp());
 +    
 +  }
 +  
++  @Test
 +  public void test2() throws IOException {
 +    Mutation m = new Mutation(new Text("r1"));
 +    m.put(new Text("cf1"), new Text("cq1"), new Value("v1".getBytes()));
 +    m.put(new Text("cf2"), new Text("cq2"), 56, new Value("v2".getBytes()));
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(2, updates.size());
 +    
 +    assertEquals("r1", new String(m.getRow()));
 +    ColumnUpdate cu = updates.get(0);
 +    
 +    assertEquals("cf1", new String(cu.getColumnFamily()));
 +    assertEquals("cq1", new String(cu.getColumnQualifier()));
 +    assertEquals("", new String(cu.getColumnVisibility()));
 +    assertFalse(cu.hasTimestamp());
 +    
 +    cu = updates.get(1);
 +    
 +    assertEquals("cf2", new String(cu.getColumnFamily()));
 +    assertEquals("cq2", new String(cu.getColumnQualifier()));
 +    assertEquals("", new String(cu.getColumnVisibility()));
 +    assertTrue(cu.hasTimestamp());
 +    assertEquals(56, cu.getTimestamp());
 +    
 +    m = cloneMutation(m);
 +    
 +    assertEquals("r1", new String(m.getRow()));
 +    updates = m.getUpdates();
 +    
 +    assertEquals(2, updates.size());
 +    
 +    cu = updates.get(0);
 +    
 +    assertEquals("cf1", new String(cu.getColumnFamily()));
 +    assertEquals("cq1", new String(cu.getColumnQualifier()));
 +    assertEquals("", new String(cu.getColumnVisibility()));
 +    assertFalse(cu.hasTimestamp());
 +    
 +    cu = updates.get(1);
 +    
 +    assertEquals("cf2", new String(cu.getColumnFamily()));
 +    assertEquals("cq2", new String(cu.getColumnQualifier()));
 +    assertEquals("", new String(cu.getColumnVisibility()));
 +    assertTrue(cu.hasTimestamp());
 +    assertEquals(56, cu.getTimestamp());
 +    
 +  }
 +  
 +  private Mutation cloneMutation(Mutation m) throws IOException {
 +    ByteArrayOutputStream baos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(baos);
 +    m.write(dos);
 +    dos.close();
 +    
 +    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bais);
 +    
 +    m = new Mutation();
 +    m.readFields(dis);
 +    return m;
 +  }
 +  
++  @Test
 +  public void test3() throws IOException {
 +    Mutation m = new Mutation(new Text("r1"));
 +    for (int i = 0; i < 5; i++) {
 +      int len = Mutation.VALUE_SIZE_COPY_CUTOFF - 2 + i;
 +      byte val[] = new byte[len];
 +      for (int j = 0; j < len; j++)
 +        val[j] = (byte) i;
 +      
 +      m.put(new Text("cf" + i), new Text("cq" + i), new Value(val));
 +      
 +    }
 +    
 +    for (int r = 0; r < 3; r++) {
 +      assertEquals("r1", new String(m.getRow()));
 +      List<ColumnUpdate> updates = m.getUpdates();
 +      assertEquals(5, updates.size());
 +      for (int i = 0; i < 5; i++) {
 +        ColumnUpdate cu = updates.get(i);
 +        assertEquals("cf" + i, new String(cu.getColumnFamily()));
 +        assertEquals("cq" + i, new String(cu.getColumnQualifier()));
 +        assertEquals("", new String(cu.getColumnVisibility()));
 +        assertFalse(cu.hasTimestamp());
 +        
 +        byte[] val = cu.getValue();
 +        int len = Mutation.VALUE_SIZE_COPY_CUTOFF - 2 + i;
 +        assertEquals(len, val.length);
 +        for (int j = 0; j < len; j++)
 +          assertEquals(i, val[j]);
 +      }
 +      
 +      m = cloneMutation(m);
 +    }
 +  }
 +  
 +  private Text nt(String s) {
 +    return new Text(s);
 +  }
 +  
 +  private Value nv(String s) {
 +    return new Value(s.getBytes());
 +  }
 +  
++  @Test
 +  public void testPuts() {
 +    Mutation m = new Mutation(new Text("r1"));
 +    
 +    m.put(nt("cf1"), nt("cq1"), nv("v1"));
 +    m.put(nt("cf2"), nt("cq2"), new ColumnVisibility("cv2"), nv("v2"));
 +    m.put(nt("cf3"), nt("cq3"), 3l, nv("v3"));
 +    m.put(nt("cf4"), nt("cq4"), new ColumnVisibility("cv4"), 4l, nv("v4"));
 +    
 +    m.putDelete(nt("cf5"), nt("cq5"));
 +    m.putDelete(nt("cf6"), nt("cq6"), new ColumnVisibility("cv6"));
 +    m.putDelete(nt("cf7"), nt("cq7"), 7l);
 +    m.putDelete(nt("cf8"), nt("cq8"), new ColumnVisibility("cv8"), 8l);
 +    
 +    assertEquals(8, m.size());
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(8, m.size());
 +    assertEquals(8, updates.size());
 +    
-     assertEquals(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
-     assertEquals(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
++    verifyColumnUpdate(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
++    verifyColumnUpdate(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
 +    
-     assertEquals(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
-     assertEquals(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
-     assertEquals(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
-     assertEquals(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
++    verifyColumnUpdate(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
++    verifyColumnUpdate(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
 +    
 +  }
 +  
++  @Test
 +  public void testPutsString() {
 +    Mutation m = new Mutation("r1");
 +    
 +    m.put("cf1", "cq1", nv("v1"));
 +    m.put("cf2", "cq2", new ColumnVisibility("cv2"), nv("v2"));
 +    m.put("cf3", "cq3", 3l, nv("v3"));
 +    m.put("cf4", "cq4", new ColumnVisibility("cv4"), 4l, nv("v4"));
 +    
 +    m.putDelete("cf5", "cq5");
 +    m.putDelete("cf6", "cq6", new ColumnVisibility("cv6"));
 +    m.putDelete("cf7", "cq7", 7l);
 +    m.putDelete("cf8", "cq8", new ColumnVisibility("cv8"), 8l);
 +    
 +    assertEquals(8, m.size());
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(8, m.size());
 +    assertEquals(8, updates.size());
 +    
-     assertEquals(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
-     assertEquals(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
++    verifyColumnUpdate(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
++    verifyColumnUpdate(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
 +    
-     assertEquals(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
-     assertEquals(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
-     assertEquals(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
-     assertEquals(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
++    verifyColumnUpdate(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
++    verifyColumnUpdate(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
 +  }
 +  
++  @Test
 +  public void testPutsStringString() {
 +    Mutation m = new Mutation("r1");
 +    
 +    m.put("cf1", "cq1", "v1");
 +    m.put("cf2", "cq2", new ColumnVisibility("cv2"), "v2");
 +    m.put("cf3", "cq3", 3l, "v3");
 +    m.put("cf4", "cq4", new ColumnVisibility("cv4"), 4l, "v4");
 +    
 +    m.putDelete("cf5", "cq5");
 +    m.putDelete("cf6", "cq6", new ColumnVisibility("cv6"));
 +    m.putDelete("cf7", "cq7", 7l);
 +    m.putDelete("cf8", "cq8", new ColumnVisibility("cv8"), 8l);
 +    
 +    assertEquals(8, m.size());
 +    assertEquals("r1", new String(m.getRow()));
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(8, m.size());
 +    assertEquals(8, updates.size());
 +    
-     assertEquals(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
-     assertEquals(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
++    verifyColumnUpdate(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
++    verifyColumnUpdate(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
 +    
-     assertEquals(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
-     assertEquals(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
-     assertEquals(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
-     assertEquals(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
++    verifyColumnUpdate(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
++    verifyColumnUpdate(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
 +  }
 +  
 +  public void testByteArrays() {
 +    Mutation m = new Mutation("r1".getBytes());
 +    
 +    m.put("cf1".getBytes(), "cq1".getBytes(), "v1".getBytes());
 +    m.put("cf2".getBytes(), "cq2".getBytes(), new ColumnVisibility("cv2"), "v2".getBytes());
 +    m.put("cf3".getBytes(), "cq3".getBytes(), 3l, "v3".getBytes());
 +    m.put("cf4".getBytes(), "cq4".getBytes(), new ColumnVisibility("cv4"), 4l, "v4".getBytes());
 +    
 +    m.putDelete("cf5".getBytes(), "cq5".getBytes());
 +    m.putDelete("cf6".getBytes(), "cq6".getBytes(), new ColumnVisibility("cv6"));
 +    m.putDelete("cf7".getBytes(), "cq7".getBytes(), 7l);
 +    m.putDelete("cf8".getBytes(), "cq8".getBytes(), new ColumnVisibility("cv8"), 8l);
 +    
 +    assertEquals(8, m.size());
 +    
 +    List<ColumnUpdate> updates = m.getUpdates();
 +    
 +    assertEquals(8, m.size());
 +    assertEquals(8, updates.size());
 +    
-     assertEquals(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
-     assertEquals(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
++    verifyColumnUpdate(updates.get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(updates.get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(updates.get(2), "cf3", "cq3", "", 3l, true, false, "v3");
++    verifyColumnUpdate(updates.get(3), "cf4", "cq4", "cv4", 4l, true, false, "v4");
 +    
-     assertEquals(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
-     assertEquals(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
-     assertEquals(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
-     assertEquals(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
++    verifyColumnUpdate(updates.get(4), "cf5", "cq5", "", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(5), "cf6", "cq6", "cv6", 0l, false, true, "");
++    verifyColumnUpdate(updates.get(6), "cf7", "cq7", "", 7l, true, true, "");
++    verifyColumnUpdate(updates.get(7), "cf8", "cq8", "cv8", 8l, true, true, "");
 +  }
 +
 +  /**
 +   * Test for regression on bug 3422. If a {@link Mutation} object is reused for multiple calls to readFields, the mutation would previously be "locked in" to
 +   * the first set of column updates (and value lengths). Hadoop input formats reuse objects when reading, so if Mutations are used with an input format (or as
 +   * the input to a combiner or reducer) then they will be used in this fashion.
 +   */
++  @Test
 +  public void testMultipleReadFieldsCalls() throws IOException {
 +    // Create test mutations and write them to a byte output stream
 +    Mutation m1 = new Mutation("row1");
 +    m1.put("cf1.1", "cq1.1", new ColumnVisibility("A|B"), "val1.1");
 +    m1.put("cf1.2", "cq1.2", new ColumnVisibility("C|D"), "val1.2");
 +    byte[] val1_3 = new byte[Mutation.VALUE_SIZE_COPY_CUTOFF + 3];
 +    Arrays.fill(val1_3, (byte) 3);
 +    m1.put("cf1.3", "cq1.3", new ColumnVisibility("E|F"), new String(val1_3));
 +    int size1 = m1.size();
 +    long nb1 = m1.numBytes();
 +    
 +    Mutation m2 = new Mutation("row2");
 +    byte[] val2 = new byte[Mutation.VALUE_SIZE_COPY_CUTOFF + 2];
 +    Arrays.fill(val2, (byte) 2);
 +    m2.put("cf2", "cq2", new ColumnVisibility("G|H"), 1234, new String(val2));
 +    int size2 = m2.size();
 +    long nb2 = m2.numBytes();
 +    
 +    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(bos);
 +    m1.write(dos);
 +    m2.write(dos);
 +    dos.close();
 +    
 +    // Now read the mutations back in from the byte array, making sure to
 +    // reuse the same mutation object, and make sure everything is correct.
 +    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bis);
 +    
 +    Mutation m = new Mutation();
 +    m.readFields(dis);
 +    
 +    assertEquals("row1", new String(m.getRow()));
 +    assertEquals(size1, m.size());
 +    assertEquals(nb1, m.numBytes());
 +    assertEquals(3, m.getUpdates().size());
-     assertEquals(m.getUpdates().get(0), "cf1.1", "cq1.1", "A|B", 0L, false, false, "val1.1");
-     assertEquals(m.getUpdates().get(1), "cf1.2", "cq1.2", "C|D", 0L, false, false, "val1.2");
-     assertEquals(m.getUpdates().get(2), "cf1.3", "cq1.3", "E|F", 0L, false, false, new String(val1_3));
++    verifyColumnUpdate(m.getUpdates().get(0), "cf1.1", "cq1.1", "A|B", 0L, false, false, "val1.1");
++    verifyColumnUpdate(m.getUpdates().get(1), "cf1.2", "cq1.2", "C|D", 0L, false, false, "val1.2");
++    verifyColumnUpdate(m.getUpdates().get(2), "cf1.3", "cq1.3", "E|F", 0L, false, false, new String(val1_3));
 +    
 +    // Reuse the same mutation object (which is what happens in the hadoop framework
 +    // when objects are read by an input format)
 +    m.readFields(dis);
 +    
 +    assertEquals("row2", new String(m.getRow()));
 +    assertEquals(size2, m.size());
 +    assertEquals(nb2, m.numBytes());
 +    assertEquals(1, m.getUpdates().size());
-     assertEquals(m.getUpdates().get(0), "cf2", "cq2", "G|H", 1234L, true, false, new String(val2));
++    verifyColumnUpdate(m.getUpdates().get(0), "cf2", "cq2", "G|H", 1234L, true, false, new String(val2));
 +  }
 +  
-   private void assertEquals(ColumnUpdate cu, String cf, String cq, String cv, long ts, boolean timeSet, boolean deleted, String val) {
++  private void verifyColumnUpdate(ColumnUpdate cu, String cf, String cq, String cv, long ts, boolean timeSet, boolean deleted, String val) {
 +    
 +    assertEquals(cf, new String(cu.getColumnFamily()));
 +    assertEquals(cq, new String(cu.getColumnQualifier()));
 +    assertEquals(cv, new String(cu.getColumnVisibility()));
 +    assertEquals(timeSet, cu.hasTimestamp());
 +    if (timeSet)
 +      assertEquals(ts, cu.getTimestamp());
 +    assertEquals(deleted, cu.isDeleted());
 +    assertEquals(val, new String(cu.getValue()));
 +  }
 +  
++  @Test
 +  public void test4() throws Exception {
 +    Mutation m1 = new Mutation(new Text("r1"));
 +    
 +    m1.put(nt("cf1"), nt("cq1"), nv("v1"));
 +    m1.put(nt("cf2"), nt("cq2"), new ColumnVisibility("cv2"), nv("v2"));
 +    
 +    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(bos);
 +    m1.write(dos);
 +    dos.close();
 +    
 +    Mutation m2 = new Mutation(new Text("r2"));
 +    
 +    m2.put(nt("cf3"), nt("cq3"), nv("v3"));
 +    m2.put(nt("cf4"), nt("cq4"), new ColumnVisibility("cv2"), nv("v4"));
 +    
 +    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bis);
 +    
 +    // used to be a bug where puts done before readFields would be seen
 +    // after readFields
 +    m2.readFields(dis);
 +    
 +    assertEquals("r1", new String(m2.getRow()));
 +    assertEquals(2, m2.getUpdates().size());
 +    assertEquals(2, m2.size());
-     assertEquals(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
 +  }
 +  
 +  Mutation convert(OldMutation old) throws IOException {
 +    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(bos);
 +    old.write(dos);
 +    dos.close();
 +    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bis);
 +    Mutation m = new Mutation();
 +    m.readFields(dis);
 +    dis.close();
 +    return m;
 +  }
 +  
-   
++  @Test
 +  public void testNewSerialization() throws Exception {
 +    // write an old mutation
 +    OldMutation m2 = new OldMutation("r1");
 +    m2.put("cf1", "cq1", "v1");
 +    m2.put("cf2", "cq2", new ColumnVisibility("cv2"), "v2");
 +    m2.putDelete("cf3", "cq3");
 +    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(bos);
 +    m2.write(dos);
 +    dos.close();
 +    long oldSize = dos.size(); 
 +    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bis);
 +    m2.readFields(dis);
 +    dis.close();
 +    
 +    // check it
 +    assertEquals("r1", new String(m2.getRow()));
 +    assertEquals(3, m2.getUpdates().size());
 +    assertEquals(3, m2.size());
-     assertEquals(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(m2.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
++    verifyColumnUpdate(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(m2.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
 +
 +    Mutation m1 = convert(m2);
 +    
 +    assertEquals("r1", new String(m1.getRow()));
 +    assertEquals(3, m1.getUpdates().size());
 +    assertEquals(3, m1.size());
-     assertEquals(m1.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(m1.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(m1.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
++    verifyColumnUpdate(m1.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(m1.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(m1.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
 +    
 +    Text exampleRow = new Text(" 123456789 123456789 123456789 123456789 123456789");
 +    int exampleLen = exampleRow.getLength();
 +    m1 = new Mutation(exampleRow);
 +    m1.put("", "", "");
 +
 +    bos = new ByteArrayOutputStream();
 +    dos = new DataOutputStream(bos);
 +    m1.write(dos);
 +    dos.close();
 +    long newSize = dos.size();
 +    assertTrue(newSize < oldSize);
 +    assertEquals(10, newSize - exampleLen);
 +    assertEquals(68, oldSize - exampleLen);
 +    // I am converting to integer to avoid comparing floats which are inaccurate
 +    assertEquals(14705, (int)(((newSize-exampleLen) * 100. / (oldSize - exampleLen)) * 1000));
 +    StringBuilder sb = new StringBuilder();
 +    byte[] ba = bos.toByteArray();
 +    for (int i = 0; i < bos.size(); i += 4) {
 +      for (int j = i; j < bos.size() && j < i + 4; j++) {
 +        sb.append(String.format("%02x", ba[j]));
 +      }
 +      sb.append(" ");
 +    }
 +    assertEquals("80322031 32333435 36373839 20313233 34353637 38392031 32333435 36373839 20313233 34353637 38392031 32333435 36373839 06000000 00000001 ", sb.toString());
-     
++
 +  }
 +  
++  @Test
 +  public void testReserialize() throws Exception {
 +    // test reading in a new mutation from an old mutation and reserializing the new mutation... this was failing
 +    OldMutation om = new OldMutation("r1");
 +    om.put("cf1", "cq1", "v1");
 +    om.put("cf2", "cq2", new ColumnVisibility("cv2"), "v2");
 +    om.putDelete("cf3", "cq3");
 +    StringBuilder bigVal = new StringBuilder();
 +    for (int i = 0; i < 100000; i++) {
 +      bigVal.append('a');
 +    }
 +    om.put("cf2", "big", bigVal);
 +
 +    
 +    Mutation m1 = convert(om);
 +
 +    ByteArrayOutputStream bos = new ByteArrayOutputStream();
 +    DataOutputStream dos = new DataOutputStream(bos);
 +    m1.write(dos);
 +    dos.close();
 +    
 +    Mutation m2 = new Mutation();
 +    
 +    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
 +    DataInputStream dis = new DataInputStream(bis);
 +    m2.readFields(dis);
 +    
 +    assertEquals("r1", new String(m1.getRow()));
 +    assertEquals(4, m2.getUpdates().size());
 +    assertEquals(4, m2.size());
-     assertEquals(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
-     assertEquals(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
-     assertEquals(m2.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
-     assertEquals(m2.getUpdates().get(3), "cf2", "big", "", 0l, false, false, bigVal.toString());
++    verifyColumnUpdate(m2.getUpdates().get(0), "cf1", "cq1", "", 0l, false, false, "v1");
++    verifyColumnUpdate(m2.getUpdates().get(1), "cf2", "cq2", "cv2", 0l, false, false, "v2");
++    verifyColumnUpdate(m2.getUpdates().get(2), "cf3", "cq3", "", 0l, false, true, "");
++    verifyColumnUpdate(m2.getUpdates().get(3), "cf2", "big", "", 0l, false, false, bigVal.toString());
 +  }
- 
++  
++  @Test
 +  public void testEquals() {
 +    Mutation m1 = new Mutation("r1");
 +    
 +    m1.put("cf1", "cq1", "v1");
 +    m1.put("cf1", "cq1", new ColumnVisibility("A&B"), "v2");
 +    m1.put("cf1", "cq1", 3, "v3");
 +    m1.put("cf1", "cq1", new ColumnVisibility("A&B&C"), 4, "v4");
 +    m1.putDelete("cf2", "cf3");
 +    m1.putDelete("cf2", "cf4", 3);
 +    m1.putDelete("cf2", "cf4", new ColumnVisibility("A&B&C"), 3);
 +    
 +    // m2 has same data as m1
 +    Mutation m2 = new Mutation("r1");
 +    
 +    m2.put("cf1", "cq1", "v1");
 +    m2.put("cf1", "cq1", new ColumnVisibility("A&B"), "v2");
 +    m2.put("cf1", "cq1", 3, "v3");
 +    m2.put("cf1", "cq1", new ColumnVisibility("A&B&C"), 4, "v4");
 +    m2.putDelete("cf2", "cf3");
 +    m2.putDelete("cf2", "cf4", 3);
 +    m2.putDelete("cf2", "cf4", new ColumnVisibility("A&B&C"), 3);
 +    
-     // m3 has differnt row than m1
++    // m3 has different row than m1
 +    Mutation m3 = new Mutation("r2");
 +    
 +    m3.put("cf1", "cq1", "v1");
 +    m3.put("cf1", "cq1", new ColumnVisibility("A&B"), "v2");
 +    m3.put("cf1", "cq1", 3, "v3");
 +    m3.put("cf1", "cq1", new ColumnVisibility("A&B&C"), 4, "v4");
 +    m3.putDelete("cf2", "cf3");
 +    m3.putDelete("cf2", "cf4", 3);
 +    m3.putDelete("cf2", "cf4", new ColumnVisibility("A&B&C"), 3);
 +
 +    // m4 has a different column than m1
 +    Mutation m4 = new Mutation("r1");
 +    
 +    m4.put("cf2", "cq1", "v1");
 +    m4.put("cf1", "cq1", new ColumnVisibility("A&B"), "v2");
 +    m4.put("cf1", "cq1", 3, "v3");
 +    m4.put("cf1", "cq1", new ColumnVisibility("A&B&C"), 4, "v4");
 +    m4.putDelete("cf2", "cf3");
 +    m4.putDelete("cf2", "cf4", 3);
 +    m4.putDelete("cf2", "cf4", new ColumnVisibility("A&B&C"), 3);
 +    
 +    // m5 has a different value than m1
 +    Mutation m5 = new Mutation("r1");
 +    
 +    m5.put("cf1", "cq1", "v1");
 +    m5.put("cf1", "cq1", new ColumnVisibility("A&B"), "v2");
 +    m5.put("cf1", "cq1", 3, "v4");
 +    m5.put("cf1", "cq1", new ColumnVisibility("A&B&C"), 4, "v4");
 +    m5.putDelete("cf2", "cf3");
 +    m5.putDelete("cf2", "cf4", 3);
 +    m5.putDelete("cf2", "cf4", new ColumnVisibility("A&B&C"), 3);
 +
 +    assertEquals(m1, m1);
 +    assertEquals(m1, m2);
 +    assertEquals(m2, m1);
 +    assertFalse(m1.equals(m3));
 +    assertFalse(m3.equals(m1));
 +    assertFalse(m1.equals(m4));
 +    assertFalse(m4.equals(m1));
 +    assertFalse(m3.equals(m4));
 +    assertFalse(m1.equals(m5));
 +    assertFalse(m5.equals(m1));
 +    assertFalse(m3.equals(m5));
 +    assertFalse(m4.equals(m5));
 +  }
++
++  @Test
++  public void testThrift() {
++    Mutation m1 = new Mutation("r1");
++    m1.put("cf1", "cq1", "v1");
++    TMutation tm1 = m1.toThrift();
++    Mutation m2 = new Mutation(tm1);
++    assertEquals(m1, m2);
++  }
++  
++  @Test(expected=IllegalArgumentException.class)
++  public void testThrift_Invalid() {
++    Mutation m1 = new Mutation("r1");
++    m1.put("cf1", "cq1", "v1");
++    TMutation tm1 = m1.toThrift();
++    tm1.setRow((byte[]) null);
++    new Mutation(tm1);
++  }
++
 +}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/a5e3ed3b/core/src/test/java/org/apache/accumulo/core/data/OldMutation.java
----------------------------------------------------------------------
diff --cc core/src/test/java/org/apache/accumulo/core/data/OldMutation.java
index 786adce,0000000..5f6f993
mode 100644,000000..100644
--- a/core/src/test/java/org/apache/accumulo/core/data/OldMutation.java
+++ b/core/src/test/java/org/apache/accumulo/core/data/OldMutation.java
@@@ -1,492 -1,0 +1,499 @@@
 +/*
 + * 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.data;
 +
 +import java.io.DataInput;
 +import java.io.DataOutput;
 +import java.io.IOException;
 +import java.util.ArrayList;
 +import java.util.Arrays;
 +import java.util.Collections;
 +import java.util.List;
 +
 +import org.apache.accumulo.core.data.thrift.TMutation;
 +import org.apache.accumulo.core.security.ColumnVisibility;
 +import org.apache.accumulo.core.util.ByteBufferUtil;
 +import org.apache.accumulo.core.util.TextUtil;
 +import org.apache.hadoop.io.Text;
 +import org.apache.hadoop.io.Writable;
 +
 +/**
 + * Will read/write old mutations.
 + */
 +public class OldMutation implements Writable {
 +  
 +  static final int VALUE_SIZE_COPY_CUTOFF = 1 << 15;
 +  
 +  private byte[] row;
 +  private byte[] data;
 +  private int entries;
 +  private List<byte[]> values;
 +  
 +  // created this little class instead of using ByteArrayOutput stream and DataOutputStream
 +  // because both are synchronized... lots of small syncs slow things down
 +  private static class ByteBuffer {
 +    
 +    int offset;
 +    byte data[] = new byte[64];
 +    
 +    private void reserve(int l) {
 +      if (offset + l > data.length) {
 +        int newSize = data.length * 2;
 +        while (newSize <= offset + l)
 +          newSize = newSize * 2;
 +        
 +        byte[] newData = new byte[newSize];
 +        System.arraycopy(data, 0, newData, 0, offset);
 +        data = newData;
 +      }
 +      
 +    }
 +    
 +    void add(byte[] b) {
 +      reserve(b.length);
 +      System.arraycopy(b, 0, data, offset, b.length);
 +      offset += b.length;
 +    }
 +    
 +    public void add(byte[] bytes, int off, int length) {
 +      reserve(length);
 +      System.arraycopy(bytes, off, data, offset, length);
 +      offset += length;
 +    }
 +    
 +    void add(boolean b) {
 +      reserve(1);
 +      if (b)
 +        data[offset++] = 1;
 +      else
 +        data[offset++] = 0;
 +    }
 +    
 +    void add(long v) {
 +      reserve(8);
 +      data[offset++] = (byte) (v >>> 56);
 +      data[offset++] = (byte) (v >>> 48);
 +      data[offset++] = (byte) (v >>> 40);
 +      data[offset++] = (byte) (v >>> 32);
 +      data[offset++] = (byte) (v >>> 24);
 +      data[offset++] = (byte) (v >>> 16);
 +      data[offset++] = (byte) (v >>> 8);
 +      data[offset++] = (byte) (v >>> 0);
 +    }
 +    
 +    void add(int i) {
 +      reserve(4);
 +      data[offset++] = (byte) (i >>> 24);
 +      data[offset++] = (byte) (i >>> 16);
 +      data[offset++] = (byte) (i >>> 8);
 +      data[offset++] = (byte) (i >>> 0);
 +    }
 +    
 +    public byte[] toArray() {
 +      byte ret[] = new byte[offset];
 +      System.arraycopy(data, 0, ret, 0, offset);
 +      return ret;
 +    }
 +    
 +  }
 +  
 +  private static class SimpleReader {
 +    int offset;
 +    byte data[];
 +    
 +    SimpleReader(byte b[]) {
 +      this.data = b;
 +    }
 +    
 +    int readInt() {
 +      return (data[offset++] << 24) + ((data[offset++] & 255) << 16) + ((data[offset++] & 255) << 8) + ((data[offset++] & 255) << 0);
 +      
 +    }
 +    
 +    long readLong() {
 +      return (((long) data[offset++] << 56) + ((long) (data[offset++] & 255) << 48) + ((long) (data[offset++] & 255) << 40)
 +          + ((long) (data[offset++] & 255) << 32) + ((long) (data[offset++] & 255) << 24) + ((data[offset++] & 255) << 16) + ((data[offset++] & 255) << 8) + ((data[offset++] & 255) << 0));
 +    }
 +    
 +    void readBytes(byte b[]) {
 +      System.arraycopy(data, offset, b, 0, b.length);
 +      offset += b.length;
 +    }
 +    
 +    boolean readBoolean() {
 +      return (data[offset++] == 1);
 +    }
 +    
 +  }
 +  
 +  private ByteBuffer buffer;
 +  
 +  private List<ColumnUpdate> updates;
 +  
 +  private static final byte[] EMPTY_BYTES = new byte[0];
 +  
 +  private void serialize() {
 +    if (buffer != null) {
 +      data = buffer.toArray();
 +      buffer = null;
 +    }
 +  }
 +  
 +  public OldMutation(Text row) {
 +    this.row = new byte[row.getLength()];
 +    System.arraycopy(row.getBytes(), 0, this.row, 0, row.getLength());
 +    buffer = new ByteBuffer();
 +  }
 +  
 +  public OldMutation(CharSequence row) {
 +    this(new Text(row.toString()));
 +  }
 +  
 +  public OldMutation() {}
 +  
 +  public OldMutation(TMutation tmutation) {
 +    this.row = ByteBufferUtil.toBytes(tmutation.row);
 +    this.data = ByteBufferUtil.toBytes(tmutation.data);
 +    this.entries = tmutation.entries;
 +    this.values = ByteBufferUtil.toBytesList(tmutation.values);
++
++    if (this.row == null) {
++      throw new IllegalArgumentException("null row");
++    }
++    if (this.data == null) {
++      throw new IllegalArgumentException("null serialized data");
++    }
 +  }
 +  
 +  public byte[] getRow() {
 +    return row;
 +  }
 +  
 +  private void put(byte b[]) {
 +    buffer.add(b.length);
 +    buffer.add(b);
 +  }
 +  
 +  private void put(Text t) {
 +    buffer.add(t.getLength());
 +    buffer.add(t.getBytes(), 0, t.getLength());
 +  }
 +  
 +  private void put(boolean b) {
 +    buffer.add(b);
 +  }
 +  
 +  private void put(int i) {
 +    buffer.add(i);
 +  }
 +  
 +  private void put(long l) {
 +    buffer.add(l);
 +  }
 +  
 +  private void put(Text cf, Text cq, byte[] cv, boolean hasts, long ts, boolean deleted, byte[] val) {
 +    
 +    if (buffer == null)
 +      throw new IllegalStateException("Can not add to mutation after serializing it");
 +    
 +    put(cf);
 +    put(cq);
 +    put(cv);
 +    put(hasts);
 +    put(ts);
 +    put(deleted);
 +    
 +    if (val.length < VALUE_SIZE_COPY_CUTOFF) {
 +      put(val);
 +    } else {
 +      if (values == null)
 +        values = new ArrayList<byte[]>();
 +      byte copy[] = new byte[val.length];
 +      System.arraycopy(val, 0, copy, 0, val.length);
 +      values.add(copy);
 +      put(-1 * values.size());
 +    }
 +    
 +    entries++;
 +  }
 +  
 +  private void put(CharSequence cf, CharSequence cq, byte[] cv, boolean hasts, long ts, boolean deleted, byte[] val) {
 +    put(new Text(cf.toString()), new Text(cq.toString()), cv, hasts, ts, deleted, val);
 +  }
 +  
 +  private void put(CharSequence cf, CharSequence cq, byte[] cv, boolean hasts, long ts, boolean deleted, CharSequence val) {
 +    put(cf, cq, cv, hasts, ts, deleted, TextUtil.getBytes(new Text(val.toString())));
 +  }
 +  
 +  public void put(Text columnFamily, Text columnQualifier, Value value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, false, 0l, false, value.get());
 +  }
 +  
 +  public void put(Text columnFamily, Text columnQualifier, ColumnVisibility columnVisibility, Value value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), false, 0l, false, value.get());
 +  }
 +  
 +  public void put(Text columnFamily, Text columnQualifier, long timestamp, Value value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, true, timestamp, false, value.get());
 +  }
 +  
 +  public void put(Text columnFamily, Text columnQualifier, ColumnVisibility columnVisibility, long timestamp, Value value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), true, timestamp, false, value.get());
 +  }
 +  
 +  public void putDelete(Text columnFamily, Text columnQualifier) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, false, 0l, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(Text columnFamily, Text columnQualifier, ColumnVisibility columnVisibility) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), false, 0l, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(Text columnFamily, Text columnQualifier, long timestamp) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, true, timestamp, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(Text columnFamily, Text columnQualifier, ColumnVisibility columnVisibility, long timestamp) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), true, timestamp, true, EMPTY_BYTES);
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, Value value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, false, 0l, false, value.get());
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility, Value value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), false, 0l, false, value.get());
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, long timestamp, Value value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, true, timestamp, false, value.get());
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility, long timestamp, Value value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), true, timestamp, false, value.get());
 +  }
 +  
 +  public void putDelete(CharSequence columnFamily, CharSequence columnQualifier) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, false, 0l, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), false, 0l, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(CharSequence columnFamily, CharSequence columnQualifier, long timestamp) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, true, timestamp, true, EMPTY_BYTES);
 +  }
 +  
 +  public void putDelete(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility, long timestamp) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), true, timestamp, true, EMPTY_BYTES);
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, CharSequence value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, false, 0l, false, value);
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility, CharSequence value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), false, 0l, false, value);
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, long timestamp, CharSequence value) {
 +    put(columnFamily, columnQualifier, EMPTY_BYTES, true, timestamp, false, value);
 +  }
 +  
 +  public void put(CharSequence columnFamily, CharSequence columnQualifier, ColumnVisibility columnVisibility, long timestamp, CharSequence value) {
 +    put(columnFamily, columnQualifier, columnVisibility.getExpression(), true, timestamp, false, value);
 +  }
 +  
 +  private byte[] readBytes(SimpleReader in) {
 +    int len = in.readInt();
 +    if (len == 0)
 +      return EMPTY_BYTES;
 +    
 +    byte bytes[] = new byte[len];
 +    in.readBytes(bytes);
 +    return bytes;
 +  }
 +  
 +  public List<ColumnUpdate> getUpdates() {
 +    serialize();
 +    
 +    SimpleReader in = new SimpleReader(data);
 +    
 +    if (updates == null) {
 +      if (entries == 1) {
 +        updates = Collections.singletonList(deserializeColumnUpdate(in));
 +      } else {
 +        ColumnUpdate[] tmpUpdates = new ColumnUpdate[entries];
 +        
 +        for (int i = 0; i < entries; i++)
 +          tmpUpdates[i] = deserializeColumnUpdate(in);
 +        
 +        updates = Arrays.asList(tmpUpdates);
 +      }
 +    }
 +    
 +    return updates;
 +  }
 +  
 +  private ColumnUpdate deserializeColumnUpdate(SimpleReader in) {
 +    byte[] cf = readBytes(in);
 +    byte[] cq = readBytes(in);
 +    byte[] cv = readBytes(in);
 +    boolean hasts = in.readBoolean();
 +    long ts = in.readLong();
 +    boolean deleted = in.readBoolean();
 +    
 +    byte[] val;
 +    int valLen = in.readInt();
 +    
 +    if (valLen < 0) {
 +      val = values.get((-1 * valLen) - 1);
 +    } else if (valLen == 0) {
 +      val = EMPTY_BYTES;
 +    } else {
 +      val = new byte[valLen];
 +      in.readBytes(val);
 +    }
 +    
 +    return new ColumnUpdate(cf, cq, cv, hasts, ts, deleted, val);
 +  }
 +  
 +  private int cachedValLens = -1;
 +  
 +  long getValueLengths() {
 +    if (values == null)
 +      return 0;
 +    
 +    if (cachedValLens == -1) {
 +      int tmpCVL = 0;
 +      for (byte[] val : values)
 +        tmpCVL += val.length;
 +      
 +      cachedValLens = tmpCVL;
 +    }
 +    
 +    return cachedValLens;
 +    
 +  }
 +  
 +  public long numBytes() {
 +    serialize();
 +    return row.length + data.length + getValueLengths();
 +  }
 +  
 +  public long estimatedMemoryUsed() {
 +    return numBytes() + 230;
 +  }
 +  
 +  /**
 +   * @return the number of column value pairs added to the mutation
 +   */
 +  public int size() {
 +    return entries;
 +  }
 +  
 +  @Override
 +  public void readFields(DataInput in) throws IOException {
 +    // Clear out cached column updates and value lengths so
 +    // that we recalculate them based on the (potentially) new
 +    // data we are about to read in.
 +    updates = null;
 +    cachedValLens = -1;
 +    buffer = null;
 +    
 +    int len = in.readInt();
 +    row = new byte[len];
 +    in.readFully(row);
 +    len = in.readInt();
 +    data = new byte[len];
 +    in.readFully(data);
 +    entries = in.readInt();
 +    
 +    boolean valuesPresent = in.readBoolean();
 +    if (!valuesPresent) {
 +      values = null;
 +    } else {
 +      values = new ArrayList<byte[]>();
 +      int numValues = in.readInt();
 +      for (int i = 0; i < numValues; i++) {
 +        len = in.readInt();
 +        byte val[] = new byte[len];
 +        in.readFully(val);
 +        values.add(val);
 +      }
 +    }
 +  }
 +  
 +  @Override
 +  public void write(DataOutput out) throws IOException {
 +    serialize();
 +    out.writeInt(row.length);
 +    out.write(row);
 +    out.writeInt(data.length);
 +    out.write(data);
 +    out.writeInt(entries);
 +    
 +    if (values == null)
 +      out.writeBoolean(false);
 +    else {
 +      out.writeBoolean(true);
 +      out.writeInt(values.size());
 +      for (int i = 0; i < values.size(); i++) {
 +        byte val[] = values.get(i);
 +        out.writeInt(val.length);
 +        out.write(val);
 +      }
 +    }
 +    
 +  }
 +  
 +  @Override
 +  public boolean equals(Object o) {
 +    if (o instanceof OldMutation)
 +      return equals((OldMutation) o);
 +    return false;
 +  }
 +  
 +  @Override
 +  public int hashCode() {
 +    return toThrift().hashCode();
 +  }
 +  
 +  public boolean equals(OldMutation m) {
 +    serialize();
 +    if (!Arrays.equals(row, m.getRow()))
 +      return false;
 +    List<ColumnUpdate> oldcus = this.getUpdates();
 +    List<ColumnUpdate> newcus = m.getUpdates();
 +    if (oldcus.size() != newcus.size())
 +      return false;
 +    for (int i = 0; i < newcus.size(); i++) {
 +      ColumnUpdate oldcu = oldcus.get(i);
 +      ColumnUpdate newcu = newcus.get(i);
 +      if (!oldcu.equals(newcu))
 +        return false;
 +    }
 +    return false;
 +  }
 +  
 +  public TMutation toThrift() {
 +    serialize();
 +    return new TMutation(java.nio.ByteBuffer.wrap(row), java.nio.ByteBuffer.wrap(data), ByteBufferUtil.toByteBuffers(values), entries);
 +  }
 +  
 +}


Mime
View raw message