@Test
  public void unitTestUniformSplit() {
    UniformSplit splitter = new UniformSplit();

    // Check splitting while starting from scratch
    try {
      splitter.split(1);
      throw new AssertionError("Splitting into <2 regions should have thrown exception");
    } catch (IllegalArgumentException e) {
    }

    byte[][] twoRegionsSplits = splitter.split(2);
    assertEquals(1, twoRegionsSplits.length);
    assertArrayEquals(twoRegionsSplits[0], new byte[] { (byte) 0x80, 0, 0, 0, 0, 0, 0, 0 });

    byte[][] threeRegionsSplits = splitter.split(3);
    assertEquals(2, threeRegionsSplits.length);
    byte[] expectedSplit0 = new byte[] { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
    assertArrayEquals(expectedSplit0, threeRegionsSplits[0]);
    byte[] expectedSplit1 = new byte[] { (byte) 0xAA, (byte) 0xAA, (byte) 0xAA, (byte) 0xAA,
      (byte) 0xAA, (byte) 0xAA, (byte) 0xAA, (byte) 0xAA };
    assertArrayEquals(expectedSplit1, threeRegionsSplits[1]);

    // Check splitting existing regions that have start and end points
    byte[] splitPoint = splitter.split(new byte[] { 0x10 }, new byte[] { 0x30 });
    assertArrayEquals(new byte[] { 0x20 }, splitPoint);

    byte[] lastRow = new byte[] { xFF, xFF, xFF, xFF, xFF, xFF, xFF, xFF };
    assertArrayEquals(lastRow, splitter.lastRow());
    byte[] firstRow = ArrayUtils.EMPTY_BYTE_ARRAY;
    assertArrayEquals(firstRow, splitter.firstRow());

    splitPoint = splitter.split(firstRow, new byte[] { 0x20 });
    assertArrayEquals(splitPoint, new byte[] { 0x10 });

    splitPoint =
      splitter.split(new byte[] { (byte) 0xdf, xFF, xFF, xFF, xFF, xFF, xFF, xFF }, lastRow);
    assertArrayEquals(splitPoint, new byte[] { (byte) 0xef, xFF, xFF, xFF, xFF, xFF, xFF, xFF });

    splitPoint = splitter.split(new byte[] { 'a', 'a', 'a' }, new byte[] { 'a', 'a', 'b' });
    assertArrayEquals(splitPoint, new byte[] { 'a', 'a', 'a', (byte) 0x80 });

    // Check splitting region with multiple mappers per region
    byte[][] splits =
      splitter.split(new byte[] { 'a', 'a', 'a' }, new byte[] { 'a', 'a', 'd' }, 3, false);
    assertEquals(2, splits.length);
    assertArrayEquals(splits[0], new byte[] { 'a', 'a', 'b' });
    assertArrayEquals(splits[1], new byte[] { 'a', 'a', 'c' });

    splits = splitter.split(new byte[] { 'a', 'a', 'a' }, new byte[] { 'a', 'a', 'e' }, 2, true);
    assertEquals(3, splits.length);
    assertArrayEquals(splits[1], new byte[] { 'a', 'a', 'c' });
  }
Unit tests for the UniformSplit algorithm. Makes sure it divides up the space of keys in the
way that we expect.
hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestRegionSplitter.java