Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.regionserver;
019
020import static org.junit.jupiter.api.Assertions.assertArrayEquals;
021import static org.junit.jupiter.api.Assertions.assertEquals;
022import static org.junit.jupiter.api.Assertions.assertFalse;
023import static org.junit.jupiter.api.Assertions.assertNotEquals;
024import static org.junit.jupiter.api.Assertions.assertTrue;
025import static org.junit.jupiter.api.Assertions.fail;
026
027import java.io.IOException;
028import org.apache.hadoop.conf.Configuration;
029import org.apache.hadoop.fs.FileStatus;
030import org.apache.hadoop.fs.Path;
031import org.apache.hadoop.hbase.HBaseTestingUtil;
032import org.apache.hadoop.hbase.HConstants;
033import org.apache.hadoop.hbase.TableName;
034import org.apache.hadoop.hbase.client.RegionInfo;
035import org.apache.hadoop.hbase.client.RegionInfoBuilder;
036import org.apache.hadoop.hbase.client.RegionInfoDisplay;
037import org.apache.hadoop.hbase.client.TableDescriptor;
038import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
039import org.apache.hadoop.hbase.exceptions.DeserializationException;
040import org.apache.hadoop.hbase.master.RegionState;
041import org.apache.hadoop.hbase.testclassification.RegionServerTests;
042import org.apache.hadoop.hbase.testclassification.SmallTests;
043import org.apache.hadoop.hbase.util.Bytes;
044import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
045import org.apache.hadoop.hbase.util.FSTableDescriptors;
046import org.apache.hadoop.hbase.util.MD5Hash;
047import org.junit.jupiter.api.BeforeEach;
048import org.junit.jupiter.api.Tag;
049import org.junit.jupiter.api.Test;
050import org.junit.jupiter.api.TestInfo;
051
052import org.apache.hbase.thirdparty.com.google.protobuf.UnsafeByteOperations;
053
054import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
055import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos;
056
057@Tag(RegionServerTests.TAG)
058@Tag(SmallTests.TAG)
059public class TestRegionInfo {
060
061  private String methodName;
062
063  @BeforeEach
064  public void setUp(TestInfo testInfo) {
065    methodName = testInfo.getTestMethod().get().getName();
066  }
067
068  @Test
069  public void testIsStart() {
070    assertTrue(RegionInfoBuilder.FIRST_META_REGIONINFO.isFirst());
071    RegionInfo ri = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME)
072      .setStartKey(Bytes.toBytes("not_start")).build();
073    assertFalse(ri.isFirst());
074  }
075
076  @Test
077  public void testIsEnd() {
078    assertTrue(RegionInfoBuilder.FIRST_META_REGIONINFO.isFirst());
079    RegionInfo ri = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME)
080      .setEndKey(Bytes.toBytes("not_end")).build();
081    assertFalse(ri.isLast());
082  }
083
084  @Test
085  public void testIsNext() {
086    byte[] bytes = Bytes.toBytes("row");
087    RegionInfo ri =
088      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setEndKey(bytes).build();
089    RegionInfo ri2 =
090      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(bytes).build();
091    assertFalse(ri.isNext(RegionInfoBuilder.FIRST_META_REGIONINFO));
092    assertTrue(ri.isNext(ri2));
093  }
094
095  @Test
096  public void testIsOverlap() {
097    byte[] a = Bytes.toBytes("a");
098    byte[] b = Bytes.toBytes("b");
099    byte[] c = Bytes.toBytes("c");
100    byte[] d = Bytes.toBytes("d");
101    RegionInfo all = RegionInfoBuilder.FIRST_META_REGIONINFO;
102    RegionInfo ari = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setEndKey(a).build();
103    RegionInfo abri =
104      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(a).setEndKey(b).build();
105    RegionInfo adri =
106      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(a).setEndKey(d).build();
107    RegionInfo cdri =
108      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(c).setEndKey(d).build();
109    RegionInfo dri = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(d).build();
110    assertTrue(all.isOverlap(all));
111    assertTrue(all.isOverlap(abri));
112    assertFalse(abri.isOverlap(cdri));
113    assertTrue(all.isOverlap(ari));
114    assertFalse(ari.isOverlap(abri));
115    assertFalse(ari.isOverlap(abri));
116    assertTrue(ari.isOverlap(all));
117    assertTrue(dri.isOverlap(all));
118    assertTrue(abri.isOverlap(adri));
119    assertFalse(dri.isOverlap(ari));
120    assertTrue(abri.isOverlap(adri));
121    assertTrue(adri.isOverlap(abri));
122  }
123
124  /**
125   * Tests {@link RegionInfo#isOverlap(RegionInfo)}
126   */
127  @Test
128  public void testIsOverlaps() {
129    byte[] a = Bytes.toBytes("a");
130    byte[] b = Bytes.toBytes("b");
131    byte[] c = Bytes.toBytes("c");
132    byte[] d = Bytes.toBytes("d");
133    byte[] e = Bytes.toBytes("e");
134    byte[] f = Bytes.toBytes("f");
135    RegionInfo ari = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setEndKey(a).build();
136    RegionInfo abri =
137      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(a).setEndKey(b).build();
138    RegionInfo eri = RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setEndKey(e).build();
139    RegionInfo cdri =
140      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(c).setEndKey(d).build();
141    RegionInfo efri =
142      RegionInfoBuilder.newBuilder(TableName.META_TABLE_NAME).setStartKey(e).setEndKey(f).build();
143    assertFalse(ari.isOverlap(abri));
144    assertTrue(abri.isOverlap(eri));
145    assertFalse(cdri.isOverlap(efri));
146    assertTrue(eri.isOverlap(ari));
147  }
148
149  @Test
150  public void testPb() throws DeserializationException {
151    RegionInfo hri = RegionInfoBuilder.FIRST_META_REGIONINFO;
152    byte[] bytes = RegionInfo.toByteArray(hri);
153    RegionInfo pbhri = RegionInfo.parseFrom(bytes);
154    assertEquals(hri, pbhri);
155  }
156
157  @Test
158  public void testReadAndWriteHRegionInfoFile() throws IOException, InterruptedException {
159    HBaseTestingUtil htu = new HBaseTestingUtil();
160    RegionInfo hri = RegionInfoBuilder.FIRST_META_REGIONINFO;
161    Path basedir = htu.getDataTestDir();
162    // Create a region. That'll write the .regioninfo file.
163    FSTableDescriptors fsTableDescriptors = new FSTableDescriptors(htu.getConfiguration());
164    FSTableDescriptors.tryUpdateMetaTableDescriptor(htu.getConfiguration());
165    HRegion r = HBaseTestingUtil.createRegionAndWAL(hri, basedir, htu.getConfiguration(),
166      fsTableDescriptors.get(TableName.META_TABLE_NAME));
167    // Get modtime on the file.
168    long modtime = getModTime(r);
169    HBaseTestingUtil.closeRegionAndWAL(r);
170    Thread.sleep(1001);
171    r = HRegion.openHRegion(basedir, hri, fsTableDescriptors.get(TableName.META_TABLE_NAME), null,
172      htu.getConfiguration());
173    // Ensure the file is not written for a second time.
174    long modtime2 = getModTime(r);
175    assertEquals(modtime, modtime2);
176    // Now load the file.
177    RegionInfo deserializedHri = HRegionFileSystem.loadRegionInfoFileContent(
178      r.getRegionFileSystem().getFileSystem(), r.getRegionFileSystem().getRegionDir());
179    assertEquals(0, RegionInfo.COMPARATOR.compare(hri, deserializedHri));
180    HBaseTestingUtil.closeRegionAndWAL(r);
181  }
182
183  long getModTime(final HRegion r) throws IOException {
184    FileStatus[] statuses = r.getRegionFileSystem().getFileSystem().listStatus(
185      new Path(r.getRegionFileSystem().getRegionDir(), HRegionFileSystem.REGION_INFO_FILE));
186    assertTrue(statuses != null && statuses.length == 1);
187    return statuses[0].getModificationTime();
188  }
189
190  @Test
191  public void testCreateHRegionInfoName() throws Exception {
192    final String tableName = methodName;
193    final TableName tn = TableName.valueOf(tableName);
194    String startKey = "startkey";
195    final byte[] sk = Bytes.toBytes(startKey);
196    String id = "id";
197
198    // old format region name
199    byte[] name = RegionInfo.createRegionName(tn, sk, id, false);
200    String nameStr = Bytes.toString(name);
201    assertEquals(tableName + "," + startKey + "," + id, nameStr);
202
203    // new format region name.
204    String md5HashInHex = MD5Hash.getMD5AsHex(name);
205    assertEquals(RegionInfo.MD5_HEX_LENGTH, md5HashInHex.length());
206    name = RegionInfo.createRegionName(tn, sk, id, true);
207    nameStr = Bytes.toString(name);
208    assertEquals(tableName + "," + startKey + "," + id + "." + md5HashInHex + ".", nameStr);
209  }
210
211  @Test
212  public void testContainsRange() {
213    TableDescriptor tableDesc =
214      TableDescriptorBuilder.newBuilder(TableName.valueOf(methodName)).build();
215    RegionInfo hri = RegionInfoBuilder.newBuilder(tableDesc.getTableName())
216      .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("g")).build();
217    // Single row range at start of region
218    assertTrue(hri.containsRange(Bytes.toBytes("a"), Bytes.toBytes("a")));
219    // Fully contained range
220    assertTrue(hri.containsRange(Bytes.toBytes("b"), Bytes.toBytes("c")));
221    // Range overlapping start of region
222    assertTrue(hri.containsRange(Bytes.toBytes("a"), Bytes.toBytes("c")));
223    // Fully contained single-row range
224    assertTrue(hri.containsRange(Bytes.toBytes("c"), Bytes.toBytes("c")));
225    // Range that overlaps end key and hence doesn't fit
226    assertFalse(hri.containsRange(Bytes.toBytes("a"), Bytes.toBytes("g")));
227    // Single row range on end key
228    assertFalse(hri.containsRange(Bytes.toBytes("g"), Bytes.toBytes("g")));
229    // Single row range entirely outside
230    assertFalse(hri.containsRange(Bytes.toBytes("z"), Bytes.toBytes("z")));
231
232    // Degenerate range
233    try {
234      hri.containsRange(Bytes.toBytes("z"), Bytes.toBytes("a"));
235      fail("Invalid range did not throw IAE");
236    } catch (IllegalArgumentException iae) {
237    }
238  }
239
240  @Test
241  public void testContainsRangeForMetaTable() {
242    TableDescriptor tableDesc =
243      TableDescriptorBuilder.newBuilder(TableName.META_TABLE_NAME).build();
244    RegionInfo hri = RegionInfoBuilder.newBuilder(tableDesc.getTableName()).build();
245    byte[] startRow = HConstants.EMPTY_START_ROW;
246    byte[] row1 = Bytes.toBytes("a,a,0");
247    byte[] row2 = Bytes.toBytes("aaaaa,,1");
248    byte[] row3 = Bytes.toBytes("aaaaa,\u0000\u0000,2");
249    byte[] row4 = Bytes.toBytes("aaaaa,\u0001,3");
250    byte[] row5 = Bytes.toBytes("aaaaa,a,4");
251    byte[] row6 = Bytes.toBytes("aaaaa,\u1000,5");
252
253    // Single row range at start of region
254    assertTrue(hri.containsRange(startRow, startRow));
255    // Fully contained range
256    assertTrue(hri.containsRange(row1, row2));
257    assertTrue(hri.containsRange(row2, row3));
258    assertTrue(hri.containsRange(row3, row4));
259    assertTrue(hri.containsRange(row4, row5));
260    assertTrue(hri.containsRange(row5, row6));
261    // Range overlapping start of region
262    assertTrue(hri.containsRange(startRow, row2));
263    // Fully contained single-row range
264    assertTrue(hri.containsRange(row1, row1));
265    // Degenerate range
266    try {
267      hri.containsRange(row3, row2);
268      fail("Invalid range did not throw IAE");
269    } catch (IllegalArgumentException iae) {
270    }
271  }
272
273  @Test
274  public void testLastRegionCompare() {
275    TableDescriptor tableDesc =
276      TableDescriptorBuilder.newBuilder(TableName.valueOf(methodName)).build();
277    RegionInfo hrip = RegionInfoBuilder.newBuilder(tableDesc.getTableName())
278      .setStartKey(Bytes.toBytes("a")).build();
279    RegionInfo hric = RegionInfoBuilder.newBuilder(tableDesc.getTableName())
280      .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("b")).build();
281    assertTrue(hrip.compareTo(hric) > 0);
282  }
283
284  @Test
285  public void testMetaTables() {
286    assertTrue(RegionInfoBuilder.FIRST_META_REGIONINFO.isMetaRegion());
287  }
288
289  @SuppressWarnings("SelfComparison")
290  @Test
291  public void testComparator() {
292    final TableName tableName = TableName.valueOf(methodName);
293    RegionInfo older = RegionInfoBuilder.newBuilder(tableName).setRegionId(0).build();
294    RegionInfo newer = RegionInfoBuilder.newBuilder(tableName).setRegionId(1).build();
295    assertTrue(older.compareTo(newer) < 0);
296    assertTrue(newer.compareTo(older) > 0);
297    assertEquals(0, older.compareTo(older));
298    assertEquals(0, newer.compareTo(newer));
299
300    RegionInfo a = RegionInfoBuilder.newBuilder(TableName.valueOf("a")).build();
301    RegionInfo b = RegionInfoBuilder.newBuilder(TableName.valueOf("b")).build();
302    assertNotEquals(0, a.compareTo(b));
303    TableName t = TableName.valueOf("t");
304    byte[] midway = Bytes.toBytes("midway");
305    a = RegionInfoBuilder.newBuilder(t).setEndKey(midway).build();
306    b = RegionInfoBuilder.newBuilder(t).setStartKey(midway).build();
307    assertTrue(a.compareTo(b) < 0);
308    assertTrue(b.compareTo(a) > 0);
309    assertTrue(a.equals(a));
310    assertEquals(0, a.compareTo(a));
311    a = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("a"))
312      .setEndKey(Bytes.toBytes("d")).build();
313    b = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("e"))
314      .setEndKey(Bytes.toBytes("g")).build();
315    assertTrue(a.compareTo(b) < 0);
316    a = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("aaaa"))
317      .setEndKey(Bytes.toBytes("dddd")).build();
318    b = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("e"))
319      .setEndKey(Bytes.toBytes("g")).build();
320    assertTrue(a.compareTo(b) < 0);
321    a = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("aaaa"))
322      .setEndKey(Bytes.toBytes("dddd")).build();
323    b = RegionInfoBuilder.newBuilder(t).setStartKey(Bytes.toBytes("aaaa"))
324      .setEndKey(Bytes.toBytes("eeee")).build();
325    assertTrue(a.compareTo(b) < 0);
326
327  }
328
329  @Test
330  public void testRegionNameForRegionReplicas() throws Exception {
331    String tableName = methodName;
332    final TableName tn = TableName.valueOf(tableName);
333    String startKey = "startkey";
334    final byte[] sk = Bytes.toBytes(startKey);
335    String id = "id";
336
337    // assert with only the region name without encoding
338
339    // primary, replicaId = 0
340    byte[] name = RegionInfo.createRegionName(tn, sk, Bytes.toBytes(id), 0, false);
341    String nameStr = Bytes.toString(name);
342    assertEquals(tableName + "," + startKey + "," + id, nameStr);
343
344    // replicaId = 1
345    name = RegionInfo.createRegionName(tn, sk, Bytes.toBytes(id), 1, false);
346    nameStr = Bytes.toString(name);
347    assertEquals(
348      tableName + "," + startKey + "," + id + "_" + String.format(RegionInfo.REPLICA_ID_FORMAT, 1),
349      nameStr);
350
351    // replicaId = max
352    name = RegionInfo.createRegionName(tn, sk, Bytes.toBytes(id), 0xFFFF, false);
353    nameStr = Bytes.toString(name);
354    assertEquals(tableName + "," + startKey + "," + id + "_"
355      + String.format(RegionInfo.REPLICA_ID_FORMAT, 0xFFFF), nameStr);
356  }
357
358  @Test
359  public void testParseName() throws IOException {
360    final TableName tableName = TableName.valueOf(methodName);
361    byte[] startKey = Bytes.toBytes("startKey");
362    long regionId = EnvironmentEdgeManager.currentTime();
363    int replicaId = 42;
364
365    // test without replicaId
366    byte[] regionName = RegionInfo.createRegionName(tableName, startKey, regionId, false);
367
368    byte[][] fields = RegionInfo.parseRegionName(regionName);
369    assertArrayEquals(tableName.getName(), fields[0], Bytes.toString(fields[0]));
370    assertArrayEquals(startKey, fields[1], Bytes.toString(fields[1]));
371    assertArrayEquals(Bytes.toBytes(Long.toString(regionId)), fields[2], Bytes.toString(fields[2]));
372    assertEquals(3, fields.length);
373
374    // test with replicaId
375    regionName = RegionInfo.createRegionName(tableName, startKey, regionId, replicaId, false);
376
377    fields = RegionInfo.parseRegionName(regionName);
378    assertArrayEquals(tableName.getName(), fields[0], Bytes.toString(fields[0]));
379    assertArrayEquals(startKey, fields[1], Bytes.toString(fields[1]));
380    assertArrayEquals(Bytes.toBytes(Long.toString(regionId)), fields[2], Bytes.toString(fields[2]));
381    assertArrayEquals(Bytes.toBytes(String.format(RegionInfo.REPLICA_ID_FORMAT, replicaId)),
382      fields[3], Bytes.toString(fields[3]));
383  }
384
385  @Test
386  public void testConvert() {
387    final TableName tableName = TableName.valueOf("ns1:" + methodName);
388    byte[] startKey = Bytes.toBytes("startKey");
389    byte[] endKey = Bytes.toBytes("endKey");
390    boolean split = false;
391    long regionId = EnvironmentEdgeManager.currentTime();
392    int replicaId = 42;
393
394    RegionInfo hri = RegionInfoBuilder.newBuilder(tableName).setStartKey(startKey).setEndKey(endKey)
395      .setSplit(split).setRegionId(regionId).setReplicaId(replicaId).build();
396
397    // convert two times, compare
398    RegionInfo convertedHri = ProtobufUtil.toRegionInfo(ProtobufUtil.toRegionInfo(hri));
399
400    assertEquals(hri, convertedHri);
401
402    // test convert RegionInfo without replicaId
403    HBaseProtos.RegionInfo info = HBaseProtos.RegionInfo.newBuilder()
404      .setTableName(HBaseProtos.TableName.newBuilder()
405        .setQualifier(UnsafeByteOperations.unsafeWrap(tableName.getQualifier()))
406        .setNamespace(UnsafeByteOperations.unsafeWrap(tableName.getNamespace())).build())
407      .setStartKey(UnsafeByteOperations.unsafeWrap(startKey))
408      .setEndKey(UnsafeByteOperations.unsafeWrap(endKey)).setSplit(split).setRegionId(regionId)
409      .build();
410
411    convertedHri = ProtobufUtil.toRegionInfo(info);
412    // expecting default replicaId
413    RegionInfo expectedHri = RegionInfoBuilder.newBuilder(tableName).setStartKey(startKey)
414      .setEndKey(endKey).setSplit(split).setRegionId(regionId).setReplicaId(0).build();
415
416    assertEquals(expectedHri, convertedHri);
417  }
418
419  @Test
420  public void testRegionDetailsForDisplay() throws IOException {
421    byte[] startKey = new byte[] { 0x01, 0x01, 0x02, 0x03 };
422    byte[] endKey = new byte[] { 0x01, 0x01, 0x02, 0x04 };
423    Configuration conf = new Configuration();
424    conf.setBoolean("hbase.display.keys", false);
425    RegionInfo h = RegionInfoBuilder.newBuilder(TableName.valueOf(methodName)).setStartKey(startKey)
426      .setEndKey(endKey).build();
427    checkEquality(h, conf);
428    // check HRIs with non-default replicaId
429    h = RegionInfoBuilder.newBuilder(TableName.valueOf(methodName)).setStartKey(startKey)
430      .setEndKey(endKey).setRegionId(EnvironmentEdgeManager.currentTime()).setReplicaId(1).build();
431    checkEquality(h, conf);
432    assertArrayEquals(RegionInfoDisplay.HIDDEN_END_KEY,
433      RegionInfoDisplay.getEndKeyForDisplay(h, conf));
434    assertArrayEquals(RegionInfoDisplay.HIDDEN_START_KEY,
435      RegionInfoDisplay.getStartKeyForDisplay(h, conf));
436
437    RegionState state = RegionState.createForTesting(h, RegionState.State.OPEN);
438    String descriptiveNameForDisplay =
439      RegionInfoDisplay.getDescriptiveNameFromRegionStateForDisplay(state, conf);
440    checkDescriptiveNameEquality(descriptiveNameForDisplay, state.toDescriptiveString(), startKey);
441
442    conf.setBoolean("hbase.display.keys", true);
443    assertArrayEquals(endKey, RegionInfoDisplay.getEndKeyForDisplay(h, conf));
444    assertArrayEquals(startKey, RegionInfoDisplay.getStartKeyForDisplay(h, conf));
445    assertEquals(state.toDescriptiveString(),
446      RegionInfoDisplay.getDescriptiveNameFromRegionStateForDisplay(state, conf));
447  }
448
449  private void checkDescriptiveNameEquality(String descriptiveNameForDisplay, String origDesc,
450    byte[] startKey) {
451    // except for the "hidden-start-key" substring everything else should exactly match
452    String firstPart = descriptiveNameForDisplay.substring(0,
453      descriptiveNameForDisplay.indexOf(new String(RegionInfoDisplay.HIDDEN_START_KEY)));
454    String secondPart = descriptiveNameForDisplay
455      .substring(descriptiveNameForDisplay.indexOf(new String(RegionInfoDisplay.HIDDEN_START_KEY))
456        + RegionInfoDisplay.HIDDEN_START_KEY.length);
457    String firstPartOrig = origDesc.substring(0, origDesc.indexOf(Bytes.toStringBinary(startKey)));
458    String secondPartOrig = origDesc.substring(
459      origDesc.indexOf(Bytes.toStringBinary(startKey)) + Bytes.toStringBinary(startKey).length());
460    assert (firstPart.equals(firstPartOrig));
461    assert (secondPart.equals(secondPartOrig));
462  }
463
464  private void checkEquality(RegionInfo h, Configuration conf) throws IOException {
465    byte[] modifiedRegionName = RegionInfoDisplay.getRegionNameForDisplay(h, conf);
466    byte[][] modifiedRegionNameParts = RegionInfo.parseRegionName(modifiedRegionName);
467    byte[][] regionNameParts = RegionInfo.parseRegionName(h.getRegionName());
468
469    // same number of parts
470    assert (modifiedRegionNameParts.length == regionNameParts.length);
471
472    for (int i = 0; i < regionNameParts.length; i++) {
473      // all parts should match except for [1] where in the modified one,
474      // we should have "hidden_start_key"
475      if (i != 1) {
476        assertArrayEquals(regionNameParts[i], modifiedRegionNameParts[i]);
477      } else {
478        assertNotEquals(regionNameParts[i][0], modifiedRegionNameParts[i][0]);
479        assertArrayEquals(modifiedRegionNameParts[1],
480          RegionInfoDisplay.getStartKeyForDisplay(h, conf));
481      }
482    }
483  }
484}