}

  @CanIgnoreReturnValue
  static int checkNonNegative(int value) {
    checkArgument(value >= 0, "Not true that %s is non-negative.", value);
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonNegative(long value) {
    checkArgument(value >= 0, "Not true that %s is non-negative.", value);
    return value;
  }

  @CanIgnoreReturnValue
  static int checkPositive(int value) {

  }

  @CanIgnoreReturnValue
  static int checkNonNegative(int value) {
    checkArgument(value >= 0, "Not true that %s is non-negative.", value);
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonNegative(long value) {
    checkArgument(value >= 0, "Not true that %s is non-negative.", value);
    return value;
  }

  @CanIgnoreReturnValue
  static int checkPositive(int value) {

    assertThrows(
        NumberFormatException.class,
        () -> UnsignedLongs.parseUnsignedLong("0", Character.MAX_RADIX + 1));

    // The radix is used as an array index, so try a negative value.
    assertThrows(NumberFormatException.class, () -> UnsignedLongs.parseUnsignedLong("0", -1));
  }

  public void testToString() {
    String[] tests = {
      "0",
      "ffffffffffffffff",

        assertEquals(0, response.readParametersWireFormat(emptyBuffer, 0, 0));
        assertEquals(0, response.readDataWireFormat(emptyBuffer, 0, 0));
    }

    @Test
    @DisplayName("Methods should handle negative indices")
    void testMethodsWithNegativeIndices() {
        // Arrange
        byte[] buffer = new byte[100];
        int negativeIndex = -1;

        // Act & Assert

	instructions["JLS"] = x86.AJLS  /* lower or same (unsigned) (CF = 1 || ZF = 1) */
	instructions["JLT"] = x86.AJLT  /* less than (signed) (SF != OF) */
	instructions["JMI"] = x86.AJMI  /* negative (minus) (SF = 1) */
	instructions["JNA"] = x86.AJLS  /* alternate */
	instructions["JNAE"] = x86.AJCS /* alternate */
	instructions["JNB"] = x86.AJCC  /* alternate */
	instructions["JNBE"] = x86.AJHI /* alternate */

        assertEquals(largeCount, result.getAllRecordCount());
    }

    public void test_negativeQueryTime() {
        // Test with negative query time (edge case)
        SearchResult result = SearchResult.create().queryTime(-1L).build();

        assertEquals(-1L, result.getQueryTime());
    }

    public void test_documentListImmutability() {

      encodings[ 0x12] = encoding // Device Control 2
      encodings[ 0x13] = encoding // Device Control 3 (oft. XOFF)
      encodings[ 0x14] = encoding // Device Control 4
      encodings[ 0x15] = encoding // Negative Acknowledgment
      encodings[ 0x16] = encoding // Synchronous idle
      encodings[ 0x17] = encoding // End of Transmission Block
      encodings[ 0x18] = encoding // Cancel
      encodings[ 0x19] = encoding // End of Medium

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link Queues}.
 *
 * @author Dimitris Andreou
 */
@NullUnmarked
public class QueuesTest extends TestCase {
  /*
   * All the following tests relate to BlockingQueue methods in Queues.
   */

  public static List<BlockingQueue<Object>> blockingQueues() {
    return ImmutableList.<BlockingQueue<Object>>of(
        new LinkedBlockingQueue<Object>(),

		switch err := recover().(type) {
		case nil:
			t.Fatal("bytes.Buffer.ReadFrom didn't panic")
		case error:
			// this is the error string of errNegativeRead
			wantError := "bytes.Buffer: reader returned negative count from Read"
			if err.Error() != wantError {
				t.Fatalf("recovered panic: got %v, want %v", err.Error(), wantError)
			}
		default:
			t.Fatalf("unexpected panic value: %#v", err)
		}
	}()

        assertFalse(auth.isExpired());

        // Test with no expiration (TTL = 0)
        auth.setAuthenticationTTL(0);
        Thread.sleep(100);
        assertFalse(auth.isExpired());

        // Test with negative TTL (no expiration)
        auth.setAuthenticationTTL(-1);
        Thread.sleep(100);
        assertFalse(auth.isExpired());
    }

    /**
     * Test close() method
     */
    @Test