/**
    * 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.hadoop.hbase;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.hadoop.hbase.client.ClientScanner;
  import org.apache.hadoop.hbase.client.Delete;
  import org.apache.hadoop.hbase.client.Put;
  import org.apache.hadoop.hbase.client.Result;
  import org.apache.hadoop.hbase.client.ResultScanner;
  import org.apache.hadoop.hbase.client.Scan;
  import org.apache.hadoop.hbase.client.Table;
  import org.apache.hadoop.hbase.filter.ColumnPrefixFilter;
  import org.apache.hadoop.hbase.filter.ColumnRangeFilter;
  import org.apache.hadoop.hbase.filter.Filter;
  import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;
  import org.apache.hadoop.hbase.filter.FirstKeyValueMatchingQualifiersFilter;
  import org.apache.hadoop.hbase.filter.RandomRowFilter;
  import org.apache.hadoop.hbase.testclassification.MediumTests;
  import org.apache.hadoop.hbase.util.Bytes;
  import org.junit.AfterClass;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import org.junit.experimental.categories.Category;
  
  /**
   * These tests are focused on testing how partial results appear to a client. Partial results are
   * {@link Result}s that contain only a portion of a row's complete list of cells. Partial results
   * are formed when the server breaches its maximum result size when trying to service a client's RPC
   * request. It is the responsibility of the scanner on the client side to recognize when partial
   * results have been returned and to take action to form the complete results.
   * <p>
   * Unless the flag {@link Scan#setAllowPartialResults(boolean)} has been set to true, the caller of
   * {@link ResultScanner#next()} should never see partial results.
   */
  @Category(MediumTests.class)
  public class TestPartialResultsFromClientSide {
    private static final Log LOG = LogFactory.getLog(TestPartialResultsFromClientSide.class);
  
    private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
  
    private static Table TABLE = null;
  
    /**
     * Table configuration
     */
    private static TableName TABLE_NAME = TableName.valueOf("testTable");
  
    private static int NUM_ROWS = 5;
    private static byte[] ROW = Bytes.toBytes("testRow");
    private static byte[][] ROWS = HTestConst.makeNAscii(ROW, NUM_ROWS);
  
    // Should keep this value below 10 to keep generation of expected kv's simple. If above 10 then
    // table/row/cf1/... will be followed by table/row/cf10/... instead of table/row/cf2/... which
    // breaks the simple generation of expected kv's
    private static int NUM_FAMILIES = 10;
    private static byte[] FAMILY = Bytes.toBytes("testFamily");
    private static byte[][] FAMILIES = HTestConst.makeNAscii(FAMILY, NUM_FAMILIES);
  
    private static int NUM_QUALIFIERS = 10;
    private static byte[] QUALIFIER = Bytes.toBytes("testQualifier");
    private static byte[][] QUALIFIERS = HTestConst.makeNAscii(QUALIFIER, NUM_QUALIFIERS);
  
    private static int VALUE_SIZE = 1024;
    private static byte[] VALUE = Bytes.createMaxByteArray(VALUE_SIZE);
  
    private static int NUM_COLS = NUM_FAMILIES * NUM_QUALIFIERS;
  
    // Approximation of how large the heap size of cells in our table. Should be accessed through
    // getCellHeapSize().
    private static long CELL_HEAP_SIZE = -1;
  
   @BeforeClass
   public static void setUpBeforeClass() throws Exception {
     TEST_UTIL.startMiniCluster(3);
     TABLE = createTestTable(TABLE_NAME, ROWS, FAMILIES, QUALIFIERS, VALUE);
   }
 
   static Table createTestTable(TableName name, byte[][] rows, byte[][] families,
       byte[][] qualifiers, byte[] cellValue) throws IOException {
     Table ht = TEST_UTIL.createTable(name, families);
     List<Put> puts = createPuts(rows, families, qualifiers, cellValue);
     ht.put(puts);
 
     return ht;
   }
 
   @AfterClass
   public static void tearDownAfterClass() throws Exception {
     TEST_UTIL.shutdownMiniCluster();
   }
 
   /**
    * Ensure that the expected key values appear in a result returned from a scanner that is
    * combining partial results into complete results
    * @throws Exception
    */
   @Test
   public void testExpectedValuesOfPartialResults() throws Exception {
     testExpectedValuesOfPartialResults(false);
     testExpectedValuesOfPartialResults(true);
   }
 
   public void testExpectedValuesOfPartialResults(boolean reversed) throws Exception {
     Scan partialScan = new Scan();
     partialScan.setMaxVersions();
     // Max result size of 1 ensures that each RPC request will return a single cell. The scanner
     // will need to reconstruct the results into a complete result before returning to the caller
     partialScan.setMaxResultSize(1);
     partialScan.setReversed(reversed);
     ResultScanner partialScanner = TABLE.getScanner(partialScan);
 
     final int startRow = reversed ? ROWS.length - 1 : 0;
     final int endRow = reversed ? -1 : ROWS.length;
     final int loopDelta = reversed ? -1 : 1;
     String message;
 
     for (int row = startRow; row != endRow; row = row + loopDelta) {
       message = "Ensuring the expected keyValues are present for row " + row;
       List<Cell> expectedKeyValues = createKeyValuesForRow(ROWS[row], FAMILIES, QUALIFIERS, VALUE);
       Result result = partialScanner.next();
       assertFalse(result.isPartial());
       verifyResult(result, expectedKeyValues, message);
     }
 
     partialScanner.close();
   }
 
   /**
    * Ensure that we only see Results marked as partial when the allowPartial flag is set
    * @throws Exception
    */
   @Test
   public void testAllowPartialResults() throws Exception {
     Scan scan = new Scan();
     scan.setAllowPartialResults(true);
     scan.setMaxResultSize(1);
     ResultScanner scanner = TABLE.getScanner(scan);
     Result result = scanner.next();
 
     assertTrue(result != null);
     assertTrue(result.isPartial());
     assertTrue(result.rawCells() != null);
     assertTrue(result.rawCells().length == 1);
 
     scanner.close();
 
     scan.setAllowPartialResults(false);
     scanner = TABLE.getScanner(scan);
     result = scanner.next();
 
     assertTrue(result != null);
     assertTrue(!result.isPartial());
     assertTrue(result.rawCells() != null);
     assertTrue(result.rawCells().length == NUM_COLS);
 
     scanner.close();
   }
 
   /**
    * Ensure that the results returned from a scanner that retrieves all results in a single RPC call
    * matches the results that are returned from a scanner that must incrementally combine partial
    * results into complete results. A variety of scan configurations can be tested
    * @throws Exception
    */
   @Test
   public void testEquivalenceOfScanResults() throws Exception {
     Scan oneShotScan = new Scan();
     oneShotScan.setMaxResultSize(Long.MAX_VALUE);
 
     Scan partialScan = new Scan(oneShotScan);
     partialScan.setMaxResultSize(1);
 
     testEquivalenceOfScanResults(TABLE, oneShotScan, partialScan);
   }
 
   public void testEquivalenceOfScanResults(Table table, Scan scan1, Scan scan2) throws Exception {
     ResultScanner scanner1 = table.getScanner(scan1);
     ResultScanner scanner2 = table.getScanner(scan2);
 
     Result r1 = null;
     Result r2 = null;
     int count = 0;
 
     while ((r1 = scanner1.next()) != null) {
       r2 = scanner2.next();
 
       assertTrue(r2 != null);
       compareResults(r1, r2, "Comparing result #" + count);
       count++;
     }
 
     r2 = scanner2.next();
     assertTrue("r2: " + r2 + " Should be null", r2 == null);
 
     scanner1.close();
     scanner2.close();
   }
 
   /**
    * Order of cells in partial results matches the ordering of cells from complete results
    * @throws Exception
    */
   @Test
   public void testOrderingOfCellsInPartialResults() throws Exception {
     Scan scan = new Scan();
 
     for (int col = 1; col <= NUM_COLS; col++) {
       scan.setMaxResultSize(getResultSizeForNumberOfCells(col));
       testOrderingOfCellsInPartialResults(scan);
 
       // Test again with a reversed scanner
       scan.setReversed(true);
       testOrderingOfCellsInPartialResults(scan);
     }
   }
 
   public void testOrderingOfCellsInPartialResults(final Scan basePartialScan) throws Exception {
     // Scan that retrieves results in pieces (partials). By setting allowPartialResults to be true
     // the results will NOT be reconstructed and instead the caller will see the partial results
     // returned by the server
     Scan partialScan = new Scan(basePartialScan);
     partialScan.setAllowPartialResults(true);
     ResultScanner partialScanner = TABLE.getScanner(partialScan);
 
     // Scan that retrieves all table results in single RPC request
     Scan oneShotScan = new Scan(basePartialScan);
     oneShotScan.setMaxResultSize(Long.MAX_VALUE);
     oneShotScan.setCaching(ROWS.length);
     ResultScanner oneShotScanner = TABLE.getScanner(oneShotScan);
 
     Result oneShotResult = oneShotScanner.next();
     Result partialResult = null;
     int iterationCount = 0;
 
     while (oneShotResult != null && oneShotResult.rawCells() != null) {
       List<Cell> aggregatePartialCells = new ArrayList<Cell>();
       do {
         partialResult = partialScanner.next();
         assertTrue("Partial Result is null. iteration: " + iterationCount, partialResult != null);
         assertTrue("Partial cells are null. iteration: " + iterationCount,
           partialResult.rawCells() != null);
 
         for (Cell c : partialResult.rawCells()) {
           aggregatePartialCells.add(c);
         }
       } while (partialResult.isPartial());
 
       assertTrue("Number of cells differs. iteration: " + iterationCount,
         oneShotResult.rawCells().length == aggregatePartialCells.size());
       final Cell[] oneShotCells = oneShotResult.rawCells();
       for (int cell = 0; cell < oneShotCells.length; cell++) {
         Cell oneShotCell = oneShotCells[cell];
         Cell partialCell = aggregatePartialCells.get(cell);
 
         assertTrue("One shot cell was null", oneShotCell != null);
         assertTrue("Partial cell was null", partialCell != null);
         assertTrue("Cell differs. oneShotCell:" + oneShotCell + " partialCell:" + partialCell,
           oneShotCell.equals(partialCell));
       }
 
       oneShotResult = oneShotScanner.next();
       iterationCount++;
     }
 
     assertTrue(partialScanner.next() == null);
 
     partialScanner.close();
     oneShotScanner.close();
   }
 
   /**
    * Setting the max result size allows us to control how many cells we expect to see on each call
    * to next on the scanner. Test a variety of different sizes for correctness
    * @throws Exception
    */
   @Test
   public void testExpectedNumberOfCellsPerPartialResult() throws Exception {
     Scan scan = new Scan();
     testExpectedNumberOfCellsPerPartialResult(scan);
 
     scan.setReversed(true);
     testExpectedNumberOfCellsPerPartialResult(scan);
   }
 
   public void testExpectedNumberOfCellsPerPartialResult(Scan baseScan) throws Exception {
     for (int expectedCells = 1; expectedCells <= NUM_COLS; expectedCells++) {
       testExpectedNumberOfCellsPerPartialResult(baseScan, expectedCells);
     }
   }
 
   public void testExpectedNumberOfCellsPerPartialResult(Scan baseScan, int expectedNumberOfCells)
       throws Exception {
 
     if (LOG.isInfoEnabled()) LOG.info("groupSize:" + expectedNumberOfCells);
 
     // Use the cellHeapSize to set maxResultSize such that we know how many cells to expect back
     // from the call. The returned results should NOT exceed expectedNumberOfCells but may be less
     // than it in cases where expectedNumberOfCells is not an exact multiple of the number of
     // columns in the table.
     Scan scan = new Scan(baseScan);
     scan.setAllowPartialResults(true);
     scan.setMaxResultSize(getResultSizeForNumberOfCells(expectedNumberOfCells));
 
     ResultScanner scanner = TABLE.getScanner(scan);
     Result result = null;
     byte[] prevRow = null;
     while ((result = scanner.next()) != null) {
       assertTrue(result.rawCells() != null);
 
       // Cases when cell count won't equal expectedNumberOfCells:
       // 1. Returned result is the final result needed to form the complete result for that row
       // 2. It is the first result we have seen for that row and thus may have been fetched as
       // the last group of cells that fit inside the maxResultSize
       assertTrue(
         "Result's cell count differed from expected number. result: " + result,
         result.rawCells().length == expectedNumberOfCells || !result.isPartial()
           || !Bytes.equals(prevRow, result.getRow()));
       prevRow = result.getRow();
     }
 
     scanner.close();
   }
 
   /**
    * @return The approximate heap size of a cell in the test table. All cells should have
    *         approximately the same heap size, so the value is cached to avoid repeating the
    *         calculation
    * @throws Exception
    */
   private long getCellHeapSize() throws Exception {
     if (CELL_HEAP_SIZE == -1) {
       // Do a partial scan that will return a single result with a single cell
       Scan scan = new Scan();
       scan.setMaxResultSize(1);
       scan.setAllowPartialResults(true);
       ResultScanner scanner = TABLE.getScanner(scan);
 
       Result result = scanner.next();
 
       assertTrue(result != null);
       assertTrue(result.rawCells() != null);
       assertTrue(result.rawCells().length == 1);
 
       CELL_HEAP_SIZE = CellUtil.estimatedHeapSizeOf(result.rawCells()[0]);
       if (LOG.isInfoEnabled()) LOG.info("Cell heap size: " + CELL_HEAP_SIZE);
       scanner.close();
     }
 
     return CELL_HEAP_SIZE;
   }
 
   /**
    * @param numberOfCells
    * @return the result size that should be used in {@link Scan#setMaxResultSize(long)} if you want
    *         the server to return exactly numberOfCells cells
    * @throws Exception
    */
   private long getResultSizeForNumberOfCells(int numberOfCells) throws Exception {
     return getCellHeapSize() * numberOfCells;
   }
 
   /**
    * Test various combinations of batching and partial results for correctness
    */
   @Test
   public void testPartialResultsAndBatch() throws Exception {
     for (int batch = 1; batch <= NUM_COLS / 4; batch++) {
       for (int cellsPerPartial = 1; cellsPerPartial <= NUM_COLS / 4; cellsPerPartial++) {
         testPartialResultsAndBatch(batch, cellsPerPartial);
       }
     }
   }
 
   public void testPartialResultsAndBatch(final int batch, final int cellsPerPartialResult)
       throws Exception {
     if (LOG.isInfoEnabled()) {
       LOG.info("batch: " + batch + " cellsPerPartialResult: " + cellsPerPartialResult);
     }
 
     Scan scan = new Scan();
     scan.setMaxResultSize(getResultSizeForNumberOfCells(cellsPerPartialResult));
     scan.setBatch(batch);
     ResultScanner scanner = TABLE.getScanner(scan);
     Result result = scanner.next();
     int repCount = 0;
 
     while ((result = scanner.next()) != null) {
       assertTrue(result.rawCells() != null);
 
       if (result.isPartial()) {
         final String error =
             "Cells:" + result.rawCells().length + " Batch size:" + batch
                 + " cellsPerPartialResult:" + cellsPerPartialResult + " rep:" + repCount;
         assertTrue(error, result.rawCells().length <= Math.min(batch, cellsPerPartialResult));
       } else {
         assertTrue(result.rawCells().length <= batch);
       }
       repCount++;
     }
 
     scanner.close();
   }
 
   /**
    * Test the method {@link Result#createCompleteResult(List, Result)}
    * @throws Exception
    */
   @Test
   public void testPartialResultsReassembly() throws Exception {
     Scan scan = new Scan();
     testPartialResultsReassembly(scan);
     scan.setReversed(true);
     testPartialResultsReassembly(scan);
   }
 
   public void testPartialResultsReassembly(Scan scanBase) throws Exception {
     Scan partialScan = new Scan(scanBase);
     partialScan.setMaxResultSize(1);
     partialScan.setAllowPartialResults(true);
     ResultScanner partialScanner = TABLE.getScanner(partialScan);
 
     Scan oneShotScan = new Scan(scanBase);
     oneShotScan.setMaxResultSize(Long.MAX_VALUE);
     ResultScanner oneShotScanner = TABLE.getScanner(oneShotScan);
 
     ArrayList<Result> partials = new ArrayList<>();
     for (int i = 0; i < NUM_ROWS; i++) {
       Result partialResult = null;
       Result completeResult = null;
       Result oneShotResult = null;
       partials.clear();
 
       do {
         partialResult = partialScanner.next();
         partials.add(partialResult);
       } while (partialResult != null && partialResult.isPartial());
 
       completeResult = Result.createCompleteResult(partials);
       oneShotResult = oneShotScanner.next();
 
       compareResults(completeResult, oneShotResult, null);
     }
 
     assertTrue(oneShotScanner.next() == null);
     assertTrue(partialScanner.next() == null);
 
     oneShotScanner.close();
     partialScanner.close();
   }
 
   /**
    * When reconstructing the complete result from its partials we ensure that the row of each
    * partial result is the same. If one of the rows differs, an exception is thrown.
    */
   @Test
   public void testExceptionThrownOnMismatchedPartialResults() throws IOException {
     assertTrue(NUM_ROWS >= 2);
 
     ArrayList<Result> partials = new ArrayList<>();
     Scan scan = new Scan();
     scan.setMaxResultSize(Long.MAX_VALUE);
     ResultScanner scanner = TABLE.getScanner(scan);
     Result r1 = scanner.next();
     partials.add(r1);
     Result r2 = scanner.next();
     partials.add(r2);
 
     assertFalse(Bytes.equals(r1.getRow(), r2.getRow()));
 
     try {
       Result.createCompleteResult(partials);
       fail("r1 and r2 are from different rows. It should not be possible to combine them into"
           + " a single result");
     } catch (IOException e) {
     }
 
     scanner.close();
   }
 
   /**
    * When a scan has a filter where {@link org.apache.hadoop.hbase.filter.Filter#hasFilterRow()} is
    * true, the scanner should not return partial results. The scanner cannot return partial results
    * because the entire row needs to be read for the include/exclude decision to be made
    */
   @Test
   public void testNoPartialResultsWhenRowFilterPresent() throws Exception {
     Scan scan = new Scan();
     scan.setMaxResultSize(1);
     scan.setAllowPartialResults(true);
     // If a filter hasFilter() is true then partial results should not be returned else filter
     // application server side would break.
     scan.setFilter(new RandomRowFilter(1.0f));
     ResultScanner scanner = TABLE.getScanner(scan);
 
     Result r = null;
     while ((r = scanner.next()) != null) {
       assertFalse(r.isPartial());
     }
 
     scanner.close();
   }
 
   /**
    * Examine the interaction between the maxResultSize and caching. If the caching limit is reached
    * before the maxResultSize limit, we should not see partial results. On the other hand, if the
    * maxResultSize limit is reached before the caching limit, it is likely that partial results will
    * be seen.
    * @throws Exception
    */
   @Test
   public void testPartialResultsAndCaching() throws Exception {
     for (int caching = 1; caching <= NUM_ROWS; caching++) {
       for (int maxResultRows = 0; maxResultRows <= NUM_ROWS; maxResultRows++) {
         testPartialResultsAndCaching(maxResultRows, caching);
       }
     }
   }
 
   /**
    * @param resultSizeRowLimit The row limit that will be enforced through maxResultSize
    * @param cachingRowLimit The row limit that will be enforced through caching
    * @throws Exception
    */
   public void testPartialResultsAndCaching(int resultSizeRowLimit, int cachingRowLimit)
       throws Exception {
     Scan scan = new Scan();
     scan.setAllowPartialResults(true);
 
     // The number of cells specified in the call to getResultSizeForNumberOfCells is offset to
     // ensure that the result size we specify is not an exact multiple of the number of cells
     // in a row. This ensures that partial results will be returned when the result size limit
     // is reached before the caching limit.
     int cellOffset = NUM_COLS / 3;
     long maxResultSize = getResultSizeForNumberOfCells(resultSizeRowLimit * NUM_COLS + cellOffset);
     scan.setMaxResultSize(maxResultSize);
     scan.setCaching(cachingRowLimit);
 
     ResultScanner scanner = TABLE.getScanner(scan);
     ClientScanner clientScanner = (ClientScanner) scanner;
     Result r = null;
 
     // Approximate the number of rows we expect will fit into the specified max rsult size. If this
     // approximation is less than caching, then we expect that the max result size limit will be
     // hit before the caching limit and thus partial results may be seen
     boolean expectToSeePartialResults = resultSizeRowLimit < cachingRowLimit;
     while ((r = clientScanner.next()) != null) {
       assertTrue(!r.isPartial() || expectToSeePartialResults);
     }
 
     scanner.close();
   }
 
   /**
    * Small scans should not return partial results because it would prevent small scans from
    * retrieving all of the necessary results in a single RPC request which is what makese small
    * scans useful. Thus, ensure that even when {@link Scan#getAllowPartialResults()} is true, small
    * scans do not return partial results
    * @throws Exception
    */
   @Test
   public void testSmallScansDoNotAllowPartials() throws Exception {
     Scan scan = new Scan();
     testSmallScansDoNotAllowPartials(scan);
     scan.setReversed(true);
     testSmallScansDoNotAllowPartials(scan);
   }
 
   public void testSmallScansDoNotAllowPartials(Scan baseScan) throws Exception {
     Scan scan = new Scan(baseScan);
     scan.setAllowPartialResults(true);
     scan.setSmall(true);
     scan.setMaxResultSize(1);
 
     ResultScanner scanner = TABLE.getScanner(scan);
     Result r = null;
 
     while ((r = scanner.next()) != null) {
       assertFalse(r.isPartial());
     }
 
     scanner.close();
   }
 
   /**
    * Make puts to put the input value into each combination of row, family, and qualifier
    * @param rows
    * @param families
    * @param qualifiers
    * @param value
    * @return
    * @throws IOException
    */
   static ArrayList<Put> createPuts(byte[][] rows, byte[][] families, byte[][] qualifiers,
       byte[] value) throws IOException {
     Put put;
     ArrayList<Put> puts = new ArrayList<>();
 
     for (int row = 0; row < rows.length; row++) {
       put = new Put(rows[row]);
       for (int fam = 0; fam < families.length; fam++) {
         for (int qual = 0; qual < qualifiers.length; qual++) {
           KeyValue kv = new KeyValue(rows[row], families[fam], qualifiers[qual], qual, value);
           put.add(kv);
         }
       }
       puts.add(put);
     }
 
     return puts;
   }
 
   /**
    * Make key values to represent each possible combination of family and qualifier in the specified
    * row.
    * @param row
    * @param families
    * @param qualifiers
    * @param value
    * @return
    */
   static ArrayList<Cell> createKeyValuesForRow(byte[] row, byte[][] families, byte[][] qualifiers,
       byte[] value) {
     ArrayList<Cell> outList = new ArrayList<>();
     for (int fam = 0; fam < families.length; fam++) {
       for (int qual = 0; qual < qualifiers.length; qual++) {
         outList.add(new KeyValue(row, families[fam], qualifiers[qual], qual, value));
       }
     }
     return outList;
   }
 
   /**
    * Verifies that result contains all the key values within expKvList. Fails the test otherwise
    * @param result
    * @param expKvList
    * @param msg
    */
   static void verifyResult(Result result, List<Cell> expKvList, String msg) {
     if (LOG.isInfoEnabled()) {
       LOG.info(msg);
       LOG.info("Expected count: " + expKvList.size());
       LOG.info("Actual count: " + result.size());
     }
 
     if (expKvList.size() == 0) return;
 
     int i = 0;
     for (Cell kv : result.rawCells()) {
       if (i >= expKvList.size()) {
         break; // we will check the size later
       }
 
       Cell kvExp = expKvList.get(i++);
       assertTrue("Not equal. get kv: " + kv.toString() + " exp kv: " + kvExp.toString(),
         kvExp.equals(kv));
     }
 
     assertEquals(expKvList.size(), result.size());
   }
 
   /**
    * Compares two results and fails the test if the results are different
    * @param r1
    * @param r2
    * @param message
    */
   static void compareResults(Result r1, Result r2, final String message) {
     if (LOG.isInfoEnabled()) {
       if (message != null) LOG.info(message);
       LOG.info("r1: " + r1);
       LOG.info("r2: " + r2);
     }
 
     final String failureMessage = "Results r1:" + r1 + " \nr2:" + r2 + " are not equivalent";
     if (r1 == null && r2 == null) fail(failureMessage);
     else if (r1 == null || r2 == null) fail(failureMessage);
 
     try {
       Result.compareResults(r1, r2);
     } catch (Exception e) {
       fail(failureMessage);
     }
   }
 
   @Test
   public void testReadPointAndPartialResults() throws Exception {
     TableName testName = TableName.valueOf("testReadPointAndPartialResults");
     int numRows = 5;
     int numFamilies = 5;
     int numQualifiers = 5;
     byte[][] rows = HTestConst.makeNAscii(Bytes.toBytes("testRow"), numRows);
     byte[][] families = HTestConst.makeNAscii(Bytes.toBytes("testFamily"), numFamilies);
     byte[][] qualifiers = HTestConst.makeNAscii(Bytes.toBytes("testQualifier"), numQualifiers);
     byte[] value = Bytes.createMaxByteArray(100);
 
     Table tmpTable = createTestTable(testName, rows, families, qualifiers, value);
 
     Scan scan = new Scan();
     scan.setMaxResultSize(1);
     scan.setAllowPartialResults(true);
 
     // Open scanner before deletes
     ResultScanner scanner = tmpTable.getScanner(scan);
 
     Delete delete1 = new Delete(rows[0]);
     delete1.addColumn(families[0], qualifiers[0], 0);
     tmpTable.delete(delete1);
 
     Delete delete2 = new Delete(rows[1]);
     delete2.addColumn(families[1], qualifiers[1], 1);
     tmpTable.delete(delete2);
 
     // Should see all cells because scanner was opened prior to deletes
     int scannerCount = countCellsFromScanner(scanner);
     int expectedCount = numRows * numFamilies * numQualifiers;
     assertTrue("scannerCount: " + scannerCount + " expectedCount: " + expectedCount,
       scannerCount == expectedCount);
 
     // Minus 2 for the two cells that were deleted
     scanner = tmpTable.getScanner(scan);
     scannerCount = countCellsFromScanner(scanner);
     expectedCount = numRows * numFamilies * numQualifiers - 2;
     assertTrue("scannerCount: " + scannerCount + " expectedCount: " + expectedCount,
       scannerCount == expectedCount);
 
     scanner = tmpTable.getScanner(scan);
     // Put in 2 new rows. The timestamps differ from the deleted rows
     Put put1 = new Put(rows[0]);
     put1.add(new KeyValue(rows[0], families[0], qualifiers[0], 1, value));
     tmpTable.put(put1);
 
     Put put2 = new Put(rows[1]);
     put2.add(new KeyValue(rows[1], families[1], qualifiers[1], 2, value));
     tmpTable.put(put2);
 
     // Scanner opened prior to puts. Cell count shouldn't have changed
     scannerCount = countCellsFromScanner(scanner);
     expectedCount = numRows * numFamilies * numQualifiers - 2;
     assertTrue("scannerCount: " + scannerCount + " expectedCount: " + expectedCount,
       scannerCount == expectedCount);
 
     // Now the scanner should see the cells that were added by puts
     scanner = tmpTable.getScanner(scan);
     scannerCount = countCellsFromScanner(scanner);
     expectedCount = numRows * numFamilies * numQualifiers;
     assertTrue("scannerCount: " + scannerCount + " expectedCount: " + expectedCount,
       scannerCount == expectedCount);
 
     TEST_UTIL.deleteTable(testName);
   }
 
   /**
    * Exhausts the scanner by calling next repetitively. Once completely exhausted, close scanner and
    * return total cell count
    * @param scanner
    * @return
    * @throws Exception
    */
   private int countCellsFromScanner(ResultScanner scanner) throws Exception {
     Result result = null;
     int numCells = 0;
     while ((result = scanner.next()) != null) {
       numCells += result.rawCells().length;
     }
 
     scanner.close();
     return numCells;
   }
 
   /**
    * Test partial Result re-assembly in the presence of different filters. The Results from the
    * partial scanner should match the Results returned from a scanner that receives all of the
    * results in one RPC to the server. The partial scanner is tested with a variety of different
    * result sizes (all of which are less than the size necessary to fetch an entire row)
    * @throws Exception
    */
   @Test
   public void testPartialResultsWithColumnFilter() throws Exception {
     testPartialResultsWithColumnFilter(new FirstKeyOnlyFilter());
     testPartialResultsWithColumnFilter(new ColumnPrefixFilter(Bytes.toBytes("testQualifier5")));
     testPartialResultsWithColumnFilter(new ColumnRangeFilter(Bytes.toBytes("testQualifer1"), true,
         Bytes.toBytes("testQualifier7"), true));
 
     Set<byte[]> qualifiers = new LinkedHashSet<>();
     qualifiers.add(Bytes.toBytes("testQualifier5"));
     testPartialResultsWithColumnFilter(new FirstKeyValueMatchingQualifiersFilter(qualifiers));
   }
 
   public void testPartialResultsWithColumnFilter(Filter filter) throws Exception {
     assertTrue(!filter.hasFilterRow());
 
     Scan partialScan = new Scan();
     partialScan.setFilter(filter);
 
     Scan oneshotScan = new Scan();
     oneshotScan.setFilter(filter);
     oneshotScan.setMaxResultSize(Long.MAX_VALUE);
 
     for (int i = 1; i <= NUM_COLS; i++) {
       partialScan.setMaxResultSize(getResultSizeForNumberOfCells(i));
       testEquivalenceOfScanResults(TABLE, partialScan, oneshotScan);
     }
   }
 }