def "reports task problems in tasks from included build that run in main build"() {
        given:
        settingsFile << """
            includeBuild 'inc'
        """
        file("inc/settings.gradle") << """
            include 'sub'
        """
        file("inc/sub/build.gradle") << """
            gradle.buildFinished { }
            tasks.register('broken') {

subprojects {
    apply plugin: 'java'
}

project(':impl') {
    apply plugin: 'idea'

    dependencies {
        ${implementationConfiguration} project(':api')
    }
}
"""
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }
        def module = project.children.find { it.name == 'impl' }

    }

    private
    fun String.toPositiveLongOrNull() =
        toLongOrNull()?.takeIf { it > 0 }
}


internal
class DefaultAsyncIOScopeFactory(
    private
    val settings: AsyncIOScopeSettings = JavaSystemPropertiesAsyncIOScopeSettings(),
    executorServiceProvider: () -> ExecutorService
) : Closeable, AsyncIOScopeFactory {

    private
    val executorService = lazy(executorServiceProvider)

        project.jdkName == '1.6'
    }

    def "provides all modules"() {

        file('build.gradle').text = '''
subprojects {
    apply plugin: 'java'
}
'''
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        IdeaProject project = loadToolingModel(IdeaProject)

        then:
        project.children.size() == 3
        project.children.any { it.name == 'api' }

      </dependency>
      <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-settings</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>org.apache.maven</groupId>
        <artifactId>maven-settings-builder</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>

	"github.com/minio/minio/internal/config"
	"github.com/minio/pkg/v3/env"
)

// Callhome related keys
const (
	Enable    = "enable"
	Frequency = "frequency"
)

// DefaultKVS - default KV config for subnet settings
var DefaultKVS = config.KVS{
	config.KV{
		Key:   Enable,
		Value: "off",
	},
	config.KV{
		Key:   Frequency,
		Value: "24h",
	},
}

	"os"

	"cmd/go/internal/base"
	"cmd/internal/telemetry"
)

var CmdTelemetry = &base.Command{
	UsageLine: "go telemetry [off|local|on]",
	Short:     "manage telemetry data and settings",
	Long: `Telemetry is used to manage Go telemetry data and settings.

Telemetry can be in one of three modes: off, local, or on.

When telemetry is in local mode, counter data is written to the local file
system, but will not be uploaded to remote servers.

            failureDescriptionStartsWith "Configuration cache problems found in this build"
        }
    }

    enum ScriptTarget {
        SETTINGS,
        PROJECT;

        String getFileName() {
            this == SETTINGS ? 'settings.gradle' : 'build.gradle'
        }

        String getTargetType() {
            toString().capitalize()
        }

        @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.profile;

import org.gradle.StartParameter;
import org.gradle.api.initialization.Settings;
import org.gradle.internal.buildevents.BuildStartedTime;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.util.internal.CollectionUtils;

    TestFile containerDir
    TestFile targetDir
    TestFile subprojectDir

    abstract String subprojectName()

    def setup() {
        file("settings.gradle") << """
            // This is here to prevent Gradle searching up to find the build's settings.gradle
        """
        initializeIntoTestDir()
    }

    void initializeIntoTestDir() {
        containerDir = testDirectory