public void testPutAllPropagatesToGet() {
    Multimap<K, V> source =
        getSubjectGenerator().create(mapEntry(k0(), v3()), mapEntry(k3(), v3()));
    Collection<V> getCollection = multimap().get(k0());
    int getCollectionSize = getCollection.size();
    assertTrue(multimap().putAll(source));
    assertEquals(getCollectionSize + 1, getCollection.size());
    assertContains(getCollection, v3());
  }

        .build(),
    )
    val call = client.newCall(Request(url = server.url("/")))
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  private fun randomString(length: Int): String {
    val byteArray = ByteArray(length)
    Random(0).nextBytes(byteArray)
    return byteArray.toByteString().base64()
  }

    assertThat(expected).hasMessageThat().isEqualTo("Mark not supported");
  }

  private static class UnmarkableInputStream extends InputStream {
    @Override
    public int read() throws IOException {
      return 0;
    }

    @Override
    public boolean markSupported() {
      return false;
    }
  }

    this.node = node;
    this.edgeType = edgeType;
  }

  @Override
  public boolean remove(@Nullable Object o) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int size() {
    if (graph.isDirected()) {
      return predecessorsOrEmpty(node).size()
          + successorsOrEmpty(node).size()
          - (edgeType == EdgeType.BOTH && predecessorsOrEmpty(node).contains(node) ? 1 : 0);

    }
    return adjacentNodes;
  }

  @Override
  public Set<E> edgesConnecting(N node) {
    return new MultiEdgesConnecting<E>(incidentEdgeMap, node) {
      @Override
      public int size() {
        return adjacentNodesMultiset().count(node);
      }
    };
  }

  @Override
  public @Nullable N removeInEdge(E edge, boolean isSelfLoop) {
    if (!isSelfLoop) {

    private BigDecimalToDoubleRounder() {}

    @Override
    double roundToDoubleArbitrarily(BigDecimal bigDecimal) {
      return bigDecimal.doubleValue();
    }

    @Override
    int sign(BigDecimal bigDecimal) {
      return bigDecimal.signum();
    }

    @Override
    BigDecimal toX(double d, RoundingMode mode) {
      return new BigDecimal(d);
    }

    @Override

  static final ReverseNaturalOrdering INSTANCE = new ReverseNaturalOrdering();

  @Override
  @SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
  public int compare(Comparable<?> left, Comparable<?> right) {
    checkNotNull(left); // right null is caught later
    if (left == right) {
      return 0;
    }

    return ((Comparable<Object>) right).compareTo(left);
  }

    @Override
    public boolean isSnapshot() {
        // Don't consider the artifact's version in here, as this is stored in the directory above that
        return false;
    }

    @Override
    public int getNature() {
        if (artifact.getVersion() != null) {
            return artifact.isSnapshot() ? SNAPSHOT : RELEASE;
        }

        VersionRange range = artifact.getVersionRange();
        if (range != null) {

        return TestUtils.createMockContext();
    }

    @Test
    void testHelpExecuteReturnsZero() throws Exception {
        UpgradeContext context = createMockContext();

        int result = help.execute(context);

        assertEquals(0, result, "Help goal should return 0 (success)");
    }

    @Test
    void testHelpExecuteDoesNotThrow() throws Exception {

// closer which only closes the associated *os.File when the ref count.
// has reached zero, i.e when all the readers have given up their locks.
type RLockedFile struct {
	*LockedFile
	mutex sync.Mutex
	refs  int // Holds read lock refs.
}

// IsClosed - Check if the rlocked file is already closed.
func (r *RLockedFile) IsClosed() bool {
	r.mutex.Lock()
	defer r.mutex.Unlock()
	return r.refs == 0
}