this.children = ImmutableList.copyOf(children); // also ensures it's serializable
        return this;
    }

    public String getPath() {
        return projectIdentifier.getProjectPath();
    }

    public DefaultProjectIdentifier getProjectIdentifier() {
        return projectIdentifier;
    }

    @Override

    }

    /**
     * @throws Exception
     */
    @Test
    public void testReadUTF8() throws Exception {
        assertThat(FileUtil.readUTF8(getPath("hoge_utf8.txt")), is("あ"));
    }

    private String getPath(final String fileName) {
        return getClass().getName().replace('.', '/').replaceFirst(getClass().getSimpleName(), fileName);
    }

        /**
         * @see LoadProjectsBuildOperationType.Result.Project#getName()
         */
        String getName();

        /**
         * @see LoadProjectsBuildOperationType.Result.Project#getPath()
         */
        String getPath();

        /**
         * @see LoadProjectsBuildOperationType.Result.Project#getIdentityPath()
         */
        String getIdentityPath();

        /**

def _copy_assets(src_path: str, dst_path: str) -> None:
  """Copies the assets directory of the saved model.

  Clones the contents of the assets/ directory from the source saved model
  directory to the destination saved model directory. Nothing will be copied if
  there are no assets directory in the source directory.

  Args:
    src_path: Source saved model directory.

        Task task = createTask(project, TEST_TASK_NAME)

        then:
        Project.PATH_SEPARATOR + TEST_TASK_NAME ==  task.getPath()

        when:
        task = createTask(childProject, TEST_TASK_NAME)

        then:
        Project.PATH_SEPARATOR + "child" + Project.PATH_SEPARATOR + TEST_TASK_NAME ==  task.getPath()

        when:
        task = createTask(childchildProject, TEST_TASK_NAME)

        then:

import org.gradle.api.Task;
import org.gradle.api.internal.plugins.DslObject;
import org.gradle.util.Path;

import javax.annotation.Nullable;

public interface TaskDetails {
    Path getPath();

    @Nullable
    String getDescription();

    String getTypeName();

    static TaskDetails of(Path path, Task task) {

)

// downwardAPIPlugin implements the VolumePlugin interface.
type downwardAPIPlugin struct {
	host volume.VolumeHost
}

var _ volume.VolumePlugin = &downwardAPIPlugin{}

func getPath(uid types.UID, volName string, host volume.VolumeHost) string {
	return host.GetPodVolumeDir(uid, utilstrings.EscapeQualifiedName(downwardAPIPluginName), volName)
}

func wrappedVolumeSpec() volume.Spec {
	return volume.Spec{

        this.project = project;
    }

    public void add(Runnable configuration) {
        if (fired) {
            String message = "Cannot add deferred configuration for project " + project.getPath();
            if (firedSentinel == null) {
                throw new IllegalStateException(message);
            } else {
                throw new IllegalStateException(message, firedSentinel);
            }

	sources []v1.VolumeProjection
	podUID  types.UID
	plugin  *projectedPlugin
	volume.MetricsProvider
}

var _ volume.Volume = &projectedVolume{}

func (sv *projectedVolume) GetPath() string {
	return getPath(sv.podUID, sv.volName, sv.plugin.host)
}

type projectedVolumeMounter struct {
	*projectedVolume

	source v1.ProjectedVolumeSource
	pod    *v1.Pod
	opts   *volume.VolumeOptions
}

                ",proximity=" + proximity + ",ttl=" + ttl +
                ",pathOffset=" + pathOffset + ",altPathOffset=" + altPathOffset +
                ",nodeOffset=" + nodeOffset + ",path=" + path + ",altPath=" + altPath +
                ",node=" + node + "]" );
        }
    }

    int pathConsumed;
    int numReferrals;
    int flags;
    Referral[] referrals;

    Trans2GetDfsReferralResponse() {