Java 类java.util.NavigableMap 实例源码

public Test testsForCheckedNavigableMap() {
  return SortedMapTestSuiteBuilder.using(
      new TestStringSortedMapGenerator() {
        @Override
        protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
          NavigableMap<String, String> map = populate(new TreeMap<String, String>(), entries);
          return Collections.checkedNavigableMap(map, String.class, String.class);
        }
      })
      .named("checkedNavigableMap/TreeMap, natural")
      .withFeatures(
          MapFeature.GENERAL_PURPOSE,
          MapFeature.ALLOWS_NULL_VALUES,
          MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
          MapFeature.RESTRICTS_KEYS,
          MapFeature.RESTRICTS_VALUES,
          CollectionFeature.KNOWN_ORDER,
          CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
          CollectionFeature.SERIALIZABLE,
          CollectionSize.ANY)
      .suppressing(suppressForCheckedNavigableMap())
      .createTestSuite();
}

@Override
public List<HRegionLocation> locateRegions(final TableName tableName,
    final boolean useCache, final boolean offlined) throws IOException {
  NavigableMap<HRegionInfo, ServerName> regions = MetaScanner.allTableRegions(this, tableName);
  final List<HRegionLocation> locations = new ArrayList<HRegionLocation>();
  for (HRegionInfo regionInfo : regions.keySet()) {
    RegionLocations list = locateRegion(tableName, regionInfo.getStartKey(), useCache, true);
    if (list != null) {
      for (HRegionLocation loc : list.getRegionLocations()) {
        if (loc != null) {
          locations.add(loc);
        }
      }
    }
  }
  return locations;
}

public void testSubMapContents2() {
    NavigableMap map = map5();
    SortedMap sm = map.subMap(two, three);
    assertEquals(1, sm.size());
    assertEquals(two, sm.firstKey());
    assertEquals(two, sm.lastKey());
    assertFalse(sm.containsKey(one));
    assertTrue(sm.containsKey(two));
    assertFalse(sm.containsKey(three));
    assertFalse(sm.containsKey(four));
    assertFalse(sm.containsKey(five));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(two, k);
    assertFalse(i.hasNext());
    Iterator j = sm.keySet().iterator();
    j.next();
    j.remove();
    assertFalse(map.containsKey(two));
    assertEquals(4, map.size());
    assertEquals(0, sm.size());
    assertTrue(sm.isEmpty());
    assertSame(sm.remove(three), null);
    assertEquals(4, map.size());
}

@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testTailMapRanges(String description, NavigableMap navigableMap) {
    NavigableMap subMap = navigableMap.tailMap(BigInteger.ONE, true);

    // same subset
    subMap.tailMap(BigInteger.ONE, true);

    // slightly smaller
    NavigableMap ns = subMap.tailMap(BigInteger.ONE, false);

    // slight exapansion
    assertThrows(() -> {
        ns.tailMap(BigInteger.ONE, true);
    },
        IllegalArgumentException.class,
        description + ": Expansion should not be allowed");

    // much smaller
    subMap.tailMap(isDescending(subMap) ? BigInteger.ZERO : BigInteger.TEN, false);
}

public static int getProtocolVersion()
{
    if(WurstClient.INSTANCE.options.mc112x_compatibility == 2)
        return 340;
    else if(WurstClient.INSTANCE.options.mc112x_compatibility == 1)
        return 338;

    NavigableMap<Integer, String> protocols = WMinecraft.PROTOCOLS;

    // use default if using Wurst-Bot
    if(WurstBot.isEnabled())
        return protocols.lastKey();

    ServerData server = lastServer.getServerData();

    // use default if ping failed
    if(!server.pinged || server.pingToServer < 0)
        return protocols.lastKey();

    // use default if server protocol is not supported
    if(!protocols.containsKey(server.version))
        return protocols.lastKey();

    // use server protocol
    return server.version;
}

public Test testsForUnmodifiableNavigableMap() {
  return MapTestSuiteBuilder.using(
      new TestStringSortedMapGenerator() {
        @Override
        protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
          return Collections.unmodifiableNavigableMap(populate(new TreeMap<>(), entries));
        }
      })
      .named("unmodifiableNavigableMap/TreeMap, natural")
      .withFeatures(
          MapFeature.ALLOWS_NULL_VALUES,
          CollectionFeature.KNOWN_ORDER,
          CollectionFeature.SERIALIZABLE,
          CollectionSize.ANY)
      .suppressing(suppressForUnmodifiableNavigableMap())
      .createTestSuite();
}

