* Booleans.contains(array, false)} with {@code bitSet.nextClearBit(0) == sizeOfBitSet}.
   *
   * @param array an array of {@code boolean} values, possibly empty
   * @param target a primitive {@code boolean} value
   * @return {@code true} if {@code array[i] == target} for some value of {@code i}
   */
  public static boolean contains(boolean[] array, boolean target) {
    for (boolean value : array) {
      if (value == target) {

   * Booleans.contains(array, false)} with {@code bitSet.nextClearBit(0) == sizeOfBitSet}.
   *
   * @param array an array of {@code boolean} values, possibly empty
   * @param target a primitive {@code boolean} value
   * @return {@code true} if {@code array[i] == target} for some value of {@code i}
   */
  public static boolean contains(boolean[] array, boolean target) {
    for (boolean value : array) {
      if (value == target) {

    testRotate(new boolean[] {true}, 1, new boolean[] {true});
    testRotate(new boolean[] {true}, 2, new boolean[] {true});

    testRotate(new boolean[] {true, false}, -3, new boolean[] {false, true});
    testRotate(new boolean[] {true, false}, -1, new boolean[] {false, true});
    testRotate(new boolean[] {true, false}, -2, new boolean[] {true, false});

            "true,true,false", "true,false,true", "false,true,true", "false,false,false" })
    void disconnect_flagCombinations(boolean hard, boolean inuse, boolean expected) throws Exception {
        when(transport.disconnect(anyBoolean(), anyBoolean())).thenAnswer(inv -> {
            boolean h = inv.getArgument(0);
            boolean u = inv.getArgument(1);
            // Arbitrary behavior mapping for test purposes
            return (h && !u) || (!h && u);

    // Happy path: shouldForceSigning returns the configured value
    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("shouldForceSigning returns stubbed boolean value")
    void shouldForceSigningReturns(boolean expected) {
        when(locator.shouldForceSigning()).thenReturn(expected);

        boolean result = locator.shouldForceSigning();

        assertEquals(expected, result);

    }

    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("isOpen delegates to handle.isOpen")
    void isOpen_delegates(boolean state) throws Exception {
        // Arrange
        SmbPipeOutputStream out = newStream();
        when(handle.isOpen()).thenReturn(state);

        // Act
        boolean result = out.isOpen();

        // Assert

    // Happy path: isInUse returns the mocked state
    @ParameterizedTest
    @DisplayName("isInUse reflects current mocked state")
    @ValueSource(booleans = { true, false })
    void isInUse_variants(boolean inUse) {
        when(session.isInUse()).thenReturn(inUse);

        boolean result = session.isInUse();

        assertEquals(inUse, result);
        verify(session, times(1)).isInUse();
    }

      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @ParameterizedTest
  @ValueSource(booleans = [false, true])
  fun proxyMoveTest(cleanClose: Boolean) {
    // Define a single Proxy at myproxy:8008 that will artificially move during the test
    val proxySelector = RecordingProxySelector()

    platform.assumeNotOpenJSSE()
    platform.assumeNotBouncyCastle()
    listener.forbidLock(get(client.connectionPool))
    listener.forbidLock(client.dispatcher)
  }

  @ParameterizedTest
  @ValueSource(booleans = [true, false])
  fun successfulCallEventSequence() {
    server!!.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server!!.url("/"))

public class SmbCopyUtilTest {

    // --- Tests for openCopyTargetFile ---

    @ParameterizedTest
    @ValueSource(booleans = { true, false })
    @DisplayName("openCopyTargetFile sets correct access flags depending on alsoRead")
    void openCopyTargetFile_accessMask_respectsAlsoRead(boolean alsoRead) throws Exception {
        // Arrange
        SmbFile dest = mock(SmbFile.class);