}
			if len(dump.DynamicWarmingSecrets) > 0 {
				t.Fatalf("found warming secrets: %v", output)
			}
			if len(dump.DynamicActiveSecrets) != 2 {
				// If the config for the SDS does not align in all locations, we may get duplicates.
				// This check ensures we do not. If this is failing, check to ensure the bootstrap config matches
				// the XDS response.

        failure.assertHasCause("Could not resolve all dependencies for configuration ':buildC:buildInputs'.")
        failure.assertHasCause("""Could not find org.test:test:1.2.
Searched in the following locations:
  - ${m.pom.file.displayUri}
Required by:
    project :buildC""")
        failure.assertHasResolutions(REPOSITORY_HINT,
            STACKTRACE_MESSAGE,
            INFO_DEBUG,
            SCAN,

NOTE: For Linux users, Gradle will discover the tool chain using the system PATH.

[[sec:custom_swift_source_set_paths]]
=== Customizing file and directory locations

Imagine you are migrating a library project that follows the Swift Package Manager layout (e.g. `Sources/__ModuleName___` directory for the production code).

        when:
        result.explain(visitor)

        then:
        visitor.toString() == TextUtil.toPlatformLineSeparators("""Could not locate a Visual Studio installation. None of the following locations contain a valid installation:
  - ${dir1}
  - ${dir2}""")
    }

    def "locates visual studio 2017 installation based on executables in path"() {
        def vsDir = vs2017Dir("vs")

        given:

	fn.ABI = wrapperABI
	typecheck.DeclFunc(fn)

	fn.SetABIWrapper(true)
	fn.SetDupok(true)

	// ABI0-to-ABIInternal wrappers will be mainly loading params from
	// stack into registers (and/or storing stack locations back to
	// registers after the wrapped call); in most cases they won't
	// need to allocate stack space, so it should be OK to mark them
	// as NOSPLIT in these cases. In addition, my assumption is that

		return false, nil
	}

	// if the new cluster roles to aggregate do not yet exist, then we need to copy the old roles if they don't exist
	// in new locations
	if err := primeAggregatedClusterRoles(p.ClusterRolesToAggregate, client.RbacV1()); err != nil {
		utilruntime.HandleError(fmt.Errorf("unable to prime aggregated clusterroles: %v", err))
		return false, nil
	}

|`@Destroys`
|Property is one or more files or directories (coming from other tasks) that the task destroys (deletes/removes)footnote:2[This notation is used to specify locations/files that a task will always delete, and these locations/files typically belong to other tasks. This annotation is useful for tasks that clean up after other tasks such as `clean`.]

|`@LocalState`
|Property is a local state for a task

import jcifs.SmbConstants;
import jcifs.SmbResourceLocator;
import jcifs.internal.util.StringUtil;
import jcifs.netbios.NbtAddress;
import jcifs.netbios.UniAddress;


/**
 * 
 * 
 * This mainly tracks two locations:
 * - canonical URL path: path component of the URL: this is used to reconstruct URLs to resources and is not adjusted by

==== Linux

To build on Linux, install a compatible version of GCC or Clang.
The {cpp} plugins will discover GCC or Clang using the system PATH.

[[sec:custom_cpp_source_set_paths]]
=== Customizing file and directory locations

Imagine you have a legacy library project that uses an _src_ directory for the production code and private headers and _include_ directory for exported headers.

When developing plugins, it's a good idea to be flexible when accepting input configuration for file locations.

It is recommended to use Gradle's <<custom_gradle_types.adoc#managed_properties,managed properties>> and `project.layout` to select file or directory locations.
This will enable lazy configuration so that the actual location will only be resolved when the file is needed and can be reconfigured at any time during build configuration.