builder.put(entry.getKey(), entry.getValue());
      }
      return ImmutableMap.copyOf(builder);
    }
  }

  public static class ImmutableMapCopyOfEntriesGenerator extends TestStringMapGenerator {
    @Override
    protected Map<String, String> create(Entry<String, String>[] entries) {
      return ImmutableMap.copyOf(asList(entries));
    }
  }

  public static class ImmutableMapUnhashableValuesGenerator

    private final transient ImmutableList<Entry<K, V>> entries;

    RegularEntrySet(ImmutableMap<K, V> map, Entry<K, V>[] entries) {
      this(map, asImmutableList(entries));
    }

    RegularEntrySet(ImmutableMap<K, V> map, ImmutableList<Entry<K, V>> entries) {
      this.map = map;
      this.entries = entries;
    }

    @Override
    ImmutableMap<K, V> map() {
      return map;
    }

  // If the `next` bits in `entries[i]` are 0 that means there are no further entries for the given
  // short hash. But 0 is also a valid index in `entries`, so we add 1 to these indices before
  // putting them in `table` or in `next` bits, and subtract 1 again when we need an index value.
  //
  // The elements of `keys`, `values`, and `entries` are added sequentially, so that elements 0 to

  public static class ImmutableBiMapGenerator extends TestStringBiMapGenerator {
    @Override
    protected BiMap<String, String> create(Entry<String, String>[] entries) {
      ImmutableBiMap.Builder<String, String> builder = ImmutableBiMap.builder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  // If the `next` bits in `entries[i]` are 0 that means there are no further entries for the given
  // short hash. But 0 is also a valid index in `entries`, so we add 1 to these indices before
  // putting them in `table` or in `next` bits, and subtract 1 again when we need an index value.
  //
  // The elements of `keys`, `values`, and `entries` are added sequentially, so that elements 0 to

        assertEquals(0, response.status, "Status should be 0.");
        assertEquals(2, response.numEntries, "Number of entries should be 2.");
    }

    /**
     * Tests the readDataWireFormat method.
     * This test simulates a response with two share entries.
     */
    @Test
    void testReadDataWireFormat() throws IOException {
        NetShareEnumResponse response = new NetShareEnumResponse();

  }

  private final transient Map<K, V> delegateMap;
  private final transient ImmutableList<Entry<K, V>> entries;

  JdkBackedImmutableMap(Map<K, V> delegateMap, ImmutableList<Entry<K, V>> entries) {
    this.delegateMap = delegateMap;
    this.entries = entries;
  }

  @Override
  public int size() {
    return entries.size();
  }

  @Override
  public @Nullable V get(@Nullable Object key) {

      if (entries instanceof Collection) {
        ensureCapacity(size + ((Collection<?>) entries).size());
      }
      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);
      }
      return this;
    }

    /**
     * Configures this {@code Builder} to order entries by value according to the specified
     * comparator.

          entryIndex = next - 1;
          entry = entries[entryIndex];
          next = CompactHashing.getNext(entry, mask);
        } while (next != srcNext);
        // here, entries[entryIndex] points to the old entry location; update it
        entries[entryIndex] = CompactHashing.maskCombine(entry, dstIndex + 1, mask);
      }
    } else {
      elements[dstIndex] = null;
      entries[dstIndex] = 0;
    }
  }

    @Test
    @DisplayName("Happy path without filter: iterates all entries in order")
    void happyPath_noFilter_returnsAll() throws Exception {
        SmbFile parent = newParent();
        List<FileEntry> entries = Arrays.asList(entry("foo", SmbConstants.TYPE_SHARE), entry("bar", SmbConstants.TYPE_SHARE));
        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), null);

        // hasNext/next sequence over two elements