hbase-common/src/test/java/org/apache/hadoop/hbase/TestCellUtil.java

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package org.apache.hadoop.hbase;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertFalse;
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.io.ByteArrayOutputStream;
  26 import java.io.IOException;
  27 import java.math.BigDecimal;
  28 import java.nio.ByteBuffer;
  29 import java.nio.charset.StandardCharsets;
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import java.util.NavigableMap;
  33 import java.util.TreeMap;
  34
  35 import org.apache.hadoop.hbase.KeyValue.Type;
  36 import org.apache.hadoop.hbase.testclassification.MiscTests;
  37 import org.apache.hadoop.hbase.testclassification.SmallTests;
  38 import org.apache.hadoop.hbase.util.Bytes;
  39 import org.junit.Assert;
  40 import org.junit.Test;
  41 import org.junit.experimental.categories.Category;
  42
  43 @Category({MiscTests.class, SmallTests.class})
  44 public class TestCellUtil {
  45   /**
  46    * CellScannable used in test. Returns a {@link TestCellScanner}
  47    */
  48   private static class TestCellScannable implements CellScannable {
  49     private final int cellsCount;
  50     TestCellScannable(final int cellsCount) {
  51       this.cellsCount = cellsCount;
  52     }
  53     @Override
  54     public CellScanner cellScanner() {
  55       return new TestCellScanner(this.cellsCount);
  56     }
  57   };
  58
  59   /**
  60    * CellScanner used in test.
  61    */
  62   private static class TestCellScanner implements CellScanner {
  63     private int count = 0;
  64     private Cell current = null;
  65     private final int cellsCount;
  66
  67     TestCellScanner(final int cellsCount) {
  68       this.cellsCount = cellsCount;
  69     }
  70
  71     @Override
  72     public Cell current() {
  73       return this.current;
  74     }
  75
  76     @Override
  77     public boolean advance() throws IOException {
  78       if (this.count < cellsCount) {
  79         this.current = new TestCell(this.count);
  80         this.count++;
  81         return true;
  82       }
  83       return false;
  84     }
  85   }
  86
  87   /**
  88    * Cell used in test. Has row only.
  89    */
  90   private static class TestCell implements Cell {
  91     private final byte [] row;
  92
  93     TestCell(final int i) {
  94       this.row = Bytes.toBytes(i);
  95     }
  96
  97     @Override
  98     public byte[] getRowArray() {
  99       return this.row;
 100     }
 101
 102     @Override
 103     public int getRowOffset() {
 104       return 0;
 105     }
 106
 107     @Override
 108     public short getRowLength() {
 109       return (short)this.row.length;
 110     }
 111
 112     @Override
 113     public byte[] getFamilyArray() {
 114       // TODO Auto-generated method stub
 115       return null;
 116     }
 117
 118     @Override
 119     public int getFamilyOffset() {
 120       // TODO Auto-generated method stub
 121       return 0;
 122     }
 123
 124     @Override
 125     public byte getFamilyLength() {
 126       // TODO Auto-generated method stub
 127       return 0;
 128     }
 129
 130     @Override
 131     public byte[] getQualifierArray() {
 132       // TODO Auto-generated method stub
 133       return null;
 134     }
 135
 136     @Override
 137     public int getQualifierOffset() {
 138       // TODO Auto-generated method stub
 139       return 0;
 140     }
 141
 142     @Override
 143     public int getQualifierLength() {
 144       // TODO Auto-generated method stub
 145       return 0;
 146     }
 147
 148     @Override
 149     public long getTimestamp() {
 150       // TODO Auto-generated method stub
 151       return 0;
 152     }
 153
 154     @Override
 155     public byte getTypeByte() {
 156       // TODO Auto-generated method stub
 157       return 0;
 158     }
 159
 160     @Override
 161     public byte[] getValueArray() {
 162       // TODO Auto-generated method stub
 163       return null;
 164     }
 165
 166     @Override
 167     public int getValueOffset() {
 168       // TODO Auto-generated method stub
 169       return 0;
 170     }
 171
 172     @Override
 173     public int getValueLength() {
 174       // TODO Auto-generated method stub
 175       return 0;
 176     }
 177
 178     @Override
 179     public byte[] getTagsArray() {
 180       // TODO Auto-generated method stub
 181       return null;
 182     }
 183
 184     @Override
 185     public int getTagsOffset() {
 186       // TODO Auto-generated method stub
 187       return 0;
 188     }
 189
 190     @Override
 191     public long getSequenceId() {
 192       // TODO Auto-generated method stub
 193       return 0;
 194     }
 195
 196     @Override
 197     public int getTagsLength() {
 198       // TODO Auto-generated method stub
 199       return 0;
 200     }
 201   };
 202
 203   /**
 204    * Was overflowing if 100k or so lists of cellscanners to return.
 205    */
 206   @Test
 207   public void testCreateCellScannerOverflow() throws IOException {
 208     consume(doCreateCellScanner(1, 1), 1 * 1);
 209     consume(doCreateCellScanner(3, 0), 3 * 0);
 210     consume(doCreateCellScanner(3, 3), 3 * 3);
 211     consume(doCreateCellScanner(0, 1), 0 * 1);
 212     // Do big number. See HBASE-11813 for why.
 213     final int hundredK = 100000;
 214     consume(doCreateCellScanner(hundredK, 0), hundredK * 0);
 215     consume(doCreateCellArray(1), 1);
 216     consume(doCreateCellArray(0), 0);
 217     consume(doCreateCellArray(3), 3);
 218     List<CellScannable> cells = new ArrayList<>(hundredK);
 219     for (int i = 0; i < hundredK; i++) {
 220       cells.add(new TestCellScannable(1));
 221     }
 222     consume(CellUtil.createCellScanner(cells), hundredK * 1);
 223     NavigableMap<byte [], List<Cell>> m = new TreeMap<>(Bytes.BYTES_COMPARATOR);
 224     List<Cell> cellArray = new ArrayList<>(hundredK);
 225     for (int i = 0; i < hundredK; i++) {
 226       cellArray.add(new TestCell(i));
 227     }
 228     m.put(new byte [] {'f'}, cellArray);
 229     consume(CellUtil.createCellScanner(m), hundredK * 1);
 230   }
 231
 232   private CellScanner doCreateCellArray(final int itemsPerList) {
 233     Cell [] cells = new Cell [itemsPerList];
 234     for (int i = 0; i < itemsPerList; i++) {
 235       cells[i] = new TestCell(i);
 236     }
 237     return CellUtil.createCellScanner(cells);
 238   }
 239
 240   private CellScanner doCreateCellScanner(final int listsCount, final int itemsPerList)
 241   throws IOException {
 242     List<CellScannable> cells = new ArrayList<>(listsCount);
 243     for (int i = 0; i < listsCount; i++) {
 244       CellScannable cs = new CellScannable() {
 245         @Override
 246         public CellScanner cellScanner() {
 247           return new TestCellScanner(itemsPerList);
 248         }
 249       };
 250       cells.add(cs);
 251     }
 252     return CellUtil.createCellScanner(cells);
 253   }
 254
 255   private void consume(final CellScanner scanner, final int expected) throws IOException {
 256     int count = 0;
 257     while (scanner.advance()) {
 258       count++;
 259     }
 260     Assert.assertEquals(expected, count);
 261   }
 262
 263   @Test
 264   public void testOverlappingKeys() {
 265     byte[] empty = HConstants.EMPTY_BYTE_ARRAY;
 266     byte[] a = Bytes.toBytes("a");
 267     byte[] b = Bytes.toBytes("b");
 268     byte[] c = Bytes.toBytes("c");
 269     byte[] d = Bytes.toBytes("d");
 270
 271     // overlaps
 272     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, b, a, b));
 273     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, c, a, b));
 274     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, b, a, c));
 275     Assert.assertTrue(PrivateCellUtil.overlappingKeys(b, c, a, c));
 276     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, c, b, c));
 277     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, d, b, c));
 278     Assert.assertTrue(PrivateCellUtil.overlappingKeys(b, c, a, d));
 279
 280     Assert.assertTrue(PrivateCellUtil.overlappingKeys(empty, b, a, b));
 281     Assert.assertTrue(PrivateCellUtil.overlappingKeys(empty, b, a, c));
 282
 283     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, b, empty, b));
 284     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, b, empty, c));
 285
 286     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, empty, a, b));
 287     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, empty, a, c));
 288
 289     Assert.assertTrue(PrivateCellUtil.overlappingKeys(a, b, empty, empty));
 290     Assert.assertTrue(PrivateCellUtil.overlappingKeys(empty, empty, a, b));
 291
 292     // non overlaps
 293     Assert.assertFalse(PrivateCellUtil.overlappingKeys(a, b, c, d));
 294     Assert.assertFalse(PrivateCellUtil.overlappingKeys(c, d, a, b));
 295
 296     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, c, d));
 297     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, c, empty));
 298     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, d, empty));
 299     Assert.assertFalse(PrivateCellUtil.overlappingKeys(c, d, b, c));
 300     Assert.assertFalse(PrivateCellUtil.overlappingKeys(c, empty, b, c));
 301     Assert.assertFalse(PrivateCellUtil.overlappingKeys(d, empty, b, c));
 302
 303     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, a, b));
 304     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, empty, b));
 305     Assert.assertFalse(PrivateCellUtil.overlappingKeys(b, c, empty, a));
 306     Assert.assertFalse(PrivateCellUtil.overlappingKeys(a,b, b, c));
 307     Assert.assertFalse(PrivateCellUtil.overlappingKeys(empty, b, b, c));
 308     Assert.assertFalse(PrivateCellUtil.overlappingKeys(empty, a, b, c));
 309   }
 310
 311   @Test
 312   public void testFindCommonPrefixInFlatKey() {
 313     // The whole key matching case
 314     KeyValue kv1 = new KeyValue("r1".getBytes(StandardCharsets.UTF_8),
 315       "f1".getBytes(StandardCharsets.UTF_8), "q1".getBytes(StandardCharsets.UTF_8), null);
 316     Assert.assertEquals(kv1.getKeyLength(),
 317       PrivateCellUtil.findCommonPrefixInFlatKey(kv1, kv1, true, true));
 318     Assert.assertEquals(kv1.getKeyLength(),
 319       PrivateCellUtil.findCommonPrefixInFlatKey(kv1, kv1, false, true));
 320     Assert.assertEquals(kv1.getKeyLength() - KeyValue.TIMESTAMP_TYPE_SIZE,
 321       PrivateCellUtil.findCommonPrefixInFlatKey(kv1, kv1, true, false));
 322     // The rk length itself mismatch
 323     KeyValue kv2 = new KeyValue("r12".getBytes(StandardCharsets.UTF_8),
 324         "f1".getBytes(StandardCharsets.UTF_8), "q1".getBytes(StandardCharsets.UTF_8), null);
 325     Assert.assertEquals(1, PrivateCellUtil.findCommonPrefixInFlatKey(kv1, kv2, true, true));
 326     // part of rk is same
 327     KeyValue kv3 = new KeyValue("r14".getBytes(StandardCharsets.UTF_8),
 328         "f1".getBytes(StandardCharsets.UTF_8), "q1".getBytes(StandardCharsets.UTF_8), null);
 329     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + "r1".getBytes(StandardCharsets.UTF_8).length,
 330       PrivateCellUtil.findCommonPrefixInFlatKey(kv2, kv3, true, true));
 331     // entire rk is same but different cf name
 332     KeyValue kv4 = new KeyValue("r14".getBytes(StandardCharsets.UTF_8),
 333       "f2".getBytes(StandardCharsets.UTF_8), "q1".getBytes(StandardCharsets.UTF_8), null);
 334     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + kv3.getRowLength() + KeyValue.FAMILY_LENGTH_SIZE
 335         + "f".getBytes(StandardCharsets.UTF_8).length,
 336         PrivateCellUtil.findCommonPrefixInFlatKey(kv3, kv4, false, true));
 337     // rk and family are same and part of qualifier
 338     KeyValue kv5 = new KeyValue("r14".getBytes(StandardCharsets.UTF_8),
 339       "f2".getBytes(StandardCharsets.UTF_8), "q123".getBytes(StandardCharsets.UTF_8), null);
 340     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + kv3.getRowLength() + KeyValue.FAMILY_LENGTH_SIZE
 341         + kv4.getFamilyLength() + kv4.getQualifierLength(),
 342         PrivateCellUtil.findCommonPrefixInFlatKey(kv4, kv5, true, true));
 343     // rk, cf and q are same. ts differs
 344     KeyValue kv6 = new KeyValue("rk".getBytes(StandardCharsets.UTF_8), 1234L);
 345     KeyValue kv7 = new KeyValue("rk".getBytes(StandardCharsets.UTF_8), 1235L);
 346     // only last byte out of 8 ts bytes in ts part differs
 347     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + kv6.getRowLength() + KeyValue.FAMILY_LENGTH_SIZE
 348         + kv6.getFamilyLength() + kv6.getQualifierLength() + 7,
 349         PrivateCellUtil.findCommonPrefixInFlatKey(kv6, kv7, true, true));
 350     // rk, cf, q and ts are same. Only type differs
 351     KeyValue kv8 = new KeyValue("rk".getBytes(StandardCharsets.UTF_8), 1234L, Type.Delete);
 352     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + kv6.getRowLength() + KeyValue.FAMILY_LENGTH_SIZE
 353         + kv6.getFamilyLength() + kv6.getQualifierLength() + KeyValue.TIMESTAMP_SIZE,
 354         PrivateCellUtil.findCommonPrefixInFlatKey(kv6, kv8, true, true));
 355     // With out TS_TYPE check
 356     Assert.assertEquals(KeyValue.ROW_LENGTH_SIZE + kv6.getRowLength() + KeyValue.FAMILY_LENGTH_SIZE
 357         + kv6.getFamilyLength() + kv6.getQualifierLength(),
 358         PrivateCellUtil.findCommonPrefixInFlatKey(kv6, kv8, true, false));
 359   }
 360
 361   /**
 362    * Assert CellUtil makes Cell toStrings same way we do KeyValue toStrings.
 363    */
 364   @Test
 365   public void testToString() {
 366     byte [] row = Bytes.toBytes("row");
 367     long ts = 123L;
 368     // Make a KeyValue and a Cell and see if same toString result.
 369     KeyValue kv = new KeyValue(row, HConstants.EMPTY_BYTE_ARRAY, HConstants.EMPTY_BYTE_ARRAY,
 370         ts, KeyValue.Type.Minimum, HConstants.EMPTY_BYTE_ARRAY);
 371     Cell cell = CellUtil.createCell(row, HConstants.EMPTY_BYTE_ARRAY, HConstants.EMPTY_BYTE_ARRAY,
 372         ts, KeyValue.Type.Minimum.getCode(), HConstants.EMPTY_BYTE_ARRAY);
 373     String cellToString = CellUtil.getCellKeyAsString(cell);
 374     assertEquals(kv.toString(), cellToString);
 375     // Do another w/ non-null family.
 376     byte [] f = new byte [] {'f'};
 377     byte [] q = new byte [] {'q'};
 378     kv = new KeyValue(row, f, q, ts, KeyValue.Type.Minimum, HConstants.EMPTY_BYTE_ARRAY);
 379     cell = CellUtil.createCell(row, f, q, ts, KeyValue.Type.Minimum.getCode(),
 380         HConstants.EMPTY_BYTE_ARRAY);
 381     cellToString = CellUtil.getCellKeyAsString(cell);
 382     assertEquals(kv.toString(), cellToString);
 383
 384   }
 385
 386   @Test
 387   public void testToString1() {
 388     String row = "test.row";
 389     String family = "test.family";
 390     String qualifier = "test.qualifier";
 391     long timestamp = 42;
 392     Type type = Type.Put;
 393     String value = "test.value";
 394     long seqId = 1042;
 395
 396     Cell cell = CellUtil.createCell(Bytes.toBytes(row), Bytes.toBytes(family),
 397       Bytes.toBytes(qualifier), timestamp, type.getCode(), Bytes.toBytes(value), seqId);
 398
 399     String nonVerbose = CellUtil.toString(cell, false);
 400     String verbose = CellUtil.toString(cell, true);
 401
 402     System.out.println("nonVerbose=" + nonVerbose);
 403     System.out.println("verbose=" + verbose);
 404
 405     Assert.assertEquals(
 406         String.format("%s/%s:%s/%d/%s/vlen=%s/seqid=%s",
 407           row, family, qualifier, timestamp, type.toString(),
 408           Bytes.toBytes(value).length, seqId),
 409         nonVerbose);
 410
 411     Assert.assertEquals(
 412       String.format("%s/%s:%s/%d/%s/vlen=%s/seqid=%s/%s",
 413         row, family, qualifier, timestamp, type.toString(), Bytes.toBytes(value).length,
 414         seqId, value),
 415       verbose);
 416
 417     // TODO: test with tags
 418   }
 419
 420   @Test
 421   public void testCloneCellFieldsFromByteBufferedCell() {
 422     byte[] r = Bytes.toBytes("row1");
 423     byte[] f = Bytes.toBytes("cf1");
 424     byte[] q = Bytes.toBytes("qual1");
 425     byte[] v = Bytes.toBytes("val1");
 426     byte[] tags = Bytes.toBytes("tag1");
 427     KeyValue kv = new KeyValue(r, f, q, 0, q.length, 1234L, Type.Put, v, 0, v.length, tags);
 428     ByteBuffer buffer = ByteBuffer.wrap(kv.getBuffer());
 429     Cell bbCell = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 430     byte[] rDest = CellUtil.cloneRow(bbCell);
 431     assertTrue(Bytes.equals(r, rDest));
 432     byte[] fDest = CellUtil.cloneFamily(bbCell);
 433     assertTrue(Bytes.equals(f, fDest));
 434     byte[] qDest = CellUtil.cloneQualifier(bbCell);
 435     assertTrue(Bytes.equals(q, qDest));
 436     byte[] vDest = CellUtil.cloneValue(bbCell);
 437     assertTrue(Bytes.equals(v, vDest));
 438     byte[] tDest = new byte[tags.length];
 439     PrivateCellUtil.copyTagsTo(bbCell, tDest, 0);
 440     assertTrue(Bytes.equals(tags, tDest));
 441   }
 442
 443   @Test
 444   public void testMatchingCellFieldsFromByteBufferedCell() {
 445     byte[] r = Bytes.toBytes("row1");
 446     byte[] f = Bytes.toBytes("cf1");
 447     byte[] q1 = Bytes.toBytes("qual1");
 448     byte[] q2 = Bytes.toBytes("qual2");
 449     byte[] v = Bytes.toBytes("val1");
 450     byte[] tags = Bytes.toBytes("tag1");
 451     KeyValue kv = new KeyValue(r, f, q1, 0, q1.length, 1234L, Type.Put, v, 0, v.length, tags);
 452     ByteBuffer buffer = ByteBuffer.wrap(kv.getBuffer());
 453     Cell bbCell1 = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 454     kv = new KeyValue(r, f, q2, 0, q2.length, 1234L, Type.Put, v, 0, v.length, tags);
 455     buffer = ByteBuffer.wrap(kv.getBuffer());
 456     Cell bbCell2 = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 457     assertTrue(CellUtil.matchingRows(bbCell1, bbCell2));
 458     assertTrue(CellUtil.matchingRows(kv, bbCell2));
 459     assertTrue(CellUtil.matchingRows(bbCell1, r));
 460     assertTrue(CellUtil.matchingFamily(bbCell1, bbCell2));
 461     assertTrue(CellUtil.matchingFamily(kv, bbCell2));
 462     assertTrue(CellUtil.matchingFamily(bbCell1, f));
 463     assertFalse(CellUtil.matchingQualifier(bbCell1, bbCell2));
 464     assertTrue(CellUtil.matchingQualifier(kv, bbCell2));
 465     assertTrue(CellUtil.matchingQualifier(bbCell1, q1));
 466     assertTrue(CellUtil.matchingQualifier(bbCell2, q2));
 467     assertTrue(CellUtil.matchingValue(bbCell1, bbCell2));
 468     assertTrue(CellUtil.matchingValue(kv, bbCell2));
 469     assertTrue(CellUtil.matchingValue(bbCell1, v));
 470     assertFalse(CellUtil.matchingColumn(bbCell1, bbCell2));
 471     assertTrue(CellUtil.matchingColumn(kv, bbCell2));
 472     assertTrue(CellUtil.matchingColumn(bbCell1, f, q1));
 473     assertTrue(CellUtil.matchingColumn(bbCell2, f, q2));
 474   }
 475
 476   @Test
 477   public void testCellFieldsAsPrimitiveTypesFromByteBufferedCell() {
 478     int ri = 123;
 479     byte[] r = Bytes.toBytes(ri);
 480     byte[] f = Bytes.toBytes("cf1");
 481     byte[] q = Bytes.toBytes("qual1");
 482     long vl = 10981L;
 483     byte[] v = Bytes.toBytes(vl);
 484     KeyValue kv = new KeyValue(r, f, q, v);
 485     ByteBuffer buffer = ByteBuffer.wrap(kv.getBuffer());
 486     Cell bbCell = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 487     assertEquals(ri, PrivateCellUtil.getRowAsInt(bbCell));
 488     assertEquals(vl, PrivateCellUtil.getValueAsLong(bbCell));
 489     double vd = 3005.5;
 490     v = Bytes.toBytes(vd);
 491     kv = new KeyValue(r, f, q, v);
 492     buffer = ByteBuffer.wrap(kv.getBuffer());
 493     bbCell = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 494     assertEquals(vd, PrivateCellUtil.getValueAsDouble(bbCell), 0.0);
 495     BigDecimal bd = new BigDecimal(9999);
 496     v = Bytes.toBytes(bd);
 497     kv = new KeyValue(r, f, q, v);
 498     buffer = ByteBuffer.wrap(kv.getBuffer());
 499     bbCell = new ByteBufferKeyValue(buffer, 0, buffer.remaining());
 500     assertEquals(bd, PrivateCellUtil.getValueAsBigDecimal(bbCell));
 501   }
 502
 503   @Test
 504   public void testWriteCell() throws IOException {
 505     byte[] r = Bytes.toBytes("row1");
 506     byte[] f = Bytes.toBytes("cf1");
 507     byte[] q1 = Bytes.toBytes("qual1");
 508     byte[] q2 = Bytes.toBytes("qual2");
 509     byte[] v = Bytes.toBytes("val1");
 510     byte[] tags = Bytes.toBytes("tag1");
 511     KeyValue kv = new KeyValue(r, f, q1, 0, q1.length, 1234L, Type.Put, v, 0, v.length, tags);
 512     NonExtendedCell nonExtCell = new NonExtendedCell(kv);
 513     ByteArrayOutputStream os = new ByteArrayOutputStream();
 514     int writeCell = PrivateCellUtil.writeCell(nonExtCell, os, true);
 515     byte[] byteArray = os.toByteArray();
 516     KeyValue res = new KeyValue(byteArray);
 517     assertTrue(CellUtil.equals(kv, res));
 518   }
 519
 520   private static class NonExtendedCell implements Cell {
 521     private KeyValue kv;
 522
 523     public NonExtendedCell(KeyValue kv) {
 524       this.kv = kv;
 525     }
 526
 527     @Override
 528     public byte[] getRowArray() {
 529       return this.kv.getRowArray();
 530     }
 531
 532     @Override
 533     public int getRowOffset() {
 534       return this.kv.getRowOffset();
 535     }
 536
 537     @Override
 538     public short getRowLength() {
 539       return this.kv.getRowLength();
 540     }
 541
 542     @Override
 543     public byte[] getFamilyArray() {
 544       return this.kv.getFamilyArray();
 545     }
 546
 547     @Override
 548     public int getFamilyOffset() {
 549       return this.kv.getFamilyOffset();
 550     }
 551
 552     @Override
 553     public byte getFamilyLength() {
 554       return this.kv.getFamilyLength();
 555     }
 556
 557     @Override
 558     public byte[] getQualifierArray() {
 559       return this.kv.getQualifierArray();
 560     }
 561
 562     @Override
 563     public int getQualifierOffset() {
 564       return this.kv.getQualifierOffset();
 565     }
 566
 567     @Override
 568     public int getQualifierLength() {
 569       return this.kv.getQualifierLength();
 570     }
 571
 572     @Override
 573     public long getTimestamp() {
 574       return this.kv.getTimestamp();
 575     }
 576
 577     @Override
 578     public byte getTypeByte() {
 579       return this.kv.getTypeByte();
 580     }
 581
 582     @Override
 583     public long getSequenceId() {
 584       return this.kv.getSequenceId();
 585     }
 586
 587     @Override
 588     public byte[] getValueArray() {
 589       return this.kv.getValueArray();
 590     }
 591
 592     @Override
 593     public int getValueOffset() {
 594       return this.kv.getValueOffset();
 595     }
 596
 597     @Override
 598     public int getValueLength() {
 599       return this.kv.getValueLength();
 600     }
 601
 602     @Override
 603     public byte[] getTagsArray() {
 604       return this.kv.getTagsArray();
 605     }
 606
 607     @Override
 608     public int getTagsOffset() {
 609       return this.kv.getTagsOffset();
 610     }
 611
 612     @Override
 613     public int getTagsLength() {
 614       return this.kv.getTagsLength();
 615     }
 616   }
 617 }