# 'go mod edit' opportunistically locks the side-lock file in the module cache,
# for compatibility with older versions of the 'go' command.
# It does not otherwise depend on the module cache, so it should not
# fail if the module cache directory cannot be created.

[root] skip

mkdir $WORK/readonly
chmod 0555 $WORK/readonly
env GOPATH=$WORK/readonly/nonexist

go mod edit -go=1.17

-- go.mod --

   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Function} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Function} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override

        DependencyHandler dependencies = project.getDependencies();

        // Test fixtures depend on the project.
        feature.getApiConfiguration().getDependencies().add(dependencies.create(project));

        // The tests depend on the test fixtures.
        SourceSet testSourceSet = JavaPluginHelper.getDefaultTestSuite(project).getSources();

import (
	"io"
	"sync"
)

var (
	closedChanOnce sync.Once
	closedChan     chan struct{}
)

// MaybeReadByte reads a single byte from r with ~50% probability. This is used
// to ensure that callers do not depend on non-guaranteed behaviour, e.g.
// assuming that rsa.GenerateKey is deterministic w.r.t. a given random stream.
//
// This does not affect tests that pass a stream of fixed bytes as the random
// source (e.g. a zeroReader).

import java.lang.reflect.Method;
import java.util.List;

/**
 * A mapper that maps a {@link Throwable} thrown during test execution into a {@link TestFailure}.
 * <p>
 * Implementors of this class should not depend on classes outside the standard library, as there is no guarantee that they will be on the test VM's classpath.
 * Instead, they should rely completely on reflection.
 */
@NonNullApi
public abstract class TestFailureMapper {

 *
 * @since 4.6
 */
public interface InjectedPluginDependencies {
    /**
     * Add a dependency on the plugin with the given id.
     *
     * @param id the id of the plugin to depend on
     *
     * @return a mutable injected plugin dependency that can be used to further refine the dependency
     */
    InjectedPluginDependency id(String id);

Every Gradle build comprises at least one _build script_.

In the build file, two types of dependencies can be added:

1. The libraries and/or plugins on which Gradle and the build script depend.
2. The libraries on which the project sources (i.e., source code) depend.

[[sec:build_script]]
== Build scripts

The build script is either a `build.gradle` file written in Groovy or a `build.gradle.kts` file in Kotlin.

      # it, and print that list for debugging. Not really clear if this is
      # helpful since the only examples I've seen are enormous.
      bazel query "rdeps(kind(py_test, $(cat $BATS_TEST_TMPDIR/deps)), $dep, 1)"
    done < $BATS_TEST_TMPDIR/missing_deps
    exit 1
  fi
}

# The Python package is not allowed to depend on any CUDA packages.

import org.gradle.internal.hash.HashCode;

/**
 * The build scoped compile caches.
 *
 * NOTE: This class cannot be renamed because it used to leak onto the public API
 * and some community plugins still depend on it in their byte code.
 */
public interface GeneralCompileCaches {
    Cache<HashCode, ClassSetAnalysisData> getClassSetAnalysisCache();
    Cache<HashCode, ClassAnalysis> getClassAnalysisCache();

limitations under the License.
*/

// Package genericclioptions contains flags which can be added to your command, bound, completed, and produce
// useful helper functions.  Nothing in this package can depend on kube/kube