/**
     * Returns the encoded type of the access rule. The meaning of the values:
     * <ul>
     *     <li>0: the rule defines accessible paths</li>
     *     <li>1: the rule defines inaccessible paths</li>
     *     <li>2: the rule defines discouraged paths</li>
     * </ul>
     *
     * @return The type of this access rule.
     */
    int getKind();

    /**

	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
)

// EmptyFields represents a set with no paths
// It looks like metav1.Fields{Raw: []byte("{}")}
var EmptyFields = func() metav1.FieldsV1 {
	f, err := SetToFields(*fieldpath.NewSet())
	if err != nil {
		panic("should never happen")
	}
	return f
}()

// FieldsToSet creates a set paths from an input trie of fields
func FieldsToSet(f metav1.FieldsV1) (s fieldpath.Set, err error) {

    /**
     * Returns the file paths of all dependencies, regardless on which tool option those paths should be placed.
     * The returned list may contain a mix of Java class-path, Java module-path, and other types of path elements.
     * This collection has the same content than {@code getDependencies.values()} except that it does not contain
     * null elements.
     *
     * @return the paths of all dependencies
     */
    @Nonnull

grep 'rsc.io/sampler v1.2.0' go.mod
cd outside
go list -m all
stdout 'rsc.io/sampler v1.3.0'
cd ..

# The same module can't be used as two different paths.
cd multiple-paths
! go mod tidy
stderr 'rsc.io/quote/v3@v3.0.0 used for two different module paths \(not-rsc.io/quote/v3 and rsc.io/quote/v3\)'

-- go.mod --
module example.com/tidy

require rsc.io/quote/v3 v3.0.0
replace rsc.io/quote/v3 => ./not-rsc.io/quote/v3

// but additional checking functions, most notably [Check], verify that
// a particular path, version pair is valid.
//
// # Escaped Paths
//
// Module paths appear as substrings of file system paths
// (in the download cache) and of web server URLs in the proxy protocol.
// In general we cannot rely on file systems to be case-sensitive,

			Name:      "test",
		},
		Spec: net.IngressSpec{
			Rules: []net.IngressRule{
				{
					Host: "my.host.com",
					IngressRuleValue: net.IngressRuleValue{
						HTTP: &net.HTTPIngressRuleValue{
							Paths: []net.HTTPIngressPath{
								{
									Path: "/test",
									Backend: net.IngressBackend{
										Service: &net.IngressServiceBackend{
											Name: "foo",
											Port: net.ServiceBackendPort{

 * limitations under the License.
 */

package org.gradle.api.file

import spock.lang.Specification

class RelativePathSpockTest extends Specification {
    def "compareTo should compare paths with same number of segments"() {
        given:
        def path1 = new RelativePath(true, "a");
        def path2 = new RelativePath(true, "b");
        expect:
        path1.compareTo(path2) < 0

public interface TaskDestroyables {
    /**
     * Registers files or directories that this task destroys.
     *
     * @param paths The files or directories that will be destroyed. The given paths are evaluated as per {@link org.gradle.api.Project#files(Object...)}.
     *
     * @since 4.3
     */
    void register(Object... paths);

import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.regex.Pattern;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class ComparableVersionIT {

    @Test
    void test() throws Exception {
        Files.walkFileTree(Paths.get("target"), new SimpleFileVisitor<Path>() {

			OneOf: value,
		},
	}

	paths := make([]*matcher.MetadataMatcher_PathSegment, 0, len(keys))
	for _, k := range keys {
		paths = append(paths, &matcher.MetadataMatcher_PathSegment{
			Segment: &matcher.MetadataMatcher_PathSegment_Key{
				Key: k,
			},
		})
	}

	out := &matcher.MetadataMatcher{
		Filter: filter,
		Path:   paths,
	}
	if useExtendedJwt {
		out.Value = &matcher.ValueMatcher{