}

    @Test
    @DisplayName("Should handle getScope() method")
    void testGetScope() {
        // Given
        String testScope = "WORKGROUP";
        when(mockNetbiosName.getScope()).thenReturn(testScope);

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

        // Then
        assertEquals(testScope, scope);
        verify(mockNetbiosName).getScope();
    }

    @Test

        System.out.println(a.getScope());
        assertTrue(a.getScope().equals("test"), "Incorrect scope for " + a.getDependencyConflictId());

        // transitive dep, overridden b depMgmt
        assertTrue(b.getScope().equals("runtime"), "Incorrect scope for " + b.getDependencyConflictId());

        // direct dep, overrides depMgmt

        when(mockCalledName.getNameType()).thenReturn(0x20);
        when(mockCalledName.getScope()).thenReturn(null);

        when(mockCallingName.getName()).thenReturn("CLIENT");
        when(mockCallingName.getNameType()).thenReturn(0x00);
        when(mockCallingName.getScope()).thenReturn(null);

        SessionRequestPacket packet = new SessionRequestPacket(mockConfig, mockCalledName, mockCallingName);

                Artifact artifact;
                if (d.getScope().equals(Artifact.SCOPE_TEST) || d.getScope().equals(Artifact.SCOPE_PROVIDED)) {
                    /* don't call createDependencyArtifact as it'll ignore test and provided scopes */
                    artifact = artifactFactory.createArtifact(
                            d.getGroupId(), d.getArtifactId(), d.getVersion(), d.getScope(), d.getType());
                } else {

                        dependency = dependency.withVersion(managedDependency.getVersion());
                    }
                    if (dependency.getScope() == null && managedDependency.getScope() != null) {
                        dependency = dependency.withScope(managedDependency.getScope());
                    }
                    if (dependency.getOptional() == null && managedDependency.getOptional() != null) {

            parent = node;
        }
        return tree;
    }

    public void setClasspath(List<ArtifactMetadata> classpath) {
        this.classpath = classpath;
    }

    public ArtifactScopeEnum getScope() {
        return scope;
    }

    public void setScope(ArtifactScopeEnum scope) {
        this.scope = scope;
    }

        // and we want artifact resolution to only return the system scoped artifact itself.
        //
        if (artifact.getScope() != null && artifact.getScope().equals(Artifact.SCOPE_SYSTEM)) {
            return new ResolutionGroup(null, null, null);
        }

        ResolutionGroup cached = cache.get(
                artifact,

        assertEquals(DirectoryCacheScope.IMMEDIATE_CHILDREN, directoryLeaseManager.getCacheEntry(dir1).getScope());
        assertEquals(DirectoryCacheScope.METADATA_ONLY, directoryLeaseManager.getCacheEntry(dir2).getScope());
        assertEquals(DirectoryCacheScope.RECURSIVE_TREE, directoryLeaseManager.getCacheEntry(dir3).getScope());
    }

    dep2: Annotated[list[str], Security(security2, scopes=["scope2"])],
):
    return {"dep1": dep1, "dep2": dep2}


app = FastAPI()


@app.get("/scopes")
def get_scopes(
    dep3: Annotated[dict[str, Any], Security(dep3, scopes=["scope3"])],
):
    return dep3


client = TestClient(app)


def test_security_scopes_dont_propagate():
    response = client.get("/scopes")

        if (dependency == null) {
            return null;
        }

        org.apache.maven.artifact.Artifact result = toArtifact(dependency.getArtifact());
        result.setScope(dependency.getScope());
        result.setOptional(dependency.isOptional());

        return result;
    }

    public static org.apache.maven.artifact.Artifact toArtifact(Artifact artifact) {
        if (artifact == null) {