},
	}
	for _, result := range results {
		t.Run(result.name, func(t *testing.T) {
			user, _ := schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)
			stmt := &gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}
			result.join.Build(stmt)
			if result.sql != stmt.SQL.String() {
				t.Errorf("want: %s, got: %s", result.sql, stmt.SQL.String())
			}
		})
	}

    void testIsSigningEnforcedReturnsTrue() {
        // Given
        when(negotiationRequest.isSigningEnforced()).thenReturn(true);

        // When
        boolean result = negotiationRequest.isSigningEnforced();

        // Then
        assertTrue(result, "isSigningEnforced should return true when signing is enforced");
        verify(negotiationRequest, times(1)).isSigningEnforced();
    }

    @Test

    private final transient DependencyResolutionResult result;
    private final transient String detailMessage;

    public DependencyResolutionException(DependencyResolutionResult result, String message, Throwable cause) {
        super(message, cause);
        this.result = result;
        this.detailMessage = prepareDetailMessage(message, result);
    }

                }
                result.addException(e);
                throw new ArtifactDescriptorException(result);
            }

            Artifact relocatedArtifact = getRelocation(session, result, model);
            if (relocatedArtifact != null) {
                if (withinSameGav(relocatedArtifact, a)) {
                    result.setArtifact(relocatedArtifact);

        int extraPad = 0;
        when(signingDigest.verify(testData, offset, length, extraPad, message)).thenReturn(true);

        // Act
        boolean result = signingDigest.verify(testData, offset, length, extraPad, message);

        // Assert
        assertTrue(result, "Verify should return true for valid signature");
        verify(signingDigest, times(1)).verify(testData, offset, length, extraPad, message);
    }

    @Test

        byte[] buffer = new byte[1024];

        int result = setupAndX.readBytesWireFormat(buffer, 0);

        // The implementation always returns 0
        assertEquals(0, result, "readBytesWireFormat returns 0");
    }

    @Test
    void testToString() {
        String result = setupAndX.toString();
        assertNotNull(result);

            // Test at buffer start
            int result1 = request.encode(buffer, 0);
            assertTrue(result1 > 0);

            // Test at buffer middle
            int result2 = request.encode(buffer, 128);
            assertTrue(result2 > 0);

            // Test near buffer end (should still fit)
            request.setEncodedSize(16);
            int result3 = request.encode(buffer, 240);

        String result = server.toString();

        assertNotNull(result);
        assertTrue(result.startsWith("ServerInfo1["));
        assertTrue(result.contains("name=SERVER01"));
        assertTrue(result.contains("versionMajor=6"));
        assertTrue(result.contains("versionMinor=1"));
        assertTrue(result.contains("type=0x00000801"));
        assertTrue(result.contains("commentOrMasterBrowser=Test server"));

        // Act
        String result = transPeekNamedPipe.toString();

        // Assert
        assertNotNull(result);
        assertTrue(result.contains("TransPeekNamedPipe"));
        if (pipeName != null) {
            assertTrue(result.contains("pipeName=" + pipeName));
        } else {
            assertTrue(result.contains("pipeName=null"));
        }
    }

    @Test

    timeout: Long,
    unit: TimeUnit,
  ): ConnectResult? {
    if (tcpConnectsInFlight.isEmpty()) return null

    val result = connectResults.poll(timeout, unit) ?: return null

    tcpConnectsInFlight.remove(result.plan)

    return result
  }

  private fun cancelInFlightConnects() {
    for (plan in tcpConnectsInFlight) {
      plan.cancel()