@DisplayName("shouldForceSigning returns stubbed boolean value")
    void shouldForceSigningReturns(boolean expected) {
        when(locator.shouldForceSigning()).thenReturn(expected);

        boolean result = locator.shouldForceSigning();

        assertEquals(expected, result);
        verify(locator, times(1)).shouldForceSigning();
        verifyNoMoreInteractions(locator);
    }

      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());

      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());

import org.junit.jupiter.api.Test;

/**
 * Tests for the {@link ResolverType} enum.
 * This class ensures that the enum constants are defined as expected.
 */
class ResolverTypeTest {

    /**
     * Tests that all expected enum constants exist.
     */
    @Test
    void testEnumConstants() {
        // Verify that each enum constant exists and can be referenced

package handlers

import (
	"net/http"
	"testing"
)

type headerTest struct {
	key      string // header key
	val      string // header val
	expected string // expected result
}

func TestGetScheme(t *testing.T) {
	headers := []headerTest{
		{xForwardedProto, "https", "https"},
		{xForwardedProto, "http", "http"},
		{xForwardedProto, "HTTP", "http"},

      assertTrue(hp.hasPort());
      assertEquals(expectPort, hp.getPort());
    } else {
      assertFalse(hp.hasPort());
      try {
        hp.getPort();
        fail("Expected IllegalStateException");
      } catch (IllegalStateException expected) {
      }
    }
    assertThat(hp.getHost()).isEqualTo(expectHost);

    // Check the post-withDefaultPort() instance (if any).
    if (!badDefaultPort) {
      try {

	initial := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogFailure()
	}

	adjusted := timeout.Timeout()

	if initial >= adjusted {
		t.Errorf("Failure to increase timeout, expected %v to be more than %v", adjusted, initial)
	}
}

func TestDynamicTimeoutDualIncrease(t *testing.T) {
	timeout := newDynamicTimeout(time.Minute, time.Second)

	initial := timeout.Timeout()

		t.Run(testCase.timeStr, func(t *testing.T) {
			gott, goterr := Parse(testCase.timeStr)
			if !errors.Is(goterr, testCase.expectedErr) {
				t.Errorf("expected %v, got %v", testCase.expectedErr, goterr)
			}
			if !gott.Equal(testCase.expectedTime) {
				t.Errorf("expected %v, got %v", testCase.expectedTime, gott)
			}
		})
	}

    private FileEntry[] results;

    /**
     * Constructs a SMB2 query directory response with the specified configuration and expected information class
     *
     * @param config
     *            the configuration to use for this response
     * @param expectInfoClass
     *            the expected file information class in the response
     */
    public Smb2QueryDirectoryResponse(final Configuration config, final byte expectInfoClass) {

    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->
      expected.assertSuppressed {
        val suppressed = it.single()
        assertThat(suppressed).isInstanceOf(IOException::class.java)
        assertThat(suppressed).isNotSameAs(expected)
      }
    }
  }

  /** Confirm suppressed exceptions that occur after connecting are returned. */