// 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

	if endpoint == "" {
		return nil
	}

	buf, err := json.Marshal(ri)
	if err != nil {
		return err
	}

	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(buf))
	if err != nil {
		return err
	}

	if token != "" {

        SMBUtil.writeInt4(10, buffer, notifyOffset + 8); // FileNameLength
        System.arraycopy("file1".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 10);

        // Second notification at offset 120 (80 + 40)
        notifyOffset = 120;
        SMBUtil.writeInt4(44, buffer, notifyOffset); // NextEntryOffset
        SMBUtil.writeInt4(2, buffer, notifyOffset + 4); // Action (REMOVED)

		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.

        assertEquals(3, dst[1] & 0xFF, "Data length low byte");
        assertEquals(0, dst[2] & 0xFF, "Data length high byte");
        assertEquals(2, dst[3], "First data byte");
        assertEquals(3, dst[4], "Second data byte");
        assertEquals(4, dst[5], "Third data byte");
    }

    /**
     * Test readParameterWordsWireFormat always returns 0
     */
    @Test

And also after the `response` is generated, before returning it.

For example, you could add a custom header `X-Process-Time` containing the time in seconds that it took to process the request and generate a response:

{* ../../docs_src/middleware/tutorial001.py hl[10,12:13] *}

/// tip

 *
 * <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.)

				runAllIAMConcurrencyTests(testCase, &check{t, testCase.serverType})
			},
		)
	}
}

func (s *TestSuiteIAM) TestDeleteUserRace(c *check) {
	ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
	defer cancel()

	bucket := getRandomBucketName()
	err := s.client.MakeBucket(ctx, bucket, minio.MakeBucketOptions{})
	if err != nil {
		c.Fatalf("bucket creat error: %v", err)
	}

	// Create a policy policy

| user               | string                                  | Identifier for owner of requested credentials          |
| maxValiditySeconds | integer (>= 900 seconds and < 365 days) | Maximum allowed expiry duration for the credentials    |
| claims             | key-value pairs                         | Claims to be associated with the requested credentials |

                                            <c:forEach var="item" items="${jspFileNameItems}">
                                                <la:option value="${f:u(item.first)}">${f:h(item.second)}</la:option>
                                            </c:forEach>
                                        </la:select>
                                    </div>
                                </div>