throw new IOException("transport closed in negotiate");
            }
            final int size = Encdec.dec_uint16be(sbuf, 2) & 0xFFFF;
            if (size < 33 || 4 + size > sbuf.length) {
                throw new IOException("Invalid payload size: " + size);
            }
            readn(in, sbuf, 4 + 32, size - 32);
            resp.decode(sbuf, 4);

            if (LogStream.level >= 4) {

        return true;
      }
      if (object instanceof BooleanArrayAsList) {
        BooleanArrayAsList that = (BooleanArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

    for (int i = 0; i < entries.size(); i++) {
      List<Entry<E>> expected = spec.expectedEntries(i, entries);
      SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
      assertEquals(expected.size(), subMultiset.entrySet().size());
      assertEquals(expected.size(), subMultiset.elementSet().size());
    }
  }

  public void testTailClosedEntrySet() {

        return true;
      }
      if (object instanceof BooleanArrayAsList) {
        BooleanArrayAsList that = (BooleanArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

        });
    assertThat(cache.size()).isAtMost(1);
  }

  public void testCompute() {
    cache.put(key, "1");
    // simultaneous deletion
    doParallelCacheOp(
        count,
        n -> {
          cache.asMap().compute(key, (k, v) -> null);
        });
    assertEquals(0, cache.size());
  }

  public void testComputeWithLoad() {

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        int size = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        for (final Smb2Lock l : this.locks) {
            size += l.size();
        }
        return size8(size);
    }

    /**
     * {@inheritDoc}
     *

    Builder<K, V> combine(Builder<K, V> other) {
      checkNotNull(other);
      ensureCapacity(this.size + other.size);
      arraycopy(
          other.alternatingKeysAndValues,
          0,
          this.alternatingKeysAndValues,
          this.size * 2,
          other.size * 2);
      this.size += other.size;
      return this;
    }

    private ImmutableMap<K, V> build(boolean throwIfDuplicateKeys) {

    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {
      stack.removeAt(stack.size - 1)
      path.removeAt(path.size - 1)
    }

    val sink = sink()

    // Write the tagClass, tag, and constructed bit. This takes 1 byte if tag is less than 31.
    if (tag < 31) {

        final Set<String> set = new HashSet<String>();
        traverser.forEach((ClassHandler) (packageName, shortClassName) -> set.add(ClassUtil.concatName(packageName, shortClassName)));
        assertThat(set.size() > 0, is(true));
        assertThat(set.contains(DummyTest.class.getName()), is(true));
        assertThat(set.contains(TraverserUtilTest.class.getName()), is(true));

     */
    @Nonnull
    MessageBuilder builder();

    /**
     * Creates a new message builder of the specified size.
     * @param size the initial size of the message builder buffer
     * @return a new message builder
     */
    @Nonnull
    MessageBuilder builder(int size);