import org.hamcrest.Matchers.equalTo
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test


class ConfigurationCacheProblemsSummaryTest {

    @Test
    fun `keeps track of unique problems upto maxCollectedProblems`() {
        val subject = ConfigurationCacheProblemsSummary(maxCollectedProblems = 2)
        assertTrue(
            "1st problem",

	if IsToolchainProgram(progPath) {
		progVers = goVers
	} else {
		progVers = info.Main.Version
		if strings.Contains(progVers, "devel") || module.IsPseudoVersion(progVers) {
			// We don't want to track pseudo versions, but may want to track prereleases.
			progVers = "devel"
		}
	}

	return goVers, progPath, progVers

     * if the property has no value, or if it does not contain a mapping for the key.
     *
     * <p>The returned provider will track the value of this property and query its value when it is queried.</p>
     *
     * <p>This method is equivalent to
     *
     * <pre><code>
     *     map(m -&gt; m.get(key))
     * </code></pre>
     *

import org.gradle.util.Path;

import java.util.ArrayList;
import java.util.List;

/**
 * Used to track which configurations in other projects a given resolution depends on. This data is
 * used to mark those configurations as observed so that they cannot be mutated later.
 *
 * <strong>Do not build on-top of this visitor. If you want to track cross-project dependencies,

// license that can be found in the LICENSE file.

// Regression test for an issue found in development.
//
// The issue is that EvUserTaskEnd events don't carry the
// task type with them, so the parser needs to track that
// information. But if the parser just tracks the string ID
// and not the string itself, that string ID may not be valid
// for use in future generations.

package main

import (
	"internal/trace"

 */

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.kotlin-dsl-sam-with-receiver")
}

description = "Base utilities and services to report and track configuration problems"

dependencies {
    api(projects.baseServices)
    api(projects.stdlibJavaExtensions)
    api(projects.logging)
    api(projects.problemsApi)

    api(libs.kotlinStdlib)

            }
            tasks.register("myTask", MyTask) {
                // use an undeclared input so we can test --refresh-dependencies
                // URL.text is not tracked for now; we'll have to change it once we start to track it
                message.set(file("message").toPath().toUri().toURL().text)
            }
        """
        file("message") << "foo"

        when:
        configurationCacheRun "myTask"

        then:

/*/docs/src/samples/**/build
/*/docs/src/snippets/**/build
/*/internal-android-performance-testing/build-android-libs
test-splits/
/gradle/verification-keyring.gpg

# IDEA
# ----
!/.idea
/.idea/*
# Needed to track entry points and nullability annotations (see https://youtrack.jetbrains.com/issue/IDEA-354114 and https://youtrack.jetbrains.com/issue/IDEA-354115)
!/.idea/misc.xml
!/.idea/codeStyles
!/.idea/inspectionProfiles
!/.idea/icon.png

        builder.firstLevelDependency(dependency.getNodeId());
        //we don't serialise the module dependencies at this stage so we need to keep track
        //of the mapping module dependency <-> resolved dependency
        modulesMap.put(dependency.getNodeId(), moduleDependency);
    }

    @Override
    public void done(DependencyGraphNode root) {

// functions and Dirac delta functions (which are treated as
// degenerate uniform distributions).
type mud struct {
	sorted, unsorted []edge

	// trackMass is the inverse cumulative sum to track as the
	// distribution is updated.
	trackMass float64
	// trackBucket is the bucket in which trackMass falls. If the
	// total mass of the distribution is < trackMass, this is
	// len(hist).
	trackBucket int