// not bothering testing all variations, since we know they share implementations
    assertThat(Striped.lock(100).size()).isAtLeast(100);
    assertTrue(Striped.lock(256).size() == 256);
    assertThat(Striped.lazyWeakLock(100).size()).isAtLeast(100);
    assertTrue(Striped.lazyWeakLock(256).size() == 256);
  }

  public void testWeakImplementations() {
    for (Striped<?> striped : weakImplementations()) {

	if r.i >= int64(len(r.s)) {
		return 0
	}
	return int(int64(len(r.s)) - r.i)
}

// Size returns the original length of the underlying byte slice.
// Size is the number of bytes available for reading via [Reader.ReadAt].
// The result is unaffected by any method calls except [Reader.Reset].
func (r *Reader) Size() int64 { return int64(len(r.s)) }

// Read implements the [io.Reader] interface.

        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        return 8;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 8;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override

    @DisplayName("Should handle various data sizes in hexdump")
    void testHexdumpVariousSizes(int size) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        byte[] data = createTestData(size);
        Hexdump.hexdump(ps, data, 0, size);
        String output = baos.toString();

        assertNotNull(output);

			Count: float64(minuteTotals.N),
			Bytes: minuteTotals.Size,
		},
		LastHour: madmin.RStat{
			Count: float64(hourTotals.N),
			Bytes: hourTotals.Size,
		},
		Totals: madmin.RStat{
			Count: float64(rt.SinceUptime.Count),
			Bytes: rt.SinceUptime.Bytes,
		},
		ErrCounts: errCounts,
	}
}

func (rt *RTimedMetrics) addsize(size int64, err error) {
	// failures seen since uptime

        assertEquals(8192, config.getRdmaReadWriteThreshold(), "Default threshold should be 8KB");
        assertEquals(65536, config.getRdmaMaxSendSize(), "Default max send size should be 64KB");
        assertEquals(65536, config.getRdmaMaxReceiveSize(), "Default max receive size should be 64KB");
        assertEquals(255, config.getRdmaCredits(), "Default credits should be 255");
    }

    @Test

	const (
		MaxMetadataSize = 1 << 20 // max. size of the metadata
		Version         = 1
	)

	var header [5]byte
	if _, err := io.ReadFull(ciphertext, header[:]); err != nil {
		return nil, err
	}
	if header[0] != Version {
		return nil, fmt.Errorf("config: unknown ciphertext version %d", header[0])
	}
	size := binary.LittleEndian.Uint32(header[1:])
	if size > MaxMetadataSize {

    }

    /**
     * Gets the page size.
     * @return the page size
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     * @param pageSize the page size
     */
    public void setPageSize(final int pageSize) {

     */
    public QueryNetworkInterfaceInfoRequest() {
        // No input data required for this IOCTL
    }

    /**
     * Get the size of this request (always 0)
     *
     * @return size in bytes
     */
    public int size() {
        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer

        this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize);
    checkState(
        this.maximumWeight == UNSET_INT,
        "maximum weight was already set to %s",
        this.maximumWeight);
    checkState(this.weigher == null, "maximum size can not be combined with weigher");
    checkArgument(maximumSize >= 0, "maximum size must not be negative");
    this.maximumSize = maximumSize;