import java.io.File


class TestFilesCleanupRootPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        require(project.rootProject == project) { "This plugin should be applied to root project!" }
        val globalExtension = project.extensions.create<TestFilesCleanupBuildServiceRootExtension>("testFilesCleanupRoot")
        project.gradle.taskGraph.whenReady {

    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the

 */
@GwtCompatible
final class Platform {

  /** Format the template with args, only supports the placeholder {@code %s}. */
  static String format(String template, Object... args) {
    return String.format(Locale.ROOT, template, args);
  }

  /** See {@link ListListIteratorTester} */
  static int listListIteratorTesterNumIterations() {
    return 4;
  }

  /** See {@link CollectionIteratorTester} */

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package disk

import "runtime"

// IsRootDisk returns if diskPath belongs to root-disk, i.e the disk mounted at "/"
func IsRootDisk(diskPath string, rootDisk string) (bool, error) {
	if runtime.GOOS == "windows" {
		// On windows this function is not implemented.
		return false, nil
	}

import org.apache.maven.api.services.ModelBuilder;
import org.apache.maven.api.services.model.LifecycleBindingsInjector;
import org.apache.maven.bridge.MavenRepositorySystem;
import org.apache.maven.model.root.RootLocator;
import org.eclipse.aether.RepositorySystem;

@Named("classpath")
@Singleton
@Deprecated
public class TestProjectBuilder extends DefaultProjectBuilder {
    @Inject
    public TestProjectBuilder(

    assert response.json() == {
        "openapi": "3.1.0",
        "info": {"title": "FastAPI", "version": "0.1.0"},
        "paths": {
            "/": {
                "get": {
                    "summary": "Read Root",
                    "operationId": "read_root__get",
                    "responses": {
                        "200": {
                            "description": "Successful Response",

 *
 * @since 3.1.0
 */
public interface Slf4jConfiguration {
    /**
     * Level
     */
    enum Level {
        DEBUG,
        INFO,
        ERROR
    }

    /**
     * Set root logging level.
     *
     * @param level the level
     */
    void setRootLoggerLevel(Level level);

    /**
     * Activate logging implementation configuration (if necessary).
     */
    void activate();

    }

    /**
     * @return the source file and it's source root
     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =
        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: error("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private

  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="supplementalDataModels" xsd.compositor="sequence">
      <name>SupplementalDataModel</name>
      <version>1.0.0</version>
      <description>Root element of the supplemental-models.xml file.</description>
      <fields>
        <field xml.listStyle="flat">
          <name>supplement</name>
          <version>1.0.0</version>

        Joiner.on(":")
            .join(
                "relative/path/to/some.jar",
                "/absolute/path/to/some.jar",
                "relative/path/to/class/root",
                "/absolute/path/to/class/root"));
    try {
      ImmutableList<URL> urls = ClassPath.parseJavaClassPath();

      assertThat(urls.get(0).getProtocol()).isEqualTo("file");