if (auto status = tsl::Env::Default()->GetChildren(path_, &files);
        !status.ok()) {
      return status;
    }
    if (files.size() != 1) {
      return absl::FailedPreconditionError(
          "Expecting directory to have one child.");
    }
    *dump_dir = tsl::io::JoinPath(path_, files[0]);
    return absl::OkStatus();
  }

  std::string path_;
  mlir::MLIRContext context_;

It makes projects identifiable and addressable without conflicts.

In a composite build, Gradle adds additional qualification to each project from an included build to avoid project path conflicts.
The full path to identify a project in a composite build is called a _build-tree path_.
It consists of a _build path_ of an included build and a _project path_ of the project.

				ReadOnly:  false,
			},
			{
				MountPath: "c:/mnt/path3",
				Name:      "disk",
				ReadOnly:  true,
			},
			{
				MountPath: "c:/mnt/path4",
				Name:      "disk4",
				ReadOnly:  false,
			},
			{
				MountPath: "c:/mnt/path5",
				Name:      "disk5",
				ReadOnly:  false,
			},
			{
				MountPath: `\mnt\path6`,
				Name:      "disk6",
				ReadOnly:  false,
			},
			{

To tell the Java compiler that a Jar is a module, as opposed to a traditional Java library, Gradle needs to place it on the so called _module path_.
It is an alternative to the _classpath_, which is the traditional way to tell the compiler about compiled dependencies.
Gradle will automatically put a Jar of your dependencies on the module path, instead of the classpath, if these three things are true:

* `java.modularity.inferModulePath` is *not* turned off

        '/pathA' | '/pathB' | 'false' | 'true'  | [[path: '/pathA', test: 'false'], [path: '/pathB', test: 'true' ]]
        '/pathA' | '/pathB' | 'true'  | 'false' | [[path: '/pathA', test: 'true' ], [path: '/pathB', test: 'false']]
        '/pathA' | '/pathB' | 'true'  | 'true'  | [[path: '/pathA', test: 'true' ], [path: '/pathB', test: 'true' ]]
    }

If you add or remove a project that uses the Kotlin DSL, build script compilation fails if you forget to update a dependency.

The project accessors are mapped from the _project path_.
For example, if a project path is `:commons:utils:some:lib` then the project accessor will be `projects.commons.utils.some.lib` (which is the short-hand notation for `projects.getCommons().getUtils().getSome().getLib()`).

					},
					{
						MountPath:        "/mnt/path3",
						Name:             "disk",
						ReadOnly:         true,
						MountPropagation: &propagationNone,
					},
					{
						MountPath: "/mnt/path4",
						Name:      "disk4",
						ReadOnly:  false,
					},
					{
						MountPath: "/mnt/path5",
						Name:      "disk5",
						ReadOnly:  false,
					},
				},
			},

        given:
        def path1 = new RelativePath(true, "a", "b", "d");
        def path2 = new RelativePath(true, "a", "b", "c");
        expect:
        path1.compareTo(path2) > 0
        path1.compareTo(path1) == 0
        path2.compareTo(path1) < 0
        path2.compareTo(path2) == 0
    }

    def "compareTo should compare paths with different number of segments"() {
        given:
        def path1 = new RelativePath(true, "b");

        for (; pos < maxPos; pos++) {
            if (path1.charAt(pos) != path2.charAt(pos + offset)) {
                break;
            }
            if (path1.charAt(pos) == separatorChar) {
                lastSeparator = pos;
            }
        }
        if (pos == maxPos) {
            if (path1.length() == path2.length() - offset) {
                return pos;
            }

def get_size_ratio(path_a: str, path_b: str) -> float:
  """Return the size ratio of the given paths.

  Args:
    path_a: Path of a directory or a file to be the nominator of the ratio.
    path_b: Path of a directory or a file to be the denominator of the ratio.

  Returns:
    Ratio of size of path_a / size of path_b.
  """
  size_a = get_dir_size(path_a)
  size_b = get_dir_size(path_b)