RangeMapEntry(Range<K> range, V value) {
      super(range, value);
    }

    boolean contains(K value) {
      return getKey().contains(value);
    }

    Cut<K> getLowerBound() {
      return getKey().lowerBound;
    }

    Cut<K> getUpperBound() {
      return getKey().upperBound;
    }
  }

  @Override
  public @Nullable V get(K key) {
    Entry<Range<K>, V> entry = getEntry(key);

    if (object instanceof Entry) {
      Entry<?, ?> that = (Entry<?, ?>) object;
      return Objects.equals(this.getKey(), that.getKey())
          && Objects.equals(this.getValue(), that.getValue());
    }
    return false;
  }

  @Override
  public int hashCode() {
    K k = getKey();
    V v = getValue();
    return ((k == null) ? 0 : k.hashCode()) ^ ((v == null) ? 0 : v.hashCode());
  }

      this.samples =
          new SampleElements<>(
              mapSamples.e0().getKey(),
              mapSamples.e1().getKey(),
              mapSamples.e2().getKey(),
              mapSamples.e3().getKey(),
              mapSamples.e4().getKey());
    }

    @Override
    public SampleElements<K> samples() {
      return samples;
    }

    @Override

    @Test
    @DisplayName("Should generate random lease key with correct size")
    void testRandomLeaseKeyGeneration() {
        Smb2LeaseKey key = new Smb2LeaseKey();

        assertNotNull(key.getKey());
        assertEquals(16, key.getKey().length);
        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {

                    BiMap<String, String> bimap = HashBiMap.create(entries.length);
                    for (Entry<String, String> entry : entries) {
                      checkArgument(!bimap.containsKey(entry.getKey()));
                      bimap.put(entry.getKey(), entry.getValue());
                    }
                    return Maps.unmodifiableBiMap(bimap);
                  }
                })
            .named("unmodifiableBiMap[HashBiMap]")

      assertFalse(
          "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed));
      assertFalse(
          "Inverse should not contain key " + reversed.getKey(),
          inv.containsKey(reversed.getKey()));
      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*

        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        assertThat(cache.asMap().containsKey(entry.getKey())).isTrue();
        assertThat(cache.asMap().containsValue(entry.getValue())).isTrue();
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertThat(cache.getUnchecked(entry.getKey())).isEqualTo(entry.getValue());
      }
      assertThat(cache.stats().missCount()).isEqualTo(WARMUP_SIZE);

    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(moreElements)));
  }

  public void testEquals_list() {
    assertFalse("A List should never equal a Set.", getSet().equals(copyToList(getSet())));
  }

    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(moreElements)));
  }

  public void testEquals_list() {
    assertFalse("A List should never equal a Set.", getSet().equals(copyToList(getSet())));
  }

    assertEquals(c.getKey(), navigableMap.lastKey());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapExclusive() {
    assertFalse(navigableMap.headMap(a.getKey()).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapInclusive() {
    assertTrue(navigableMap.tailMap(a.getKey()).containsKey(a.getKey()));
  }

  public void testHeadMap() {