Set<E> inEdgesV = inEdges(nodeV);
    return nodePairInvalidatableSet(
        outEdgesU.size() <= inEdgesV.size()
            ? unmodifiableSet(Sets.filter(outEdgesU, connectedPredicate(nodeU, nodeV)))
            : unmodifiableSet(Sets.filter(inEdgesV, connectedPredicate(nodeV, nodeU))),
        nodeU,
        nodeV);
  }

  @Override
  public Set<E> edgesConnecting(EndpointPair<N> endpoints) {

        final String name = fessConfig.getQueryBrowserLangParameterName();
        if (StringUtil.isNotBlank(name)) {
            try {
                return requestManager.getParameter(name).filter(StringUtil::isNotBlank).map(LocaleUtils::toLocale);
            } catch (final Exception e) {
                logger.debug("Failed to parse locale: name={}", name, e);
            }
        }

        }
    }

    private
    fun Task.findTraceJson(): List<File> {
        if (this !is Test) {
            return emptyList()
        }
        // e.g. build/test-results/embeddedIntegTest/trace.json
        return listOf(project.layout.buildDirectory.file("test-results/$name/trace.json").get().asFile)
    }

    private
    fun Task.genericHtmlReports() = when (this) {

          "build-init-specs",
          "build-state",
          "composite-builds",
          "concurrent",
          "daemon-services",
          "declarative-dsl-internal-utils",
          "file-temp",
          "files",
          "functional",
          "internal-testing",
          "stdlib-kotlin-extensions"
        ],
        "parallelizationMethod": {
          "numberOfBatches": 1,

			t.Errorf("test %d, got nil-error, want non-nil error", i)
		}
	}
}

func Benchmark(b *testing.B) {
	type file struct {
		hdr  *Header
		body []byte
	}

	vectors := []struct {
		label string
		files []file
	}{{
		"USTAR",
		[]file{{
			&Header{Name: "bar", Mode: 0640, Size: int64(3)},
			[]byte("foo"),
		}, {
			&Header{Name: "world", Mode: 0640, Size: int64(5)},

        });

        userBhv.selectCursor(cb -> cb.query().setRoles_Equal(role.getId()), entity -> {
            entity.setRoles(
                    stream(entity.getRoles()).get(stream -> stream.filter(s -> !s.equals(role.getId())).toArray(n -> new String[n])));
            userBhv.insertOrUpdate(entity);
        });
    }

    /**
     * Sets up the list condition for the role query.

  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀

             Searching for package file structure from directories
             with <font color="#3465A4">__init__.py</font> files
             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>

     * This method must be implemented by concrete searcher classes.
     *
     * @param query the search query string
     * @param params the search request parameters including pagination, filters, etc.
     * @param userBean the optional user bean for access control and personalization
     * @return the search result containing matched documents and metadata
     */

import org.dbflute.mail.send.embedded.receptionist.SMailConventionReceptionist;
import org.dbflute.mail.send.supplement.async.SMailAsyncStrategy;
import org.dbflute.mail.send.supplement.filter.SMailSubjectFilter;
import org.dbflute.mail.send.supplement.label.SMailLabelStrategy;
import org.dbflute.optional.OptionalThing;
import org.dbflute.util.DfStringUtil;
import org.lastaflute.core.magic.async.AsyncManager;

    public static List<String> getAvailableProviders() {
        List<RdmaProvider> allProviders = Arrays.asList(new DisniRdmaProvider(), new TcpRdmaProvider());

        return allProviders.stream()
                .filter(RdmaProvider::isAvailable)
                .map(RdmaProvider::getProviderName)
                .collect(java.util.stream.Collectors.toList());
    }