assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */
    @Test
    void decodeFromEncodedBuffer() throws NdrException {

				// Only proceed for local endpoints
				network[nodeName] = string(madmin.ItemOnline)
				continue
			}
			_, present := network[nodeName]
			if !present {
				if err := isServerResolvable(endpoint, 5*time.Second); err == nil {
					network[nodeName] = string(madmin.ItemOnline)
				} else {
					if xnet.IsNetworkOrHostDown(err, false) {
						network[nodeName] = string(madmin.ItemOffline)

 *
 * <p><b>Warning:</b> {@code ArrayTable} is rarely the {@link Table} implementation you want. First,
 * it requires that the complete universe of rows and columns be specified at construction time.
 * Second, it is always backed by an array large enough to hold a value for every possible
 * combination of row and column keys. (This is rarely optimal unless the table is extremely dense.)

        assertNotNull(newStackTrace);
    }

    public void test_multipleInstances() {
        // Test that multiple instances are independent
        String message1 = "First exception";
        String message2 = "Second exception";

        UnsupportedSearchException exception1 = new UnsupportedSearchException(message1);
        UnsupportedSearchException exception2 = new UnsupportedSearchException(message2);

  /**
   * @param c the number of compression rounds (must be positive)
   * @param d the number of finalization rounds (must be positive)
   * @param k0 the first half of the key
   * @param k1 the second half of the key
   */
  SipHashFunction(int c, int d, long k0, long k1) {
    checkArgument(
        c > 0, "The number of SipRound iterations (c=%s) during Compression must be positive.", c);
    checkArgument(

        ResourceManager.ManagedResource<TestResource> managed = resourceManager.manage(resource);

        managed.close();
        assertTrue(resource.isClosed());

        // Second close should not throw
        assertDoesNotThrow(managed::close);
    }

    @Test
    @DisplayName("Test null resource registration throws exception")
    void testNullResourceRegistration() {

		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},
		{"driver.Valuer not equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now.Add(time.Second), Valid: true}, false},
		{"driver.Valuer equal (ptr to nil ptr)", (*ModifyAt)(nil), &ModifyAt{}, false},
	}
	for _, test := range assertEqualTests {
		t.Run(test.name, func(t *testing.T) {

        byte[] data1 = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data1, 0, data1.length);
        byte[] result1 = digest.digest();
        assertNotNull(result1);

        // Second cycle
        byte[] data2 = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        digest.update(data2, 0, data2.length);
        byte[] result2 = digest.digest();
        assertNotNull(result2);

        // Test first host
        NbtAddress result = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result);
        assertEquals("TESTHOST", result.getHostName());

        // Test second host
        result = lmhosts.getByName("SERVER01", mockContext);
        assertNotNull(result);
        assertEquals("SERVER01", result.getHostName());
    }

    @Test

		var c *metacache
		if rpc == nil {
			resp := localMetacacheMgr.getBucket(ctx, o.Bucket).findCache(*o)
			c = &resp
		} else {
			rctx, cancel := context.WithTimeout(ctx, 5*time.Second)
			c, err = rpc.GetMetacacheListing(rctx, *o)
			cancel()
		}
		if err != nil {
			if errors.Is(err, context.Canceled) {
				// Context is canceled, return at once.