"fmt"
	"testing"
)

func Benchmark_bucketMetacache_findCache(b *testing.B) {
	bm := newBucketMetacache("", false)
	const elements = 50000
	const paths = 100
	if elements%paths != 0 {
		b.Fatal("elements must be divisible by the number of paths")
	}
	var pathNames [paths]string
	for i := range pathNames[:] {
		pathNames[i] = fmt.Sprintf("prefix/%d", i)
	}
	for i := range elements {
		bm.findCache(listPathOptions{

async function modifyOpenAPIFile(filePath) {
  try {
    const data = await fs.promises.readFile(filePath)
    const openapiContent = JSON.parse(data)

    const paths = openapiContent.paths
    for (const pathKey of Object.keys(paths)) {
      const pathData = paths[pathKey]
      for (const method of Object.keys(pathData)) {
        const operation = pathData[method]
        if (operation.tags && operation.tags.length > 0) {

import static org.junit.jupiter.api.Assertions.assertNotEquals;

public class JavaPathTypeTest {
    /**
     * {@return dummy paths to use in tests}.
     */
    private static List<Path> paths() {
        return List.of(Path.of("src", "foo.java"), Path.of("src", "bar.java"));
    }

    /**
     * Converts paths from Unix style to platform-dependent style.
     *
     * @param expected the option value expected by the test

    }

    /**
     * Get whitelisted paths
     */
    public Set<String> getWhitelistedPaths() {
        return Collections.unmodifiableSet(whitelistedPaths);
    }

    /**
     * Clear all blacklisted paths
     */
    public void clearBlacklist() {
        blacklistedPaths.clear();
    }

    /**
     * Clear all whitelisted paths
     */
    public void clearWhitelist() {

        this.numOfThread = value;
    }

    public String getPaths() {
        checkSpecifiedProperty("paths");
        return convertEmptyToNull(paths);
    }

    public void setPaths(String value) {
        registerModifiedProperty("paths");
        this.paths = value;
    }

    public String[] getPermissions() {
        checkSpecifiedProperty("permissions");

            if (StringUtil.isNotBlank(getIncludedDocPaths())) {
                final List<Pattern> pathPatterList = new ArrayList<>();
                final String[] paths = getIncludedDocPaths().split("[\r\n]");
                for (final String u : paths) {
                    final String v = systemHelper.normalizeConfigPath(u);
                    if (StringUtil.isNotBlank(v)) {

                                        <label for="paths" class="col-sm-2 text-sm-right col-form-label"><la:message
                                                key="labels.paths"/></label>
                                        <div class="col-sm-10">
                                            <la:text styleId="paths" property="paths" styleClass="form-control"/>
                                        </div>

     */
    @Nonnull
    @Override
    public String[] option(Iterable<? extends Path> paths) {
        return format(null, paths);
    }

    /**
     * Implementation shared with {@link Modular}.
     */
    final String[] format(String moduleName, Iterable<? extends Path> paths) {
        if (option == null) {
            throw new IllegalStateException("No option is associated to this path type.");

    public void setPaths_Equal(String paths) {
        setPaths_Term(paths, null);
    }

    public void setPaths_Equal(String paths, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setPaths_Term(paths, opLambda);
    }

    public void setPaths_Term(String paths) {
        setPaths_Term(paths, null);
    }

    public void setPaths_Term(String paths, ConditionOptionCall<TermQueryBuilder> opLambda) {

        // Due to normalization bug, UNC paths are not properly detected
        // The normalization removes all duplicate backslashes, so \\\\server becomes \server
        // This test validates that paths which should be UNC but aren't detected due to normalization
        // still pass validation (which is the current behavior, though not ideal)