* #previous()} can retrieve the preceding {@code position} elements.
   *
   * @throws IndexOutOfBoundsException if {@code position} is negative or is greater than {@code
   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {
    checkPositionIndex(position, size);
    this.size = size;
    this.position = position;

    }

    @Test
    @DisplayName("writeUShort handles negative values as unsigned")
    void testWriteUShortNegative() {
        byte[] dest = new byte[2];
        NtlmMessage.writeUShort(dest, 0, -2);
        assertArrayEquals(new byte[] { -2, -1 }, dest, "Negative short should be encoded unsigned");
    }

    @Test

    }

    @Test
    void testReadParameterWordsWireFormat() {
        byte[] buffer = new byte[1024];
        int result = response.readParameterWordsWireFormat(buffer, 0);

        // The method should read parameter words
        assertTrue(result >= 0, "readParameterWordsWireFormat should return non-negative value");
    }

    @Test

type OpUnaryTerm struct {
	Op    string     `parser:"@(\"*\" | \"/\" | \"%\")"`
	Right *UnaryTerm `parser:"@@"`
}

// UnaryTerm represents a single negated term or a primary term
type UnaryTerm struct {
	Negated *NegatedTerm `parser:"  @@"`
	Primary *PrimaryTerm `parser:"| @@"`
}

// NegatedTerm has a leading minus sign.
type NegatedTerm struct {
	Term *PrimaryTerm `parser:"\"-\" @@"`
}

        assertEquals(10, searchRenderData.getPageSize());

        searchRenderData.setPageSize(100);
        assertEquals(100, searchRenderData.getPageSize());

        // Test with negative value
        searchRenderData.setPageSize(-1);
        assertEquals(-1, searchRenderData.getPageSize());
    }

    @Test
    public void test_setAndGetCurrentPageNumber() {
        // Test with zero

    }
    return increment ? div + signum : div;
  }

  /**
   * Returns {@code x mod m}, a non-negative value less than {@code m}. This differs from {@code x %
   * m}, which might be negative. This method is equivalent to {@code Math.floorMod(x, m)} except
   * that that method also allows negative {@code m}. {@code Math.floorMod} should be preferred when
   * {@code m} is known to be positive.
   *
   * <p>For example:

        // Test with max int value (unsigned interpretation)
        buffer.putInt(0, 0xFFFFFFFF);
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should read max ULong correctly.");

        // Test with a negative int (should be interpreted as unsigned positive)
        buffer.putInt(0, -1); // -1 is 0xFFFFFFFF
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should interpret -1 as unsigned max ULong.");
    }

		err = rt.Right.aggregateRow(r, tableAlias)
		if err != nil {
			return err
		}
	}
	return nil
}

func (e *UnaryTerm) aggregateRow(r Record, tableAlias string) error {
	if e.Negated != nil {
		return e.Negated.Term.aggregateRow(r, tableAlias)
	}
	return e.Primary.aggregateRow(r, tableAlias)
}

func (e *PrimaryTerm) aggregateRow(r Record, tableAlias string) error {
	switch {
	case e.ListExpr != nil:

        return Stream.of(Arguments.of((LongGetter) FileEntry::createTime, -1L, "negative createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, 0L, "zero createTime"),
                Arguments.of((LongGetter) FileEntry::createTime, Long.MAX_VALUE, "max createTime"),

                Arguments.of((LongGetter) FileEntry::lastModified, -2L, "negative lastModified"),

    }

    @Test
    @DisplayName("Codes: all non-negative and unique")
    void codes_are_non_negative_and_unique() {
        // Edge checks: ensure there are no negative or duplicate codes
        Set<Integer> seen = new HashSet<>();
        for (int c : WinError.WINERR_CODES) {
            assertTrue(c >= 0, "Code should be non-negative: " + c);
            assertTrue(seen.add(c), "Duplicate code detected: " + c);