@Override
  Set<K> createKeySet() {
    return new KeySet(map);
  }

  final Set<K> createMaybeNavigableKeySet() {
    if (map instanceof NavigableMap) {
      return new NavigableKeySet((NavigableMap<K, Collection<V>>) map);
    } else if (map instanceof SortedMap) {
      return new SortedKeySet((SortedMap<K, Collection<V>>) map);
    } else {
      return new KeySet(map);
    }
  }

  @WeakOuter

        // Prepare minimal buffer
        byte[] buffer = new byte[24];

        // Test with offset 0
        int bytesDecoded = response.decode(buffer, 0, 24);
        assertEquals(24, bytesDecoded, "Should return 24 bytes consumed from offset 0");

        // Test with different offset
        response = new ValidateNegotiateInfoResponse();
        buffer = new byte[50];
        bytesDecoded = response.decode(buffer, 10, 24);

            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = 0;
            rpcUuid.time_mid = 0;
            rpcUuid.time_hi_and_version = 0;
            rpcUuid.clock_seq_hi_and_reserved = 0;
            rpcUuid.clock_seq_low = 0;
            rpcUuid.node = new byte[6];

            UUID uuid = new UUID(rpcUuid);

            // Act

        StringReader sReader = new StringReader(serializedModel);

        MavenStaxReader modelReader = new MavenStaxReader();
        try {
            model = new Model(modelReader.read(sReader));
        } catch (XMLStreamException e) {
            throw new ModelInterpolationException(

        storage.putAll(m);
    }

    public String put(String key, List<String> commentLines, List<String> valueLines) {
        commentLines = new ArrayList<>(commentLines);
        valueLines = new ArrayList<>(valueLines);
        String escapedKey = escapeKey(key);
        StringBuilder sb = new StringBuilder();
        // int lastLine = valueLines.size() - 1;
        if (valueLines.isEmpty()) {
            valueLines.add(escapedKey + "=");

        storage.putAll(m);
    }

    public String put(String key, List<String> commentLines, List<String> valueLines) {
        commentLines = new ArrayList<>(commentLines);
        valueLines = new ArrayList<>(valueLines);
        String escapedKey = escapeKey(key);
        StringBuilder sb = new StringBuilder();
        // int lastLine = valueLines.size() - 1;
        if (valueLines.isEmpty()) {
            valueLines.add(escapedKey + "=");

    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);

        Map<Element, Element> map = new HashMap<>();
        for (Element element : keys) {
          map.put(element, element);
        }
        return map;
      }
    },
    LinkedHM {
      @Override
      Map<Element, Element> create(Collection<Element> keys) {
        Map<Element, Element> map = new LinkedHashMap<>();
        for (Element element : keys) {

        murmur3_32().hashString("ABCDefGHI\u0799", UTF_8));
  }

  @SuppressWarnings("deprecation")
  public void testEncodedStringInputs() {
    Random rng = new Random(0);
    for (int z = 0; z < 100; z++) {
      int[] codePoints = new int[rng.nextInt(8)];
      for (int i = 0; i < codePoints.length; i++) {
        do {
          codePoints[i] = rng.nextInt(0x800);

  private SleepingRunnable sleeper;
  private Future<Boolean> delayedFuture;

  private final TearDownStack tearDownStack = new TearDownStack();

  @Override
  protected void setUp() {
    ExecutorService executor = newSingleThreadExecutor();
    tearDownStack.addTearDown(executor::shutdownNow);
    sleeper = new SleepingRunnable(1000);
    delayedFuture = executor.submit(sleeper, true);