if (l != null) {
            l.clearValue();
        }
        return storage.remove(key);
    }

    @Override
    public void clear() {
        for (Layout l : layout.values()) {
            l.clearValue();
        }
        storage.clear();
    }

    /**
     * Return the comment header.
     *
     * @return the comment header
     */
    public List<String> getHeader() {

        if (l != null) {
            l.clearValue();
        }
        return storage.remove(key);
    }

    @Override
    public void clear() {
        for (Layout l : layout.values()) {
            l.clearValue();
        }
        storage.clear();
    }

    /**
     * Return the comment header.
     *
     * @return the comment header
     */
    public List<String> getHeader() {

    long total = 0;
    CharBuffer buf = createBuffer();
    while (from.read(buf) != -1) {
      Java8Compatibility.flip(buf);
      to.append(buf);
      total += buf.remaining();
      Java8Compatibility.clear(buf);
    }
    return total;
  }

  // TODO(lukes): consider allowing callers to pass in a buffer to use, some callers would be able

              socket.setReceiveBufferSize(SOCKET_BUFFER_SIZE)
              return socket
            }
          },
        ).build()
  }

  @AfterEach
  fun tearDown() {
    Thread.interrupted() // Clear interrupted state.
  }

  @Test
  fun interruptWritingRequestBody() {
    server.enqueue(MockResponse())
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()

    private Map<Key, PluginDescriptor> descriptors = new ConcurrentHashMap<>(128);
    private Map<Key, Key> keys = new ConcurrentHashMap<>();

    @Override
    public void flush() {
        descriptors.clear();
    }

    @Override
    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);

    assertThat(multimap.get("foo")).containsExactly(1, 2, 3, 4, 5).inOrder();
    List<Integer> sublist = list.subList(0, 5);
    assertThat(sublist).containsExactly(1, 2, 3, 4, 5).inOrder();

    sublist.clear();
    assertTrue(sublist.isEmpty());
    multimap.put("foo", 6);

    assertThrows(ConcurrentModificationException.class, () -> sublist.isEmpty());
  }

  public void testCreateFromMultimap() {

          extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

    @IgnoreJRERequirement // see enclosing class (whose annotation Animal Sniffer ignores here...)

    return true;
  }

  @Override
  @CanIgnoreReturnValue
  public boolean addAll(Collection<? extends E> collection) {
    int size = collection.size();
    if (size >= maxSize) {
      clear();
      return Iterables.addAll(this, Iterables.skip(collection, size - maxSize));
    }
    return standardAddAll(collection);
  }

  @Override

      return standardHashCode();
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesClearToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());
    result.clear();
    assertGet(k0());
    assertEmpty(result);
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testAddNullValue() {