import org.gradle.internal.UncheckedException;

import java.io.File;

public class RelativePathUtil {
    /**
     * Returns a relative path from 'from' to 'to'
     *
     * @param from where to calculate from
     * @param to where to calculate to
     * @return The relative path
     */
    public static String relativePath(File from, File to) {
        try {

	// VolumeStatCalDuration tracks the duration in seconds to calculate volume stats.
	// this metric is mainly for comparison between fsquota monitoring and `du` for disk usage.
	VolumeStatCalDuration = metrics.NewHistogramVec(
		&metrics.HistogramOpts{
			Subsystem:      kubeletSubsystem,
			Name:           "volume_metric_collection_duration_seconds",
			Help:           "Duration in seconds to calculate volume stats",
			Buckets:        metrics.DefBuckets,

    /**
     * Creates a {@link FileCollection} that represents some task input that is calculated from one or more other file collections.
     *
     * <p>The implementation applies caching to the result, so that the matching files are calculated during file snapshotting and the result cached in memory for when it is queried again, either during task action execution or in order to calculate some other task input value.
     *

        treeTaskGraphOps[0].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[0].parentId == buildSrcOps[0].id
        treeTaskGraphOps[1].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[1].parentId == root.id

        def taskGraphOps = ops.all(CalculateTaskGraphBuildOperationType)
        taskGraphOps.size() == 2
        taskGraphOps[0].displayName == "Calculate task graph (:buildSrc)"

    }

    @Test
    void calculateByte() throws IOException {
        Map<ChecksumAlgorithmService.ChecksumAlgorithm, String> checksums = service.calculate(
                "test".getBytes(StandardCharsets.UTF_8), service.select(Arrays.asList("SHA-1", "MD5")));
        assertNotNull(checksums);
        assertEquals(2, checksums.size());

        then:
        executed ":jar", ":lib", ":child:jar", ":child:lib", ":useCompileConfiguration"

        where:
        fluid << [true, false]
    }

    def "reports failure to calculate build dependencies when artifact build dependencies cannot be queried - fluid: #fluid"() {
        makeFluid(fluid)
        buildFile << """
            dependencies {
                compile project(':child')

			inputBytes += len(k) + len(v)
		}

		// Calculate node name
		nodeName := r.Host
		if globalIsDistErasure {
			nodeName = globalLocalNodeName
		}
		if host, port, err := net.SplitHostPort(nodeName); err == nil {
			if port == "443" || port == "80" {
				nodeName = host
			}
		}

		// Calculate reqPath
		reqPath := r.URL.RawPath
		if reqPath == "" {
			reqPath = r.URL.Path

        e.message == 'Value for <thing> has not been calculated yet.'

        when:
        container.getValue().get()

        then:
        def e2 = thrown(IllegalStateException)
        e2.message == 'Value for <thing> has not been calculated yet.'
    }

    def "at most one thread calculates the value"() {
        // Don't use a spock mock as these apply their own synchronization

	line2InColor := fmt.Sprintf(msgLine2Fmt, color.CyanBold(updateString))

	// calculate the rectangular box size.
	maxContentWidth := max(line1Length, line2Length)

	// termWidth is set to a default one to use when we are
	// not able to calculate terminal width via OS syscalls
	termWidth := 25
	if width, err := pb.GetTerminalWidth(); err == nil {
		termWidth = width
	}

    }

    public RelativePathUtil() {
        logDeprecation();
    }

    /**
     * Returns a relative path from 'from' to 'to'
     *
     * @param from where to calculate from
     * @param to where to calculate to
     * @return The relative path
     */
    public static String relativePath(File from, File to) {
        logDeprecation();
        try {