public void testRangesByUpperBound() {
  for (Range<Integer> range1 : QUERY_RANGES) {
    for (Range<Integer> range2 : QUERY_RANGES) {
      TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
      rangeSet.add(range1);
      rangeSet.add(range2);

      NavigableMap<Cut<Integer>, Range<Integer>> expectedRangesByUpperBound = Maps.newTreeMap();
      for (Range<Integer> range : rangeSet.asRanges()) {
        expectedRangesByUpperBound.put(range.upperBound, range);
      }
      testNavigationAgainstExpected(expectedRangesByUpperBound,
          new TreeRangeSet.RangesByUpperBound<Integer>(rangeSet.rangesByLowerBound),
          CUTS_TO_TEST);
    }
  }
}

public void testDescendingKeySet() {
  NavigableMap<String, Integer> map = create();
  NavigableSet<String> descendingKeySet = map.descendingKeySet();
  assertTrue(descendingKeySet instanceof SynchronizedNavigableSet);
  assertSame(
      mutex, ((SynchronizedNavigableSet<String>) descendingKeySet).mutex);
}

public void testTailMap_K_B() {
  NavigableMap<String, Integer> map = create();
  NavigableMap<String, Integer> subMap = map.tailMap("a", true);
  assertTrue(subMap instanceof SynchronizedNavigableMap);
  assertSame(
      mutex, ((SynchronizedNavigableMap<String, Integer>) subMap).mutex);
}

public static <K, V, W extends Iterable<V>> Entry<K, V> pollFirstEntry(NavigableMap<K, W> map) {
    Entry<K, V> result = null;

    Iterator<Entry<K, W>> itE = map.entrySet().iterator();

    // For robustness, remove entry valueX sets
    while(itE.hasNext()) {
        Entry<K, W> e = itE.next();

        K k = e.getKey();
        Iterable<V> vs = e.getValue();

        Iterator<V> itV = vs.iterator();
        if(itV.hasNext()) {
            V v = itV.next();
            itV.remove();

            if(!itV.hasNext()) {
                itE.remove();
            }

            result = new SimpleEntry<>(k, v);
            break;
        } else {
            itE.remove();
            continue;
        }
    }

    return result;
}

/**
 * put(null,x) throws NPE
 */
public void testDescendingPut1_NullPointerException() {
    NavigableMap c = dmap5();
    try {
        c.put(null, "whatever");
        shouldThrow();
    } catch (NullPointerException success) {}
}

/**
 * Tests that the containsAll method returns {@code false}.
 */
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testContainsAll(String description, NavigableMap<?,?> navigableMap) {
    TreeMap treeMap = new TreeMap();
    treeMap.put("1", 1);
    treeMap.put("2", 2);
    treeMap.put("3", 3);

    assertFalse(navigableMap.equals(treeMap), "Should not contain any elements.");
}

@Override
public String toString() {
  StringBuilder sb =
      new StringBuilder()
          .append("SizeConfigStrategy{groupedMap=")
          .append(groupedMap)
          .append(", sortedSizes=(");
  for (Map.Entry<Bitmap.Config, NavigableMap<Integer, Integer>> entry : sortedSizes.entrySet()) {
    sb.append(entry.getKey()).append('[').append(entry.getValue()).append("], ");
  }
  if (!sortedSizes.isEmpty()) {
    sb.replace(sb.length() - 2, sb.length(), "");
  }
  return sb.append(")}").toString();
}

/**
 * @return Map of StoreFiles by column family
 */
private NavigableMap<byte[], List<Path>> getStoreFiles() {
  NavigableMap<byte[], List<Path>> allStoreFiles =
      new TreeMap<byte[], List<Path>>(Bytes.BYTES_COMPARATOR);
  for (Store store : getStores()) {
    Collection<StoreFile> storeFiles = store.getStorefiles();
    if (storeFiles == null) continue;
    List<Path> storeFileNames = new ArrayList<Path>();
    for (StoreFile storeFile : storeFiles) {
      storeFileNames.add(storeFile.getPath());
    }
    allStoreFiles.put(store.getFamily().getName(), storeFileNames);
  }
  return allStoreFiles;
}

