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

		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)
		}
	}()

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.NullMarked;

/**
 * Testing utilities relating to garbage collection finalization.
 *
 * <p>Use this class to test code triggered by finalization, that is, one of the following
 * actions taken by the java garbage collection system:
 *
 * <ul>

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readBytesWireFormat(buffer, 9) // Not enough space to read 2 bytes
            );
        }

        @Test
        @DisplayName("Should handle negative values as unsigned")
        void testReadBytesWireFormatNegativeAsUnsigned() {
            // Given
            byte[] buffer = new byte[10];
            // Write -1 which will be read as 65535 unsigned

        TestRule rule2 = new TestRule("rule2", false);

        ruleManager.addRule(rule1);

        try {
            ruleManager.addRule(-1, rule2);
            fail("Should throw IndexOutOfBoundsException for negative index");
        } catch (IndexOutOfBoundsException e) {
            // Expected
        }

        try {
            ruleManager.addRule(5, rule2);

## Changes by Kind

### Feature

- Kubeadm: generate CA certificates with a start time that is offset 5 minutes in the past relative to the current system time to workaround cases of clock desync.

import com.google.common.cache.TestingRemovalListeners.CountingRemovalListener;
import java.util.List;
import java.util.Set;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests relating to cache eviction: what does and doesn't count toward maximumSize, what happens
 * when maximumSize is reached, etc.
 *
 * @author mike nonemacher
 */
@NullUnmarked
public class CacheEvictionTest extends TestCase {

	}
	versions, buf, e = msgp.ReadIntBytes(buf)
	if e != nil {
		return 0, buf, e
	}
	if versions < 0 {
		return 0, buf, fmt.Errorf("decodeXLHeaders: Negative version count %d", versions)
	}
	return versions, buf, nil
}

// decodeVersions will decode a number of versions from a buffer
// and perform a callback for each version in order, newest first.

// Errors returned by Scanner.
var (
	ErrTooLong         = errors.New("bufio.Scanner: token too long")
	ErrNegativeAdvance = errors.New("bufio.Scanner: SplitFunc returns negative advance count")
	ErrAdvanceTooFar   = errors.New("bufio.Scanner: SplitFunc returns advance count beyond input")
	ErrBadReadCount    = errors.New("bufio.Scanner: Read returned impossible count")
)

const (

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.NullMarked;

/**
 * Testing utilities relating to garbage collection finalization.
 *
 * <p>Use this class to test code triggered by finalization, that is, one of the following
 * actions taken by the java garbage collection system:
 *
 * <ul>