import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;

/**
 * Verifies scope of root project is preserved regardless of parent dependency management.
 *
 * @see <a href="https://issues.apache.org/jira/browse/MNG-2919">MNG-2919</a>
 */
@Deprecated
@SuppressWarnings("checkstyle:UnusedLocalVariable")

# Security Tools

When you need to declare dependencies with OAuth2 scopes you use `Security()`.

But you still need to define what is the dependable, the callable that you pass as a parameter to `Depends()` or `Security()`.

There are multiple tools that you can use to create those dependables, and they get integrated into OpenAPI so they are shown in the automatic docs UI, they can be used by automatically generated clients and SDKs, etc.

        final int start = srcIndex;

        this.addressArray = new NbtAddress[this.numberOfNames];

        String n;
        int hexCode;
        final String scope = this.queryAddress.hostName.scope;
        boolean groupName;
        int ownerNodeType;
        boolean isBeingDeleted;
        boolean isInConflict;
        boolean isActive;
        boolean isPermanent;
        int j;

     * @param requestedState requested lease state
     * @param scope cache scope
     * @return lease key or null if not supported
     * @throws SmbException if an error occurs
     */
    public static Smb2LeaseKey requestDirectoryLease(SmbFile smbFile, int requestedState, DirectoryCacheScope scope) throws SmbException {
        if (!smbFile.isDirectory()) {

            // Expected due to missing dependencies in test environment
            assertTrue(true);
            return;
        }
        // assertEquals(0, result.size()); // Commented out due to variable scope
    }

    public void test_getBoostedDocumentList_withVirtualHost() {
        KeyMatch keyMatch = new KeyMatch();
        keyMatch.setId("km1");
        keyMatch.setTerm("java");

func getScope(t time.Time, region string) string {
	scope := strings.Join([]string{
		t.Format(yyyymmdd),
		region,
		string(serviceS3),
		"aws4_request",
	}, SlashSeparator)
	return scope
}

// getStringToSign a string based on selected query values.
func getStringToSign(canonicalRequest string, t time.Time, scope string) string {

 */
@Experimental
@Immutable
@SuppressWarnings("checkstyle:InterfaceIsType")
public interface ProjectScope extends ExtensibleEnum {

    /**
     * Main scope.
     */
    ProjectScope MAIN = projectScope("main");

    /**
     * Test scope.
     */
    ProjectScope TEST = projectScope("test");

 */
public interface NetbiosName {

    /**
     * Returns the NetBIOS name.
     *
     * @return the name
     */
    String getName();

    /**
     * Returns the NetBIOS scope identifier.
     *
     * @return the scope id
     */
    String getScope();

    /**
     * Returns the NetBIOS name type.
     *
     * @return the name type
     */
    int getNameType();

/// note | Technical Details

A `Request` has a `request.scope` attribute, that's just a Python `dict` containing the metadata related to the request.

A `Request` also has a `request.receive`, that's a function to "receive" the body of the request.

The `scope` `dict` and `receive` function are both part of the ASGI specification.

And those two things, `scope` and `receive`, are what is needed to create a new `Request` instance.

        }
    }

    interface DependenciesPointer extends Pointer {
        /**
         * Returns the dependency scope this pointer applies to.
         *
         * @return the dependency scope, or "all" if not specified
         */
        String scope(); // default: all

        /**
         * Returns the type of pointer, which is always DEPENDENCIES for a DependenciesPointer.
         *