this.writeSizeFile = this.writeSize;
        }

        if (log.isDebugEnabled()) {
            log.debug("Negotiated file write size is " + this.writeSizeFile);
        }

        if (this.useNTSmbs) {
            this.reqx = new SmbComWriteAndX(th.getConfig());
            this.rspx = new SmbComWriteAndXResponse(th.getConfig());
        } else {

// does not exist in enough quorum nodes.
func refreshLock(ctx context.Context, ds *Dsync, id, source string, quorum int) (bool, error) {
	restClnts, _ := ds.GetLockers()

	// Create buffered channel of size equal to total number of nodes.
	ch := make(chan refreshResult, len(restClnts))
	var wg sync.WaitGroup

	args := LockArgs{
		UID: id,
	}

	for index, c := range restClnts {
		wg.Add(1)

    assertThat(stats.evictionCount()).isEqualTo(removalListener.size());
    assertThat(stats.loadSuccessCount()).isEqualTo(computeCount.get());
    assertThat(stats.loadExceptionCount()).isEqualTo(exceptionCount.get() + computeNullCount.get());
    // each computed value is still in the cache, or was passed to the removal listener
    assertThat(cache.size() + removalListener.size()).isEqualTo(computeCount.get());
  }

  @J2ktIncompatible

    assertThat(stats.evictionCount()).isEqualTo(removalListener.size());
    assertThat(stats.loadSuccessCount()).isEqualTo(computeCount.get());
    assertThat(stats.loadExceptionCount()).isEqualTo(exceptionCount.get() + computeNullCount.get());
    // each computed value is still in the cache, or was passed to the removal listener
    assertThat(cache.size() + removalListener.size()).isEqualTo(computeCount.get());
  }

  @J2ktIncompatible

      this.delegate = delegate;
      this.delta = delta;
    }

    @Override
    protected List<E> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      return delegate.size() + delta;
    }
  }

  @SuppressWarnings("JoinIterableIterator") // explicitly testing iterator overload, too
  public void testNoSpecialNullBehavior() {
    checkNoOutput(J, iterable);

    }
  }

  // Factory method that skips the null checks.  Used only when the elements
  // are guaranteed to be non-null.
  static <E> ImmutableList<E> unsafeDelegateList(List<? extends E> list) {
    switch (list.size()) {
      case 0:
        return of();
      case 1:
        return of(list.get(0));
      default:
        @SuppressWarnings("unchecked")
        List<E> castedList = (List<E>) list;

    }

    private byte[] createMockFileStandardInfoBuffer() {
        // Create a buffer that represents FileStandardInfo data
        byte[] buffer = new byte[24];

        // Mock allocation size (8 bytes)
        for (int i = 0; i < 8; i++) {
            buffer[i] = (byte) i;
        }

        // Mock end of file (8 bytes)
        for (int i = 8; i < 16; i++) {
            buffer[i] = (byte) (i * 2);

    }

    /**
     * Perform constant-time encryption to prevent timing attacks
     */
    private byte[] performConstantTimeEncryption(Cipher cipher, byte[] message) throws Exception {
        // Pad to fixed block size to prevent timing leaks
        int blockSize = cipher.getBlockSize();
        if (blockSize == 0)
            blockSize = 16; // GCM mode

    for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
      put(entry.getKey(), entry.getValue());
    }
  }

  @Override
  public void cleanUp() {}

  @Override
  public long size() {
    throw new UnsupportedOperationException();
  }

  @Override
  public void invalidate(Object key) {
    throw new UnsupportedOperationException();
  }

  /**
   * @since 11.0
   */

    } catch (SecurityException ok) {
      // Allowed in case test doesn't have privs
    }
  }

  /** The number of elements to place in collections, arrays, etc. */
  static final int SIZE = 20;

  /** Returns a new started daemon Thread running the given runnable. */
  final Thread newStartedThread(Runnable runnable) {
    Thread t = new Thread(runnable);
    t.setDaemon(true);
    t.start();