// Given
            SmbResource destination = mock(SmbResource.class);

            // When/Then
            assertDoesNotThrow(() -> mockResource.copyTo(destination), "Copy operation should not throw exception");
            verify(mockResource).copyTo(destination);
        }

        @Test
        @DisplayName("rename operations should work correctly")
        void testRenameTo() throws CIFSException {

        // Create a defensive copy to avoid ConcurrentModificationException
        List<CommonServerMessageBlock> operationsCopy = List.copyOf(pendingOps);

        // Clear the failed channel's pending operations first
        failedChannel.clearPendingOperations();

        // Redistribute to healthy channels

        });
  }

  private CacheBuilderFactory cacheFactory() {
    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(Strength.STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.copyOf(Strength.values()))
        .withConcurrencyLevels(ImmutableSet.of(1, 4, 16, 64))
        .withMaximumSizes(ImmutableSet.of(0, 1, 10, 100, 1000))
        .withInitialCapacities(ImmutableSet.of(0, 1, 10, 100, 1000))

    assertEquals(newMap.entrySet(), map.entrySet());
    assertEquals(newMap.keySet(), map.keySet());
    Set<Object> expectedValues = ImmutableSet.of(one);
    Set<Object> actualValues = ImmutableSet.copyOf(map.values());
    assertEquals(expectedValues, actualValues);
  }

  /** Lookups on the map view shouldn't impact the recency queue. */
  public void testAsMapRecency() {
    CacheBuilder<Object, Object> builder =

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

      assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb));
    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;
    final Long asLong; // null means that asLong should throw an exception

                } catch (final Exception x) {
                    this.e = new SmbException("WriterThread", x);
                }
                notify();
            }
        }
    }

    void copyTo0(final SmbFile dest, final byte[][] b, final int bsize, final WriterThread w, final SmbComReadAndX req,
            final SmbComReadAndXResponse resp) throws SmbException {
        int i;

              @Override
              public Set<AnEnum> create(AnEnum[] elements) {
                return (elements.length == 0)
                    ? EnumSet.noneOf(AnEnum.class)
                    : EnumSet.copyOf(MinimalCollection.of(elements));
              }
            })
        .named("EnumSet")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,
            CollectionFeature.SERIALIZABLE,

 * ImmutableNetwork}.
 *
 * <p>You can create an immutable copy of an existing {@code Network} using {@link
 * ImmutableNetwork#copyOf(Network)}:
 *
 * {@snippet :
 * ImmutableNetwork<Integer, MyEdge> immutableGraph = ImmutableNetwork.copyOf(network);
 * }
 *
 * <p>Instances of {@link ImmutableNetwork} do not implement {@link MutableNetwork} (obviously!) and

   *     array}, plus {@code element} occupying the last position.
   */
  public static <T extends @Nullable Object> T[] concat(T[] array, @ParametricNullness T element) {
    T[] result = Arrays.copyOf(array, array.length + 1);
    result[array.length] = element;
    return result;
  }

  /**
   * Returns an array containing all of the elements in the specified collection; the runtime type

        filtered.forEach(
            (Integer i) -> {
              assertTrue("Unexpected element: " + i, EVEN.apply(i));
              foundElements.add(i);
            });
        assertEquals(ImmutableList.copyOf(filtered), foundElements);
      }
    }
  }

  public abstract static class AbstractFilteredCollectionTest<C extends Collection<Integer>>
      extends AbstractFilteredIterableTest<C> {