there are limitations to what a Go implementation can do in response to a data race.
An implementation may always react to a data race by reporting the race and terminating the program.
Otherwise, each read of a single-word-sized or sub-word-sized memory location
must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
and not yet overwritten.
These implementation constraints make Go more like Java or JavaScript,

        this.pid = config.getPid();
        this.batchLevel = 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockResponse#isAsync()
     */
    @Override

	return lifecycle.ObjectOpts{
		Name:               oi.Name,
		UserTags:           oi.UserTags,
		VersionID:          oi.VersionID,
		ModTime:            oi.ModTime,
		Size:               oi.Size,
		IsLatest:           oi.IsLatest,
		NumVersions:        oi.NumVersions,
		DeleteMarker:       oi.DeleteMarker,
		SuccessorModTime:   oi.SuccessorModTime,
		RestoreOngoing:     oi.RestoreOngoing,

  }

  public void testSize0() {
    Iterator<String> iterator = emptyIterator();
    assertEquals(0, Iterators.size(iterator));
  }

  public void testSize1() {
    Iterator<Integer> iterator = singleton(0).iterator();
    assertEquals(1, Iterators.size(iterator));
  }

  public void testSize_partiallyConsumed() {
    Iterator<Integer> iterator = asList(1, 2, 3, 4, 5).iterator();

        }

        if (_specification != null) {
            builder.setFetchSource(_specification.columnList.toArray(new String[_specification.columnList.size()]), null);
        }

        return builder;
    }

    // ===================================================================================

  public void testValuesRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    assertTrue(multimap().asMap().values().remove(singleton(v0())));
    assertEquals(2, multimap().size());
    assertEquals(singletonMap(k0(), newHashSet(v0(), v3())), multimap().asMap());
  }

      map.put(i, Integer.toString(i));
    }
    map.trimToSize();
    assertThat(map.entries).hasLength(10);
    assertThat(map.keys).hasLength(10);
    assertThat(map.values).hasLength(10);
    assertEquals(10, map.size());
    for (int i = 0; i < 10; i++) {
      assertThat(map.get(i)).isEqualTo(Integer.toString(i));
    }
  }

  public void testEntrySetValueAfterRemoved() {

            bufferIndex += 28; // ???
        }

        bufferIndex = start + daclOffset;

        if (daclOffset != 0) {
            bufferIndex++; // revision
            bufferIndex++;
            final int size = ServerMessageBlock.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            final int numAces = ServerMessageBlock.readInt4(buffer, bufferIndex);
            bufferIndex += 4;

        Set<String> needsInlining = needsInlining(session);
        if (needsInlining.isEmpty()) {
            return artifacts;
        }
        ArrayList<Artifact> newArtifacts = new ArrayList<>(artifacts.size());
        for (Artifact artifact : artifacts) {
            if ("pom".equals(artifact.getExtension())
                    && artifact.getClassifier().isEmpty()) {
                try {

  var minFreshSeconds = -1
  var onlyIfCached = false
  var noTransform = false
  var immutable = false

  var canUseHeaderValue = true
  var headerValue: String? = null

  loop@ for (i in 0 until headers.size) {
    val name = headers.name(i)
    val value = headers.value(i)

    when {
      name.equals("Cache-Control", ignoreCase = true) -> {
        if (headerValue != null) {