Java 类org.apache.hadoop.hbase.util.RegionSplitter.HexStringSplit 实例源码

项目：LCIndex-HBase-0.94.16 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：HIndex 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：IRIndex 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：PyroDB 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：c5 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：HBase-Research 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：hbase-0.94.8-qod 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：hbase-0.94.8-qod 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：DominoHBase 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：hindex 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
  preSplitTableAndVerify(expectedBounds,
      HexStringSplit.class.getSimpleName(), "NewHexPresplitTable");
}

项目：ditb 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
preSplitTableAndVerify(expectedBounds,
    HexStringSplit.class.getSimpleName(),
    TableName.valueOf("NewHexPresplitTable"));
}

项目：ditb 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：LCIndex-HBase-0.94.16 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：pbase 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<byte[]>();
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
preSplitTableAndVerify(expectedBounds,
    HexStringSplit.class.getSimpleName(),
    TableName.valueOf("NewHexPresplitTable"));
}

项目：pbase 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：HIndex 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：IRIndex 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：hbase 文件：TestRegionSplitter.java

/**
 * Test creating a pre-split table using the HexStringSplit algorithm.
 */
@Test
public void testCreatePresplitTableHex() throws Exception {
  final List<byte[]> expectedBounds = new ArrayList<>(17);
  expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);
  expectedBounds.add("10000000".getBytes());
  expectedBounds.add("20000000".getBytes());
  expectedBounds.add("30000000".getBytes());
  expectedBounds.add("40000000".getBytes());
  expectedBounds.add("50000000".getBytes());
  expectedBounds.add("60000000".getBytes());
  expectedBounds.add("70000000".getBytes());
  expectedBounds.add("80000000".getBytes());
  expectedBounds.add("90000000".getBytes());
  expectedBounds.add("a0000000".getBytes());
  expectedBounds.add("b0000000".getBytes());
  expectedBounds.add("c0000000".getBytes());
  expectedBounds.add("d0000000".getBytes());
  expectedBounds.add("e0000000".getBytes());
  expectedBounds.add("f0000000".getBytes());
      expectedBounds.add(ArrayUtils.EMPTY_BYTE_ARRAY);

      // Do table creation/pre-splitting and verification of region boundaries
preSplitTableAndVerify(expectedBounds,
    HexStringSplit.class.getSimpleName(),
    TableName.valueOf(name.getMethodName()));
}

项目：PyroDB 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：c5 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：HBase-Research 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：hbase-0.94.8-qod 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：hbase-0.94.8-qod 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：DominoHBase 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：hindex 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
assertArrayEquals(twoRegionsSplits[0], "80000000".getBytes());

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals(splitPoint, "10000000".getBytes());

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals(splitPoint,"efffffff".getBytes());
}

项目：hbase 文件：TestRegionSplitter.java

/**
 * Unit tests for the HexStringSplit algorithm. Makes sure it divides up the
 * space of keys in the way that we expect.
 */
@Test
public void unitTestHexStringSplit() {
    HexStringSplit splitter = new HexStringSplit();
    // Check splitting while starting from scratch

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
    assertArrayEquals("80000000".getBytes(), twoRegionsSplits[0]);

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = "55555555".getBytes();
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = "aaaaaaaa".getBytes();
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split("10000000".getBytes(), "30000000".getBytes());
    assertArrayEquals("20000000".getBytes(), splitPoint);

    byte[] lastRow = "ffffffff".getBytes();
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = "00000000".getBytes();
    assertArrayEquals(firstRow, splitter.firstRow());

    // Halfway between 00... and 20... should be 10...
    splitPoint = splitter.split(firstRow, "20000000".getBytes());
    assertArrayEquals("10000000".getBytes(), splitPoint);

    // Halfway between df... and ff... should be ef....
    splitPoint = splitter.split("dfffffff".getBytes(), lastRow);
    assertArrayEquals("efffffff".getBytes(), splitPoint);

    // Check splitting region with multiple mappers per region
    byte[][] splits = splitter.split("00000000".getBytes(), "30000000".getBytes(), 3, false);
    assertEquals(2, splits.length);
    assertArrayEquals("10000000".getBytes(), splits[0]);
    assertArrayEquals("20000000".getBytes(), splits[1]);

    splits = splitter.split("00000000".getBytes(), "20000000".getBytes(), 2, true);
    assertEquals(3, splits.length);
    assertArrayEquals("10000000".getBytes(), splits[1]);
}