assertEquals("********", SystemUtil.maskSensitiveValue("auth_header", "Bearer xyz"));
        assertEquals("********", SystemUtil.maskSensitiveValue("OAUTH_CLIENT_ID", "123456"));
    }

    @Test
    public void test_maskSensitiveValue_withPrivate() {
        assertEquals("********", SystemUtil.maskSensitiveValue("PRIVATE_DATA", "sensitive"));

    Table<Character, Integer, String> table = builder.buildOrThrow();
    assertThat(table.rowKeySet()).containsExactly('b', 'c', 'e', 'r', 'x').inOrder();
    assertThat(table.columnKeySet()).containsExactly(0, 1, 2, 3, 4, 5, 7).inOrder();
    assertThat(table.values())
        .containsExactly("cat", "axe", "baz", "tub", "dog", "bar", "foo", "foo", "bar")
        .inOrder();

        @Test
        @DisplayName("Should get NTLM challenge with address")
        void testGetChallengeWithAddress() throws CIFSException {
            // Given
            byte[] expectedChallenge = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            when(transportPool.getChallenge(context, address)).thenReturn(expectedChallenge);

            // When
            byte[] result = transportPool.getChallenge(context, address);

        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

    @Test
    public void test_ofNullable_withBigDecimal() {
        BigDecimal testValue = new BigDecimal("123.456");
        OptionalEntity<BigDecimal> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

        assertEquals(reasoning, result.getReasoning());
    }

    @Test
    public void test_documentUrl_preserved() {
        final String docUrl = "https://example.com/doc-123-456.pdf";
        final IntentDetectionResult result = IntentDetectionResult.summary(docUrl, "summary");

        assertEquals(docUrl, result.getDocumentUrl());
    }

    @Test

        void testConstructorAndOpnum() {
            // When: Creating open alias message
            samr.SamrOpenAlias message = new samr.SamrOpenAlias(mockPolicyHandle, 123, 456, mockPolicyHandle);

            // Then: Should have correct values
            assertEquals(0x1b, message.getOpnum());
            assertEquals(mockPolicyHandle, message.domain_handle);

		t.Errorf("Failed to generate sql, got %v", sql)
	}

	stmt = dryRunDB.Model(&user).Where("id = ?", 1).Updates(map[string]interface{}{"age": ageFloat(0.12345678)}).Statement
	sql = DB.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
	if !regexp.MustCompile(`.*age.*=0.123457,`).MatchString(sql) {
		t.Errorf("Failed to generate sql, got %v", sql)
	}
}

func TestGroupConditions(t *testing.T) {
	type Pizza struct {

        // Test with empty string
        searchRenderData.setQueryId("");
        assertEquals("", searchRenderData.getQueryId());

        // Test with UUID-like string
        String uuid = "123e4567-e89b-12d3-a456-426614174000";
        searchRenderData.setQueryId(uuid);
        assertEquals(uuid, searchRenderData.getQueryId());

        // Test with simple ID
        searchRenderData.setQueryId("query-001");

        }

        @Test
        @DisplayName("toString uses hex authority when high bytes are non-zero")
        void testToStringHexAuthority() {
            byte[] ident = new byte[] { 1, 2, 3, 4, 5, 6 }; // high bytes non-zero -> hex representation
            SID sid = new SID(buildSidT((byte) 1, ident, 7, 8), jcifs.SID.SID_TYPE_USE_NONE, null, null, false);
            String s = sid.toString();

        when(response.getDigest()).thenReturn(digest);
        response.setDigest(digest);
        assertEquals(digest, response.getDigest());

        // Test mid methods
        long mid = 123456L;
        doNothing().when(response).setMid(mid);
        when(response.getMid()).thenReturn(mid);
        response.setMid(mid);
        assertEquals(mid, response.getMid());

        // Test command methods