private int resizeTable(int oldMask, int newCapacity, int targetHash, int targetEntryIndex) {
    Object newTable = CompactHashing.createTable(newCapacity);
    int newMask = newCapacity - 1;

    if (targetEntryIndex != UNSET) {
      // Add target first; it must be last in the chain because its entry hasn't yet been created
      CompactHashing.tableSet(newTable, targetHash & newMask, targetEntryIndex + 1);
    }

  private int resizeTable(int oldMask, int newCapacity, int targetHash, int targetEntryIndex) {
    Object newTable = CompactHashing.createTable(newCapacity);
    int newMask = newCapacity - 1;

    if (targetEntryIndex != UNSET) {
      // Add target first; it must be last in the chain because its entry hasn't yet been created
      CompactHashing.tableSet(newTable, targetHash & newMask, targetEntryIndex + 1);
    }

  private int resizeTable(int oldMask, int newCapacity, int targetHash, int targetEntryIndex) {
    Object newTable = CompactHashing.createTable(newCapacity);
    int newMask = newCapacity - 1;

    if (targetEntryIndex != UNSET) {
      // Add target first; it must be last in the chain because its entry hasn't yet been created
      CompactHashing.tableSet(newTable, targetHash & newMask, targetEntryIndex + 1);
    }

        when(project.getOutputDirectory(any(ProjectScope.class))).thenCallRealMethod();

        assertEquals(Path.of("myproject", "target", "classes"), targetPath(project));

        scope = ProjectScope.TEST;
        assertEquals(Path.of("myproject", "target", "test-classes"), targetPath(project));
    }

     *
     * @see #targetPath()
     * @see Project#getOutputDirectory(ProjectScope)
     */
    @Nonnull
    default Path targetPath(@Nonnull Project project) {
        Optional<Path> targetPath = targetPath();
        // The test for `isAbsolute()` is a small optimization for avoiding the call to `getOutputDirectory(…)`.
        return targetPath.filter(Path::isAbsolute).orElseGet(() -> {

        // Verify targetPath was preserved through conversion chain
        assertEquals(
                "custom-output", customResource.getTargetPath(), "targetPath should be preserved in ConnectedResource");

        // Test that includes modification preserves targetPath (tests ConnectedResource functionality)
        customResource.addInclude("*.properties");

     * <pre>{@code
     * <resource>
     *   <directory>src/main/resources</directory>
     *   <targetPath>META-INF/resources</targetPath>
     * </resource>
     * }</pre>
     * <p>
     * The maven-resources-plugin resolves {@code targetPath} as:
     * {@code project.build.outputDirectory + "/" + targetPath}, which results in
     * {@code target/classes/META-INF/resources}. This method provides the same base directory

                .includes(sourceRoot.includes())
                .excludes(sourceRoot.excludes())
                .filtering(Boolean.toString(sourceRoot.stringFiltering()))
                .targetPath(sourceRoot.targetPath().map(Path::toString).orElse(null))
                .build());
        this.originalSourceRoot = sourceRoot;
        this.scope = scope;
        this.project = project;
    }

    @Override

          <include>LICENSE</include> <!-- copied from the parent pom because I couldn't figure out a way to make combine.children="append" work -->
          <include>proguard/*</include>
        </includes>
        <targetPath>META-INF</targetPath>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <groupId>org.mvnsearch</groupId>
        <artifactId>toolchains-maven-plugin</artifactId>
      </plugin>
      <plugin>

          <include>LICENSE</include> <!-- copied from the parent pom because I couldn't figure out a way to make combine.children="append" work -->
          <include>proguard/*</include>
        </includes>
        <targetPath>META-INF</targetPath>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <groupId>org.mvnsearch</groupId>
        <artifactId>toolchains-maven-plugin</artifactId>
      </plugin>
      <plugin>