}
  }

  /**
   * Returns whether the source has zero chars. The default implementation first checks {@link
   * #lengthIfKnown}, returning true if it's known to be zero and false if it's known to be
   * non-zero. If the length is not known, it falls back to opening a stream and checking for EOF.
   *
   * <p>Note that, in cases where {@code lengthIfKnown} returns zero, it is <i>possible</i> that

    }
  }

  /**
   * Returns whether the source has zero chars. The default implementation first checks {@link
   * #lengthIfKnown}, returning true if it's known to be zero and false if it's known to be
   * non-zero. If the length is not known, it falls back to opening a stream and checking for EOF.
   *
   * <p>Note that, in cases where {@code lengthIfKnown} returns zero, it is <i>possible</i> that

        assertEquals(0, result);

        // Test with different parameters
        result = netShareEnum.readSetupWireFormat(buffer, 10, 50);
        assertEquals(0, result);

        // Test with zero length
        result = netShareEnum.readSetupWireFormat(buffer, 0, 0);
        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test readParametersWireFormat returns 0")

		//	-a-1 == ^a
		//
		// If the number is negative, we use an inversion mask to invert the
		// data bytes and treat the value as an unsigned number.
		var inv byte // 0x00 if positive or zero, 0xff if negative
		if b[0]&0x40 != 0 {
			inv = 0xff
		}

		var x uint64
		for i, c := range b {
			c ^= inv // Inverts c only if inv is 0xff, otherwise does nothing
			if i == 0 {

          // primitives
          .put(Object.class, "")
          .put(Number.class, 0)
          .put(UnsignedInteger.class, UnsignedInteger.ZERO)
          .put(UnsignedLong.class, UnsignedLong.ZERO)
          .put(BigInteger.class, BigInteger.ZERO)
          .put(BigDecimal.class, BigDecimal.ZERO)
          .put(CharSequence.class, "")
          .put(String.class, "")
          .put(Pattern.class, Pattern.compile(""))

     */
    public boolean isEmpty() {
        return this.sub_authority_count == 0;
    }

    /**
     * Checks whether the SID is blank (all sub-authorities zero).
     *
     * @return whether the SID is blank (all sub-authorities zero)
     */
    public boolean isBlank() {
        boolean blank = true;
        for (final int sub : this.sub_authority) {
            blank = blank && sub == 0;
        }

        int offset = 0;

        setHeaderStart(response, 64);

        // Write structure with zero length
        SMBUtil.writeInt2(9, buffer, offset);
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2);
        SMBUtil.writeInt4(0, buffer, offset + 4); // Zero length

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then

	// end of the token. It's where you are now, and you just read this token.
	if tok == '(' && in.Stack.Col() == prevCol+1 {
		// Macro has arguments. Scan list of formals.
		acceptArg := true
		args = []string{} // Zero length but not nil.
	Loop:
		for {
			tok = in.Stack.Next()
			switch tok {
			case ')':
				tok = in.Stack.Next() // First token of macro definition.
				break Loop
			case ',':
				if acceptArg {

        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**
     * Parameterised test of capacity values, including edge cases such as
     * zero and negative capacities.
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, Long.MAX_VALUE })
    @DisplayName("capacity may be any long value")
    void testCapacityEdgeValues(long capacity) {

        bufferIndex += 4;
        setupCount = buffer[bufferIndex] & 0xFF;
        bufferIndex += 2;
        if ((setupCount != 0) && (LogStream.level >= 3)) {
            log.println("setupCount is not zero: " + setupCount);
        }

        return bufferIndex - start;
    }