// divisor, it avoids loops.
	slices.Sort(setCounts)

	return setCounts
}

// getSetIndexes returns list of indexes which provides the set size
// on each index, this function also determines the final set size
// The final set size has the affinity towards choosing smaller
// indexes (total sets)

 */
@Deprecated(since = "4.0.0")
class UrlNormalizingPostProcessor implements InterpolationPostProcessor {

    private static final Set<String> URL_EXPRESSIONS;

    static {
        Set<String> expressions = new HashSet<>();
        expressions.add("project.url");
        expressions.add("project.scm.url");
        expressions.add("project.scm.connection");

	for _, t := range tgts {
		labels := []string{nameL, t.String(), endpointL, t.Endpoint()}
		m.Set(webhookFailedMessages, float64(t.Stats().FailedMessages), labels...)
		m.Set(webhookQueueLength, float64(t.Stats().QueueLength), labels...)
		m.Set(webhookTotalMessages, float64(t.Stats().TotalMessages), labels...)
	}

	return nil

  }

  /** Returns the platform preferred implementation of a set based on a hash table. */
  static <E extends @Nullable Object> Set<E> newHashSetWithExpectedSize(int expectedSize) {
    return Sets.newHashSetWithExpectedSize(expectedSize);
  }

  /** Returns the platform preferred implementation of a thread-safe hash set. */
  static <E> Set<E> newConcurrentHashSet() {
    return ConcurrentHashMap.newKeySet();
  }

    testers.add(MultisetIteratorTester.class);
    testers.add(MultisetSerializationTester.class);
    return testers;
  }

  private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> features) {
    Set<Feature<?>> derivedFeatures = new HashSet<>(features);
    derivedFeatures.remove(CollectionFeature.GENERAL_PURPOSE);
    derivedFeatures.remove(CollectionFeature.SUPPORTS_ADD);

			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.set, result)
		}

		result.add(testCase.targetIDToAdd)
		if reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: not equal, got: equal", i+1)
		}
	}
}

func TestTargetIDSetUnion(t *testing.T) {
	testCases := []struct {
		set            TargetIDSet
		setToAdd       TargetIDSet
		expectedResult TargetIDSet
	}{

 */
@CacheableTask
public abstract class FindMissingDocumentationFiles extends DefaultTask {
    private static final Set<String> EXCLUDED_FILES = new HashSet<>(Arrays.asList(
        "temp.adoc",
        "userguide_single.adoc"
    ));

    private static final Set<String> EXCLUDED_ANCHORS = new HashSet<>(Arrays.asList(
        // properties have been deprecated in Gradle 9.0.0
        "sec:war_convention_properties",

        request = new Smb2QueryInfoRequest(mockConfig);
        byte testFileInfoClass = (byte) 0x10;

        request.setFileInfoClass(testFileInfoClass);

        // Verify file info class was set and info type was set to SMB2_0_INFO_FILE
        try {
            Field fileInfoClassField = Smb2QueryInfoRequest.class.getDeclaredField("fileInfoClass");
            fileInfoClassField.setAccessible(true);

        }
      } else {
        // set on the future completed
        assertFalse(cancellationSuccess.get());
        assertTrue(setFutureSetSuccess.get());
        assertTrue(setFutureCompletionSuccess.get());
      }
      // reset for next iteration
      setFutureSetSuccess.set(false);
      setFutureCompletionSuccess.set(false);
      cancellationSuccess.set(false);
      finalResults.clear();
    }

    }

    /**
     * Wraps exception handling for {@link Properties#load(InputStream)}.
     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param props the property set (must not be {@literal null})
     * @param in the input stream (must not be {@literal null})
     */
    public static void load(final Properties props, final InputStream in) {
        assertArgumentNotNull("props", props);