*/
  private final @Nullable List<NodeConnection<N>> orderedNodeConnections;

  private int predecessorCount;
  private int successorCount;

  private DirectedGraphConnections(
      Map<N, Object> adjacentNodeValues,
      @Nullable List<NodeConnection<N>> orderedNodeConnections,
      int predecessorCount,
      int successorCount) {
    this.adjacentNodeValues = checkNotNull(adjacentNodeValues);

	return &DeadlineWriter{WriteCloser: w, timeout: timeout}
}

func (w *DeadlineWriter) Write(buf []byte) (int, error) {
	if w.err != nil {
		return 0, w.err
	}

	n, err := WithDeadline[int](context.Background(), w.timeout, func(ctx context.Context) (int, error) {
		return w.WriteCloser.Write(buf)
	})
	w.err = err
	return n, err
}

    abstract void apply(T collection, Object query);

    abstract double expectedAsymptotic(int n);
  }

  /**
   * Returns a list of objects with the same hash code, of size 2^power, counting calls to equals,
   * hashCode, and compareTo in counter.
   */
  private static List<CountsHashCodeAndEquals> createAdversarialInput(
      int power, CallsCounter counter) {
    String str1 = "Aa";
    String str2 = "BB";

    }

    @Test
    void testEngineDigestWithBuffer() {
        // Test engineDigest(byte[] buf, int offset, int len)
        HMACT64 hmac = new HMACT64(TEST_KEY);
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

        byte[] buffer = new byte[32];
        int bytesWritten = hmac.engineDigest(buffer, 5, 16);

        assertEquals(16, bytesWritten);

    for (int i = 0; i < 10000; i++) {
      stripedLock.get(new Object()).lock();
      // nothing special (e.g. an exception) happens
    }
  }

  public void testBulkGetReturnsSorted() {
    for (Striped<?> striped : allImplementations()) {
      Map<Object, Integer> indexByLock = new HashMap<>();
      for (int i = 0; i < striped.size(); i++) {

    for (int i = 0; i < 10000; i++) {
      stripedLock.get(new Object()).lock();
      // nothing special (e.g. an exception) happens
    }
  }

  public void testBulkGetReturnsSorted() {
    for (Striped<?> striped : allImplementations()) {
      Map<Object, Integer> indexByLock = new HashMap<>();
      for (int i = 0; i < striped.size(); i++) {

        private long mid;
        private int command;
        private int uid;
        private boolean extendedSecurity;
        private long sessionId;
        private boolean retainPayload;
        private byte[] rawPayload;

        // Response interface fields
        private boolean received = false;
        private int grantedCredits = 0;
        private int errorCode = 0;
        private boolean verifyFailed = false;

        this.sourceKey = sourceKey;
        this.chunks = chunks;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        System.arraycopy(this.sourceKey, 0, dst, dstIndex, 24);
        dstIndex += 24;

        SMBUtil.writeInt4(this.chunks.length, dst, dstIndex);

            }
            final int workstationLength = workstation != null ? workstation.length : 0;
            final byte[] lmResponse = getLMResponse();
            final int lmLength = lmResponse != null ? lmResponse.length : 0;
            final byte[] ntResponse = getNTResponse();
            final int ntLength = ntResponse != null ? ntResponse.length : 0;

        
        // Data (16 bytes of reserved)
        int dataOffset = offset + 16 + nameLen;
        dataOffset = (dataOffset + 7) & ~7;  // 8-byte alignment
        
        for (int i = 0; i < 16; i++) {
            buffer[dataOffset + i] = 0;
        }
    }
    
    @Override
    public int size() {
        int nameLen = getName().length();