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

        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);

        assertNotNull(result1);
        assertFalse(result1.hasFailure());

        runner.refresh();

        // Second write with update
        SuggestItem updatedItem = new SuggestItem(new String[] { "テスト" }, readings, new String[] { "content" }, 2, 0, -1,

            notification.readBytesWireFormat(buffer1, 0);

            // Second read with different values
            byte[] fileId2 = new byte[16];
            Arrays.fill(fileId2, (byte) 0x99);
            byte[] buffer2 = createValidOplockBreakBuffer((byte) 0x08, fileId2);
            notification.readBytesWireFormat(buffer2, 0);

            // Verify second read overwrote first read values

            names.names[0].sid_type = (short) jcifs.SID.SID_TYPE_USER;
            names.names[0].name = new UnicodeString("alice", false);
            names.names[0].sid_index = 0;
            // Second is a domain group
            names.names[1] = new lsarpc.LsarTranslatedName();
            names.names[1].sid_type = (short) jcifs.SID.SID_TYPE_DOM_GRP;
            names.names[1].name = new UnicodeString("Domain Users", false);

   * {@code key} (or zero, if there is none) is passed as the first argument to {@code
   * accumulatorFunction}, and {@code x} is passed as the second argument.
   *
   * @since 21.0
   */
  @CanIgnoreReturnValue
  public long accumulateAndGet(K key, long x, LongBinaryOperator accumulatorFunction) {
    checkNotNull(accumulatorFunction);

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

        final InputStream in2 = new ByteArrayInputStream("data2".getBytes());

        // First call
        extractor.testValidateInputStream(in1);

        // Second call with different stream
        extractor.testValidateInputStream(in2);

        // Third call with null should still throw
        try {
            extractor.testValidateInputStream(null);

        assertTrue(ipcSigningEnforced, "Should delegate IPC signing enforced setting");
        assertTrue(firstExtendedSecurityCall, "First call should return true");
        assertFalse(secondExtendedSecurityCall, "Second call should return false");

        verify(mockDelegate).isEncryptionEnabled();
        verify(mockDelegate).isSigningEnabled();
        verify(mockDelegate).isSigningEnforced();

	}

	u := url.URL(*o.args.URL)
	q := u.Query()
	q.Set("token", token)
	u.RawQuery = q.Encode()

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, u.String(), nil)
	if err != nil {
		return AuthNResponse{}, err
	}

	if o.args.AuthToken != "" {