elements = new Object[distinct];
      counts = new int[distinct];
      int i = 0;
      for (Entry<? extends Object> entry : multiset.entrySet()) {
        elements[i] = entry.getElement();
        counts[i] = entry.getCount();
        i++;
      }
    }

    Object readResolve() {
      ImmutableMultiset.Builder<Object> builder =

        Configuration cfg = Mockito.mock(Configuration.class);
        return new Smb2LogoffResponse(cfg);
    }

    @Test
    @DisplayName("Constructor accepts a Configuration and creates instance")
    void constructor_happyPath() {
        // Arrange
        Configuration cfg = Mockito.mock(Configuration.class);

        // Act
        Smb2LogoffResponse resp = new Smb2LogoffResponse(cfg);

        // Assert

    return Arrays.asList(
        new Object[][] {
          {new MapIteratorCache<String, String>(new HashMap<String, String>())},
          {new MapIteratorCache<String, String>(new TreeMap<String, String>(nullsLast))},
          {new MapRetrievalCache<String, String>(new HashMap<String, String>())},
          {new MapRetrievalCache<String, String>(new TreeMap<String, String>(nullsLast))}
        });
  }

  @Before

  public static <K extends Comparable<?>, V> Builder<K, V> naturalOrder() {
    return new Builder<K, V>(Ordering.natural());
  }

  public static <K, V> Builder<K, V> orderedBy(Comparator<K> comparator) {
    return new Builder<K, V>(comparator);
  }

  public static <K extends Comparable<?>, V> Builder<K, V> reverseOrder() {
    return new Builder<K, V>(Ordering.natural().reverse());
  }

    public void setUp() throws Exception {
        super.setUp();
        thumbnailGenerator = new ThumbnailGenerator();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
    }

    public void test_constructor() {
        // Test default constructor
        ThumbnailGenerator generator = new ThumbnailGenerator();
        assertNotNull(generator);
    }

    assertEquals(hash32, Hashing.combineOrdered(ImmutableList.of(hash32)));
    assertEquals(
        HashCode.fromBytes(new byte[] {(byte) 0x80, 0, 0, 0}),
        Hashing.combineOrdered(ImmutableList.of(hash32, hash32)));
    assertEquals(
        HashCode.fromBytes(new byte[] {(byte) 0xa0, 0, 0, 0}),
        Hashing.combineOrdered(ImmutableList.of(hash32, hash32, hash32)));
    assertFalse(

        long t;

        return switch (enc) {
        case TIME_1970_SEC_32BE -> new Date(dec_uint32be(src, si) * 1000L);
        case TIME_1970_SEC_32LE -> new Date(dec_uint32le(src, si) * 1000L);
        case TIME_1904_SEC_32BE -> new Date(((dec_uint32be(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);
        case TIME_1904_SEC_32LE -> new Date(((dec_uint32le(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);

    Files.copy(i18nFile, temp1);
    moveHelper(true, new UnmovableFile(temp1, false, true), temp2);
    assertTrue(Files.equal(temp2, i18nFile));
  }

  public void testMoveFailures() throws IOException {
    File temp1 = createTempFile();
    File temp2 = createTempFile();

    moveHelper(false, new UnmovableFile(temp1, false, false), temp2);
    moveHelper(

        // Arrange: program send() to simulate first, next, next(NO_MORE_FILES)
        List<String[]> batches = new ArrayList<>();
        batches.add(new String[] { ".", "..", "a", "b" }); // first batch, dot entries filtered
        batches.add(new String[] { "c" }); // second batch
        batches.add(new String[] {}); // last -> NO_MORE_FILES

        // send() answer that mutates the provided response

            SmbTreeHandleImpl sh = newTreeHandle(false);
            SmbTreeHandleImpl dh = newTreeHandle(false);

            byte[][] buffers = new byte[][] { new byte[8], new byte[8] };

            // Act + Assert (no exception)
            assertDoesNotThrow(() -> SmbCopyUtil.copyFile(src, dest, buffers, 8, new WriterThread(), sh, dh));
        }
    }