functionalTestsPass.filter { it.testCoverage.isCrossVersionTest }
        if (stage.stageName !in listOf(StageName.QUICK_FEEDBACK_LINUX_ONLY, StageName.QUICK_FEEDBACK)) {
            if (topLevelFunctionalTests.size + functionalTestProjects.size > 1) {
                buildType(
                    PartialTrigger(
                        "All Functional Tests for ${stage.stageName.stageName}",

        final Map<String, String> headerMap = new HashMap<>();
        provider.adjustActionResponseHeaders("text/plain", (k, v) -> headerMap.put(k, v));

        assertEquals(0, headerMap.size());
    }

    @Test
    public void test_write_defaultHeadersOnly() throws Exception {
        final FessConfig fessConfig = createFessConfigWithResponseHeaders("*=X-Def:def\n*=X-Def2:def2");

        ensureProjectNotSeen(projectPath)

        projectsToEnableNullaway.add(projectPath)
    }

    private val seenProjectsCount: Int
        get() = projectsWithNullAwayEnabled.size + projectsWithUncheckedDeps.size + projectsToEnableNullaway.size

    override fun close() {
        require(seenProjectsCount > 0) {
            "NullawayStatusService was created but no status tasks have run"
        }

        printResult {

    compressing outbound web socket messages. Configure this with 0L to always compress outbound
    messages and `Long.MAX_VALUE` to never compress outbound messages. The default is 1024L which
    compresses messages of size 1 KiB and larger. (Inbound messages are compressed or not based on
    the web socket server's configuration.)
 *  New: Defer constructing `Inflater` and `Deflater` instances until they are needed. This saves

            }
            response = r;

            executeCallbacks = new ArrayList<>(doneCallbacks.size());
            Consumer<RESPONSE> callback;
            while ((callback = doneCallbacks.poll()) != null) {
                executeCallbacks.add(callback);
            }
        }
        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));

        log.debug("Discovered {} local network interfaces", localInterfaces.size());
    }

    private boolean canEnableMultiChannel() {
        return localInterfaces.size() > 0 && remoteInterfaces.size() > 0 && (localInterfaces.size() > 1 || remoteInterfaces.size() > 1);
    }

    private void establishAdditionalChannels() {
        int currentChannels = channels.size();

        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

        for (Dependency dependency : dependencies) {
            normalized.put(dependency.getManagementKey(), dependency);
        }

        if (dependencies.size() != normalized.size()) {
            model.setDependencies(new ArrayList<>(normalized.values()));
        }
    }

    /**

* Bump GCI version to latest m55 version in GCE for K8s 1.4 ([#36302](https://github.com/kubernetes/kubernetes/pull/36302), [@mtaufen](https://github.com/mtaufen))
* Add a check for file size if the reading content returns empty ([#33976](https://github.com/kubernetes/kubernetes/pull/33976), [@jingxu97](https://github.com/jingxu97))

    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {
      stack.removeAt(stack.size - 1)
      path.removeAt(path.size - 1)
    }

    val sink = sink()

    // Write the tagClass, tag, and constructed bit. This takes 1 byte if tag is less than 31.
    if (tag < 31) {

        final Set<String> set = new HashSet<String>();
        traverser.forEach((ClassHandler) (packageName, shortClassName) -> set.add(ClassUtil.concatName(packageName, shortClassName)));
        assertThat(set.size() > 0, is(true));
        assertThat(set.contains(DummyTest.class.getName()), is(true));
        assertThat(set.contains(TraverserUtilTest.class.getName()), is(true));