QUICK_FEEDBACK_LINUX_ONLY(
        "Quick Feedback - Linux Only",
        "Run checks and functional tests (embedded executer, Linux)",
        "QuickFeedbackLinuxOnly",
    ),
    QUICK_FEEDBACK("Quick Feedback", "Run checks and functional tests (embedded executer, Windows)", "QuickFeedback"),
    PULL_REQUEST_FEEDBACK("Pull Request Feedback", "Run various functional tests", "PullRequestFeedback"),
    READY_FOR_NIGHTLY(
        "Ready for Nightly",

import okhttp3.internal.http.RealInterceptorChain
import okhttp3.internal.http.RecordingProxySelector
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.internal.TlsUtil.localhost

/**
 * OkHttp is usually tested with functional tests: these use public APIs to confirm behavior against
 * MockWebServer. In cases where logic is particularly tricky, we use unit tests. This class makes
 * it easy to get sample values to use in such tests.
 *

   *
   * <p>This differs from {@code Long.bitCount(x) == 1}, because {@code
   * Long.bitCount(Long.MIN_VALUE) == 1}, but {@link Long#MIN_VALUE} is not a power of two.
   */
  // Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
  @SuppressWarnings("ShortCircuitBoolean")
  public static boolean isPowerOfTwo(long x) {
    return x > 0 & (x & (x - 1)) == 0;
  }

  /**

            if (topLevelFunctionalTests.size + functionalTestProjects.size > 1) {
                buildType(
                    PartialTrigger(
                        "All Functional Tests for ${stage.stageName.stageName}",
                        "Stage_${stage.stageName.id}_FuncTests",
                        model,
                        functionalTests,
                    ),
                )

            }

        assertFalse(projectFoldersWithFunctionalTests.isEmpty())
        projectFoldersWithFunctionalTests.forEach {
            assertTrue(projectDirsWithFunctionalTests.contains(it), "Contains functional tests: $it")
        }
    }

    @Test
    fun allSubprojectsDefineTheirCrossVersionTestPropertyCorrectly() {
        val projectDirsWithCrossVersionTests =
            model.subprojects.subprojects

    "path": "platforms/core-configuration/flow-services",
    "unitTests": false,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "functional",
    "path": "platforms/core-runtime/functional",
    "unitTests": true,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "gradle-cli",
    "path": "platforms/core-runtime/gradle-cli",

    CacheBuilder<Object, Object> builder = CacheBuilder.from(parse("maximumSize=9000"));
    builder.build(CacheLoader.from(Suppliers.ofInstance(null)));
  }

  public void testDisableCaching() {
    // Functional test: assert that CacheBuilderSpec.disableCaching()
    // disables caching.  It's irrelevant how it does so.
    CacheBuilder<Object, Object> builder = CacheBuilder.from(CacheBuilderSpec.disableCaching());

            <option value="$PROJECT_DIR$/platforms/core-runtime/file-temp" />
            <option value="$PROJECT_DIR$/platforms/core-runtime/files" />
            <option value="$PROJECT_DIR$/platforms/core-runtime/functional" />
            <option value="$PROJECT_DIR$/platforms/core-runtime/gradle-cli" />
            <option value="$PROJECT_DIR$/platforms/core-runtime/gradle-cli-main" />

import java.util.jar.Manifest;
import java.util.logging.Logger;
import java.util.zip.ZipEntry;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;
import org.junit.Test;

/** Functional tests of {@link ClassPath}. */
@NullUnmarked
public class ClassPathTest extends TestCase {
  private static final Logger log = Logger.getLogger(ClassPathTest.class.getName());
  private static final File FILE = new File(".");

### `tf.keras`:

*   Improvements from the Functional API refactoring:
    *   Functional model construction does not need to maintain a global
        workspace graph, removing memory leaks especially when building many
        models or very large models.
    *   Functional model construction should be ~8-10% faster on average.
    *   Functional models can now contain non-symbolic values in their call