{[]string{"127.0.0.1:" + casePorts[2], nonLoopBackIP + ":" + casePorts[2]}, "0.0.0.0:" + casePorts[2]},
		{[]string{"localhost:" + casePorts[3]}, "127.0.0.1:" + casePorts[3]},
		{[]string{nonLoopBackIP + ":" + casePorts[4]}, nonLoopBackIP + ":" + casePorts[4]},
		{[]string{"127.0.0.1:" + casePorts[5], nonLoopBackIP + ":" + casePorts[5]}, "0.0.0.0:" + casePorts[5]},
	}

nextTest:
	for i, testCase := range testCases {

 * second. This could be accomplished by requiring a permit per byte, and specifying a rate of 5000
 * permits per second:
 *
 * {@snippet :
 * final RateLimiter rateLimiter = RateLimiter.create(5000.0); // rate = 5000 permits per second
 * void submitPacket(byte[] packet) {
 *   rateLimiter.acquire(packet.length);
 *   networkService.send(packet);
 * }
 * }
 *

		wantInverted: []sparseEntry{{0, 0}},
	}, {
		in: []sparseEntry{}, size: 5000,
		wantValid:    true,
		wantInverted: []sparseEntry{{0, 5000}},
	}, {
		in: []sparseEntry{{0, 5000}}, size: 5000,
		wantValid:    true,
		wantAligned:  []sparseEntry{{0, 5000}},
		wantInverted: []sparseEntry{{5000, 0}},
	}, {
		in: []sparseEntry{{1000, 4000}}, size: 5000,
		wantValid:    true,
		wantAligned:  []sparseEntry{{1024, 3976}},

key":"enable_http2","value":"off"}]},"region":{"_":[{"key":"name","value":""}]},"scanner":{"_":[{"key":"speed","value":"default"},{"key":"idle_speed","value":""},{"key":"alert_excess_versions","value":"100"},{"key":"alert_excess_folders","value":"50000"},{"key":"delay","value":""},{"key":"max_wait","value":""},{"key":"cycle","value":""}]},"site":{"_":[{"key":"name","value":""},{"key":"region","value":""}]},"storage_class":{"_":[{"key":"standard","value":"EC:5"},{"key":"rrs","value":"EC:1"},{"key...

60000..6FFFD  ; disallowed                             # NA   <reserved-60000>..<reserved-6FFFD>
6FFFE..6FFFF  ; disallowed                             # 2.0  <noncharacter-6FFFE>..<noncharacter-6FFFF>
70000..7FFFD  ; disallowed                             # NA   <reserved-70000>..<reserved-7FFFD>
7FFFE..7FFFF  ; disallowed                             # 2.0  <noncharacter-7FFFE>..<noncharacter-7FFFF>

type usageTestFile struct {
	name string
	size int
}

func TestDataUsageUpdate(t *testing.T) {
	base := t.TempDir()
	const bucket = "bucket"
	files := []usageTestFile{
		{name: "rootfile", size: 10000},
		{name: "rootfile2", size: 10000},
		{name: "dir1/d1file", size: 2000},
		{name: "dir2/d2file", size: 300},
		{name: "dir1/dira/dafile", size: 100000},
		{name: "dir1/dira/dbfile", size: 200000},

    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate
        .Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate
    assertThat(certificate.notBefore.time).isEqualTo(5000L)
    assertThat(certificate.notAfter.time).isEqualTo(10000L)
  }

  @Test
  fun customDuration() {
    val now = System.currentTimeMillis()

| Maximum number of versions per object                                           | 10000 (can be configured to higher values but we do not recommend beyond 10000) |

            int consumed = Math.min(19, reqPath.length());

            data1 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);

            data2 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);
        }

        @Test
        @DisplayName("Should be equal for same values")
        void testEquals() {

import org.jspecify.annotations.NullUnmarked;

/** Test Java8 map.compute in concurrent cache context. */
@NullUnmarked
public class LocalCacheMapComputeTest extends TestCase {
  final int count = 10000;
  final String delimiter = "-";
  final String key = "key";
  Cache<String, String> cache;

  // helper
  private static void doParallelCacheOp(int count, IntConsumer consumer) {