private void decrementArrayOfSize(int size, Class<?> arrayClass) {
  NavigableMap<Integer, Integer> sizes = getSizesForAdapter(arrayClass);
  Integer current = sizes.get(size);
  if (current == null) {
    throw new NullPointerException(
        "Tried to decrement empty size" + ", size: " + size + ", this: " + this);
  }
  if (current == 1) {
    sizes.remove(size);
  } else {
    sizes.put(size, current - 1);
  }
}

@GwtIncompatible // NavigableMap
public void testNavigableMapTransformEntries() {
  NavigableMap<String, String> map =
      ImmutableSortedMap.of("a", "4", "b", "9");
  EntryTransformer<String, String, String> concat =
      new EntryTransformer<String, String, String>() {
        @Override
        public String transformEntry(String key, String value) {
          return key + value;
        }
      };
  NavigableMap<String, String> transformed = transformEntries(map, concat);

  assertEquals(ImmutableSortedMap.of("a", "a4", "b", "b9"), transformed);
}

/**
 * Tests that contains requires Comparable
 */
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testContainsRequiresComparable(String description, NavigableMap<?,?> navigableMap) {
    assertThrows(() -> {
        navigableMap.containsKey(new Object());
    },
        ClassCastException.class,
        description + ": Compareable should be required");
}

public void testNavigableKeySet() {
  NavigableMap<String, Integer> map = create();
  NavigableSet<String> navigableKeySet = map.navigableKeySet();
  assertTrue(navigableKeySet instanceof SynchronizedNavigableSet);
  assertSame(
      mutex, ((SynchronizedNavigableSet<String>) navigableKeySet).mutex);
}

private SafeTreeMap(NavigableMap<K, V> delegate) {
  this.delegate = delegate;
  if (delegate == null) {
    throw new NullPointerException();
  }
  for (K k : keySet()) {
    checkValid(k);
  }
}

/**
 * higherEntry returns next entry.
 */
public void testHigherEntry() {
    NavigableMap map = map5();
    Map.Entry e1 = map.higherEntry(three);
    assertEquals(four, e1.getKey());

    Map.Entry e2 = map.higherEntry(zero);
    assertEquals(one, e2.getKey());

    Map.Entry e3 = map.higherEntry(five);
    assertNull(e3);

    Map.Entry e4 = map.higherEntry(six);
    assertNull(e4);
}

public NavigableMap<K,V> descendingMap() {
    NavigableMap<K,V> mv = descendingMapView;
    return (mv != null) ? mv :
        (descendingMapView =
         new DescendingSubMap<>(m,
                                fromStart, lo, loInclusive,
                                toEnd,     hi, hiInclusive));
}

@SuppressWarnings({"rawtypes", "unchecked"})
public void testForwarding() {
  new ForwardingWrapperTester()
      .testForwarding(NavigableMap.class, new Function<NavigableMap, NavigableMap>() {
        @Override public NavigableMap apply(NavigableMap delegate) {
          return wrap(delegate);
        }
      });
}

public void testEquals() {
  NavigableMap<Integer, String> map1 = ImmutableSortedMap.of(1, "one");
  NavigableMap<Integer, String> map2 = ImmutableSortedMap.of(2, "two");
  new EqualsTester()
      .addEqualityGroup(map1, wrap(map1), wrap(map1))
      .addEqualityGroup(map2, wrap(map2))
      .testEquals();
}

public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
    if (!inRange(toKey, inclusive))
        throw new IllegalArgumentException("toKey out of range");
    return new AscendingSubMap<>(m,
                                 fromStart, lo,    loInclusive,
                                 false,     toKey, inclusive);
}

/**
 * subMap returns map with keys in requested range
 */
