expect:
        extendsString.wildcard
        superString.wildcard
        objects.wildcard
        anything.wildcard

        !extendsString.isClass()
        !superString.isClass()
        !objects.isClass()
        !anything.isClass()

        extendsString.rawClass == String
        superString.rawClass == Object
        objects.rawClass == Object
        anything.rawClass == Object

        });
    }

    private abstract class ClassFileVisitor extends EmptyFileVisitor implements ReproducibleFileVisitor {
        @Override
        public void visitFile(FileVisitDetails fileDetails) {
            if (isClass(fileDetails) && !isAnonymousClass(fileDetails)) {
                visitClassFile(fileDetails);
            }
        }

        abstract void visitClassFile(FileVisitDetails fileDetails);

// slashes are removed.
// If the path is empty, Dir returns ".".
// If the path consists entirely of slashes followed by non-slash bytes, Dir
// returns a single slash. In any other case, the returned path does not end in a
// slash.
func Dir(path string) string {
	dir, _ := Split(path)
	return Clean(dir)

			Prefix:      false,
			ExpectedMsg: "",
		},
		"dot dot,prefix": {
			Name:        "..",
			Prefix:      true,
			ExpectedMsg: "",
		},

		"slash": {
			Name:        "foo/bar",
			Prefix:      false,
			ExpectedMsg: "/",
		},
		"slash,prefix": {
			Name:        "foo/bar",
			Prefix:      true,
			ExpectedMsg: "/",
		},

		"percent": {
			Name:        "foo%bar",

			return "", errors.New("file URL encodes volume in host field: too few slashes?")
		}
		return `\\` + host + path, nil
	}

	// If host is empty, path must contain an initial slash followed by a
	// drive letter and path. Remove the slash and verify that the path is valid.
	if vol := filepath.VolumeName(path[1:]); vol == "" || strings.HasPrefix(vol, `\\`) {
		return "", errors.New("file URL missing drive letter")
	}

# .a files should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o x.a text/template
! grep 'GOROOT\\' x.a
! grep 'text\\template' x.a
! grep 'c:\\' x.a

# executables should use slash-separated paths even on windows
# This is important for reproducing native builds with cross-compiled builds.
go build -o hello.exe hello.go
! grep 'GOROOT\\' hello.exe

		h.WriteString(string(svc.Hostname))
		h.Write(Slash)
		h.WriteString(svc.Attributes.Namespace)
		h.Write(Separator)
	}
	h.Write(Separator)

	for _, vs := range r.VirtualServices {
		for _, cfg := range model.VirtualServiceDependencies(vs) {
			h.WriteString(cfg.Kind.String())
			h.Write(Slash)
			h.WriteString(cfg.Name)
			h.Write(Slash)
			h.WriteString(cfg.Namespace)
			h.Write(Separator)
		}

    }

    def "path separators are equal"() {
        def slash = '/' as char
        def backslash = '\\' as char

        expect:
        compareCharsIgnoringCase(slash, backslash) == 0
        compareCharsIgnoringCase(backslash, slash) == 0
        compareChars(slash, backslash) == 0
        compareChars(backslash, slash) == 0
        equalChars(slash, backslash, caseSensitivity)

				d.class = windows.FileIdBothDirectoryInfo
			} else if d.class == windows.FileFullDirectoryRestartInfo {
				d.class = windows.FileFullDirectoryInfo
			}
		}
		// Drain the buffer
		var islast bool
		for n != 0 && !islast {
			var nextEntryOffset uint32
			var nameslice []uint16
			entry := unsafe.Pointer(&(*d.buf)[d.bufp])
			if d.class == windows.FileIdBothDirectoryInfo {

    }

    def "throws IllegalArgumentException when filter contains forward slash [#testFilter]"() {
        when:
        select(testFilter)

        then:
        def ex = thrown(IllegalArgumentException)
        ex.message == "'$testFilter' is an invalid pattern. Patterns cannot contain forward slash."

        where:
        testFilter << ['/abc', 'a/bc', 'ab/c', 'a/b/c', 'a/bc', 'a.b/c']
    }