Session session, RequestType requestType, Artifact rootArtifact, PathScope scope) {
        return new DependencyResolverRequestBuilder()
                .session(session)
                .requestType(requestType)
                .rootArtifact(rootArtifact)
                .pathScope(scope)
                .build();
    }

    @Nonnull

        return classpathTransformation.transform(dirtyGraph, scope, false);
    }

    // ----------------------------------------------------------------------------
    public MetadataTreeNode getClasspathTree(ArtifactScopeEnum scope)
            throws MetadataGraphTransformationException, MetadataResolutionException {
        ClasspathContainer cpc = getClasspath(scope);
        if (cpc == null) {
            return null;

    /**
     * Shortcut for {@code getService(DependencyResolver.class).flatten(...)}.
     *
     * @param node node for which to get a flattened list
     * @param scope build path scope (main compile, test compile, etc.) of desired nodes
     * @return flattened list of node with the given build path scope

    </dependency>

    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

        assertEquals("", name);
    }

    @Test
    @DisplayName("Should handle null scope")
    void testNullScope() {
        // Given
        when(mockNetbiosName.getScope()).thenReturn(null);

        // When
        String scope = mockNetbiosName.getScope();

        // Then
        assertNull(scope);
    }

    @Test
    @DisplayName("Should handle various name lengths")

Pero también pasamos una `list` de scopes, en este caso con solo un scope: `items` (podría tener más).

Y la función de dependencia `get_current_active_user` también puede declarar sub-dependencias, no solo con `Depends` sino también con `Security`. Declarando su propia función de sub-dependencia (`get_current_user`), y más requisitos de scope.

En este caso, requiere el scope `me` (podría requerir más de un scope).

/// note | Nota

		t.Errorf("Test %d: service mismatch:Expected \"%s\", got \"%s\"", testNum, expectedCredentials.scope.service, actualCredential.scope.service)
	}

	if expectedCredentials.scope.request != actualCredential.scope.request {
		t.Errorf("Test %d: scope request mismatch:Expected \"%s\", got \"%s\"", testNum, expectedCredentials.scope.request, actualCredential.scope.request)
	}
}

The spec also states that the `username` and `password` must be sent as form data (so, no JSON here).

### `scope` { #scope }

The spec also says that the client can send another form field "`scope`".

The form field name is `scope` (in singular), but it is actually a long string with "scopes" separated by spaces.

Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

     * a fairly complete list of NetBIOS hex codes. Scope is not used but is
     * still functional in other NetBIOS products and so for completeness it has been
     * implemented. A <code>scope</code> of <code>null</code> or <code>""</code>
     * signifies no scope.
     *
     * @param host the name to resolve
     * @param type the hex code of the name
     * @param scope the scope of the name
     * @return the resolved NetBIOS address

### <abbr title="Geltungsbereich">`scope`</abbr>

Ferner sagt die Spezifikation, dass der Client ein weiteres Formularfeld "`scope`" („Geltungsbereich“) senden kann.

Der Name des Formularfelds lautet `scope` (im Singular), tatsächlich handelt es sich jedoch um einen langen String mit durch Leerzeichen getrennten „Scopes“.

Jeder „Scope“ ist nur ein String (ohne Leerzeichen).