public void testSubMapContents() {
    ConcurrentSkipListMap map = map5();
    NavigableMap sm = map.subMap(two, true, four, false);
    assertEquals(two, sm.firstKey());
    assertEquals(three, sm.lastKey());
    assertEquals(2, sm.size());
    assertFalse(sm.containsKey(one));
    assertTrue(sm.containsKey(two));
    assertTrue(sm.containsKey(three));
    assertFalse(sm.containsKey(four));
    assertFalse(sm.containsKey(five));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(two, k);
    k = (Integer)(i.next());
    assertEquals(three, k);
    assertFalse(i.hasNext());
    Iterator r = sm.descendingKeySet().iterator();
    k = (Integer)(r.next());
    assertEquals(three, k);
    k = (Integer)(r.next());
    assertEquals(two, k);
    assertFalse(r.hasNext());

    Iterator j = sm.keySet().iterator();
    j.next();
    j.remove();
    assertFalse(map.containsKey(two));
    assertEquals(4, map.size());
    assertEquals(1, sm.size());
    assertEquals(three, sm.firstKey());
    assertEquals(three, sm.lastKey());
    assertEquals("C", sm.remove(three));
    assertTrue(sm.isEmpty());
    assertEquals(3, map.size());
}

/**
 * lowerEntry returns preceding entry.
 */
public void testLowerEntry() {
    NavigableMap map = map5();
    Map.Entry e1 = map.lowerEntry(three);
    assertEquals(two, e1.getKey());

    Map.Entry e2 = map.lowerEntry(six);
    assertEquals(five, e2.getKey());

    Map.Entry e3 = map.lowerEntry(one);
    assertNull(e3);

    Map.Entry e4 = map.lowerEntry(zero);
    assertNull(e4);
}

@Override
public NavigableMap<K, V> descendingMap() {
  synchronized (mutex) {
    if (descendingMap == null) {
      return descendingMap = navigableMap(delegate().descendingMap(), mutex);
    }
    return descendingMap;
  }
}

@Override protected <K, V> NavigableMap<K, V> create() {
  @SuppressWarnings("unchecked")
  NavigableMap<K, V> innermost = new SafeTreeMap<K, V>(
      (Comparator<? super K>) Ordering.natural().nullsFirst());
  TestMap<K, V> inner = new TestMap<K, V>(innermost, mutex);
  NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex);
  return outer;
}

@Override
public NavigableMap<Cut<C>, Range<C>> subMap(
    Cut<C> fromKey, boolean fromInclusive, Cut<C> toKey, boolean toInclusive) {
  return subMap(Range.range(
      fromKey, BoundType.forBoolean(fromInclusive),
      toKey, BoundType.forBoolean(toInclusive)));
}

@Test
public void testDelete_CheckTimestampUpdated() throws IOException {
  TableName tableName = TableName.valueOf(name.getMethodName());
  byte[] row1 = Bytes.toBytes("row1");
  byte[] col1 = Bytes.toBytes("col1");
  byte[] col2 = Bytes.toBytes("col2");
  byte[] col3 = Bytes.toBytes("col3");

  // Setting up region
  String method = this.getName();
  this.region = initHRegion(tableName, method, CONF, fam1);
  try {
    // Building checkerList
    List<Cell> kvs = new ArrayList<Cell>();
    kvs.add(new KeyValue(row1, fam1, col1, null));
    kvs.add(new KeyValue(row1, fam1, col2, null));
    kvs.add(new KeyValue(row1, fam1, col3, null));

    NavigableMap<byte[], List<Cell>> deleteMap = new TreeMap<byte[], List<Cell>>(
        Bytes.BYTES_COMPARATOR);
    deleteMap.put(fam1, kvs);
    region.delete(deleteMap, Durability.SYNC_WAL);

    // extract the key values out the memstore:
    // This is kinda hacky, but better than nothing...
    long now = System.currentTimeMillis();
    DefaultMemStore memstore = (DefaultMemStore) ((HStore) region.getStore(fam1)).memstore;
    Cell firstCell = memstore.cellSet.first();
    assertTrue(firstCell.getTimestamp() <= now);
    now = firstCell.getTimestamp();
    for (Cell cell : memstore.cellSet) {
      assertTrue(cell.getTimestamp() <= now);
      now = cell.getTimestamp();
    }
  } finally {
    HRegion.closeHRegion(this.region);
    this.region = null;
  }
}

