Artifact artifact = (Artifact) aSet;
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()
                    + " Scope: " + artifact.getScope());
            assertTrue(
                    artifact.getVersion().equals("1.0"), "Incorrect version for " + artifact.getDependencyConflictId());
        }
    }

        return scope == null ? DEFAULT_SCOPE : scope;
    }

    /**
     *
     * @return unsafe String representation of this scope.
     */
    public String getScope() {
        if (id == 1) {
            return Artifact.SCOPE_COMPILE;
        } else if (id == 2) {
            return Artifact.SCOPE_TEST;

        } else if (id == 3) {
            return Artifact.SCOPE_RUNTIME;

    String getGroupId();

    String getArtifactId();

    String getVersion();

    void setVersion(String version);

    String getScope();

    String getType();

    String getClassifier();

    boolean hasClassifier();

    File getFile();

    void setFile(File destination);

    String getBaseVersion();

        this.asGraph = asGraph;
        return this;
    }

    public MetadataResolutionRequest setScope(String scope) {
        this.scope = scope;
        return this;
    }

    public String getScope() {
        return scope;
    }

        }

        DefaultArtifact clone = new DefaultArtifact(
                artifact.getGroupId(),
                artifact.getArtifactId(),
                range,
                artifact.getScope(),
                artifact.getType(),
                artifact.getClassifier(),
                artifact.getArtifactHandler(),
                artifact.isOptional());
        clone.setRelease(artifact.isRelease());

                });

                for (MetadataGraphEdge e : sortedExits) {
                    MetadataGraphVertex targetNode = e.getTarget();
                    targetNode.getMd().setArtifactScope(e.getScope());
                    targetNode.getMd().setWhy(e.getSource().getMd().toString());
                    visit(targetNode);
                }
            }
        }

            throw new UnknownHostException("no name with type 0x" + Hexdump.toHexString(addr.getNameType(), 2)
                    + (addr.getName().getScope() == null || addr.getName().getScope().isEmpty() ? " with no scope"
                            : " with scope " + addr.getName().getScope())
                    + " for host " + addr.getHostAddress());
        }
    }

    /**
     * Get the address of the active WINS server

     *
     * <p>A typical usage is to invoke this method for all dependencies having a
     * {@link DependencyScope#TEST TEST} or {@link DependencyScope#TEST_ONLY TEST_ONLY}
     * {@linkplain Dependency#getScope() scope}. An {@code --add-reads} option may need
     * to be generated for compiling and running the test classes that use such dependencies.</p>
     *

	hashedChunk := hex.EncodeToString(cr.chunkSHA256Writer.Sum(nil))

	// Calculate string to sign.
	alg := signV4ChunkedAlgorithm + "\n"
	stringToSign := alg +
		cr.seedDate.Format(iso8601Format) + "\n" +
		getScope(cr.seedDate, cr.region) + "\n" +
		cr.seedSignature + "\n" +
		emptySHA256 + "\n" +
		hashedChunk

	// Get hmac signing key.
	signingKey := getSigningKey(cr.cred.SecretKey, cr.seedDate, cr.region, serviceS3)

        // scoped graph is versioned by definition
        if (scopedVertices) {
            versionedVertices = true;
        }
    }

    public ArtifactScopeEnum getScope() {
        return scope;
    }

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

    // ------------------------------------------------------------------------