// Version test
		{
			name:   "version as root want success",
			method: http.MethodGet,
			path:   kmsVersionPath,
			asRoot: true,

			wantStatusCode: http.StatusOK,
			wantResp:       []string{"version"},
		},
		{
			name:   "version as user with no policy want forbidden",
			method: http.MethodGet,
			path:   kmsVersionPath,
			asRoot: false,

			wantStatusCode: http.StatusForbidden,

		gorootPath = runtime.GOROOT()
		if gorootPath != "" {
			return
		}

		// runtime.GOROOT is empty — perhaps go_android_exec was built with
		// -trimpath and GOROOT is unset. Try 'go env GOROOT' as a fallback,
		// assuming that the 'go' command in $PATH is the correct one.

		cmd := exec.Command("go", "env", "GOROOT")
		cmd.Stderr = os.Stderr
		out, err := cmd.Output()

     * meaning that the {@link #getRootDirectory()} and {@link #getBasedir()}
     * points to the same directory, and that either {@link Model#isRoot()}
     * is {@code true} or that {@code basedir} contains a {@code .mvn} child
     * directory.
     *
     * @return {@code true} if the project is the root project
     * @see Model#isRoot()
     */
    boolean isRootProject();

        assertFalse(base.overlaps(other));
    }

    @Test
    @DisplayName("isRoot and isRootOrShare reflect path state")
    void testIsRootAndShare() {
        assertTrue(locator("smb://server/").isRoot());
        assertFalse(locator("smb://server/share/").isRoot());
        assertTrue(locator("smb://server/").isRootOrShare());
        assertTrue(locator("smb://server/share/").isRootOrShare());

	importDir   map[string]string            // canonical import path -> dir

}

func NewWalker(context *build.Context, root string) *Walker {
	w := &Walker{
		context:  context,
		root:     root,
		features: map[string]bool{},
		imported: map[string]*apiPackage{"unsafe": &apiPackage{Package: types.Unsafe}},
	}
	w.loadImports()
	return w
}

pkg os, func OpenRoot(string) (*Root, error) #67002
pkg os, method (*Root) Close() error #67002
pkg os, method (*Root) Create(string) (*File, error) #67002
pkg os, method (*Root) FS() fs.FS #67002
pkg os, method (*Root) Lstat(string) (fs.FileInfo, error) #67002
pkg os, method (*Root) Mkdir(string, fs.FileMode) error #67002
pkg os, method (*Root) Name() string #67002
pkg os, method (*Root) Open(string) (*File, error) #67002

            }
        }
        return null;
    }

    static String[] list(final SmbFile root, final String wildcard, final int searchAttributes, final SmbFilenameFilter fnf,
            final SmbFileFilter ff) throws SmbException {
        try (CloseableIterator<SmbResource> it = doEnum(root, wildcard, searchAttributes, fnf == null ? null : (parent, name) -> {
            if (!(parent instanceof SmbFile)) {

}

// autoGenerateRootCredentials generates root credentials deterministically if
// a KMS is configured, no manual credentials have been specified and if root
// access is disabled.
func autoGenerateRootCredentials() auth.Credentials {
	if GlobalKMS == nil {
		return globalActiveCred
	}

	aKey, err := GlobalKMS.MAC(GlobalContext, &kms.MACRequest{Message: []byte("root access key")})

    boolean hasNextAddress() {
        return this.addressIndex < this.addresses.length;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbResourceLocator#isRoot()
     */
    @Override
    public boolean isRoot() {
        // length == 0 should not happen
        return getShare() == null && getUNCPath().length() <= 1;
    }

    boolean isRootOrShare() {

        /**
         * @param root The root dependency
         * @return this request for chaining, never {@code null}
         */
        @Nonnull
        public DependencyResolverRequestBuilder root(@Nonnull DependencyCoordinates root) {
            this.root = root;
            return this;
        }

        /**