private void transformResultAndAddToList(Result result, List<MDPoint> found) {
  NavigableMap<byte[], byte[]> map = result.getFamilyMap(MDHBaseAdmin.SECONDARY_FAMILY);
  if (map == null) return;
  for (Entry<byte[], byte[]> entry : map.entrySet()) {
    MDPoint p = toPoint(entry.getKey(), entry.getValue());
    found.add(p);
  }
}

/**
 * putAll adds all key-value pairs from the given map
 */
public void testDescendingPutAll() {
    NavigableMap empty = dmap0();
    NavigableMap map = dmap5();
    empty.putAll(map);
    assertEquals(5, empty.size());
    assertTrue(empty.containsKey(m1));
    assertTrue(empty.containsKey(m2));
    assertTrue(empty.containsKey(m3));
    assertTrue(empty.containsKey(m4));
    assertTrue(empty.containsKey(m5));
}

/**
 * A deserialized/reserialized map equals original
 */
public void testSerialization() throws Exception {
    NavigableMap x = map5();
    NavigableMap y = serialClone(x);

    assertNotSame(x, y);
    assertEquals(x.size(), y.size());
    assertEquals(x.toString(), y.toString());
    assertEquals(x, y);
    assertEquals(y, x);
}

@Test
public void testHBaseGroupScanAssignmentNoAfinity() throws Exception {
  NavigableMap<HRegionInfo,ServerName> regionsToScan = Maps.newTreeMap();
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[0], splits[1]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[1], splits[2]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[2], splits[3]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[3], splits[4]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[4], splits[5]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[5], splits[6]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[6], splits[7]), SERVER_X);
  regionsToScan.put(new HRegionInfo(TABLE_NAME, splits[7], splits[0]), SERVER_X);

  final List<DrillbitEndpoint> endpoints = Lists.newArrayList();
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_A).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_B).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_C).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_D).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_E).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_F).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_G).setControlPort(1234).build());
  endpoints.add(DrillbitEndpoint.newBuilder().setAddress(HOST_H).setControlPort(1234).build());

  HBaseGroupScan scan = new HBaseGroupScan();
  scan.setRegionsToScan(regionsToScan);
  scan.setHBaseScanSpec(new HBaseScanSpec(TABLE_NAME_STR, splits[0], splits[0], null));
  scan.applyAssignments(endpoints);

  int i = 0;
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'A'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'B'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'C'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'D'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'E'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'F'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'G'
  assertEquals(1, scan.getSpecificScan(i++).getRegionScanSpecList().size()); // 'H'
  testParallelizationWidth(scan, i);
}

private NavigableMap<Cut<C>, Range<C>> subMap(Range<Cut<C>> subWindow) {
  if (!complementLowerBoundWindow.isConnected(subWindow)) {
    return ImmutableSortedMap.of(); 
  } else {
    subWindow = subWindow.intersection(complementLowerBoundWindow);
    return new ComplementRangesByLowerBound<C>(positiveRangesByLowerBound, subWindow);
  }
}

@Override protected <K, V> NavigableMap<K, V> create() {
  @SuppressWarnings("unchecked")
  NavigableMap<K, V> innermost = new SafeTreeMap<K, V>(
      (Comparator<? super K>) Ordering.natural().nullsFirst());
  TestMap<K, V> inner = new TestMap<K, V>(innermost, mutex);
  NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex);
  return outer;
}

/**
 * isEmpty is true of empty map and false for non-empty
 */
public void testIsEmpty() {
    NavigableMap empty = map0();
    NavigableMap map = map5();
    assertTrue(empty.isEmpty());
    assertFalse(map.isEmpty());
}

/**
 * Resets the contents of navigableMap to have entries a, c, for the
 * navigation tests.
 */
@SuppressWarnings("unchecked") // Needed to stop Eclipse whining
private void resetWithHole() {
  Entry<K, V>[] entries = new Entry[] {a, c};
  super.resetMap(entries);
  navigableMap = (NavigableMap<K, V>) getMap();
}

@Override
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
  return new SafeTreeMap<K, V>(delegate.headMap(checkValid(toKey), inclusive));
}

@Override
public NavigableMap<K, V> subMap(
    K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
  return forward().subMap(toKey, toInclusive, fromKey, fromInclusive).descendingMap();
}