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

        }

        @Override
        public ComparisonChain compareTrueFirst(boolean left, boolean right) {
          return classify(Boolean.compare(right, left)); // reversed
        }

        @Override
        public ComparisonChain compareFalseFirst(boolean left, boolean right) {
          return classify(Boolean.compare(left, right));
        }

        ComparisonChain classify(int result) {

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

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

     * to any service performing a transition, then we can fail in the ServiceManager constructor
     * rather than in a Service.Listener callback.
     */
    @GuardedBy("monitor")
    boolean ready;

    @GuardedBy("monitor")
    boolean transitioned;

    final int numberOfServices;

    /**
     * Controls how long to wait for all the services to either become healthy or reach a state from

     * to any service performing a transition, then we can fail in the ServiceManager constructor
     * rather than in a Service.Listener callback.
     */
    @GuardedBy("monitor")
    boolean ready;

    @GuardedBy("monitor")
    boolean transitioned;

    final int numberOfServices;

    /**
     * Controls how long to wait for all the services to either become healthy or reach a state from

    void testIsValidReturnsTrue() {
        // Arrange
        when(negotiationResponse.isValid(cifsContext, negotiationRequest)).thenReturn(true);

        // Act
        boolean result = negotiationResponse.isValid(cifsContext, negotiationRequest);

        // Assert
        assertTrue(result);
        verify(negotiationResponse).isValid(cifsContext, negotiationRequest);
    }

    @Test

    @Override
    public boolean addAll(final int index, final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(index, c);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public boolean contains(final Object o) {
        return parent.contains(o);
    }

    @Override
    public boolean containsAll(final Collection<?> c) {