!!! tip
    To declare File bodies, you need to use `File`, because otherwise the parameters would be interpreted as query parameters or body (JSON) parameters.

The files will be uploaded as "form data".

  private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid
   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the

 * finding the annotated elements. Subclasses only need to provide the processing logic given those elements.
 *
 * The declared type of the processor can be overwritten to test various error cases, e.g. a processor that
 * declares itself as incremental, but doesn't honor that contract.
 */
@CompileStatic
class AnnotationProcessorFixture {
    protected final String annotationName

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

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

* `users:read` or `users:write` are common examples.
* `instagram_basic` is used by Facebook / Instagram.
* `https://www.googleapis.com/auth/drive` is used by Google.

!!! info
    In OAuth2 a "scope" is just a string that declares a specific permission required.

        return new AbstractTypeMetadataWalker.InstanceTypeMetadataWalker(typeMetadataStore, nestedAnnotation);
    }

    /**
     * A factory method for a walker that can visit property hierarchy declared by a type.
     *
     * Type walker can detect a nested property cycle and stop walking the path with a cycle, no exception is thrown.
     */

	// Go spec: A short variable declaration may redeclare variables
	// provided they were originally declared in the same block with
	// the same type, and at least one of the non-blank variables is new.
	n := 0 // number of new variables
	for _, ident := range idents {
		assert(ident.Obj == nil, "identifier already declared or resolved")
		if ident.Name != "_" {
			obj := ast.NewObj(ast.Var, ident.Name)

[[sec:strict-version]]
`strictly`::
Any version not matched by this version notation will be excluded.
This is the strongest version declaration.
On a declared dependency, a `strictly` can downgrade a version.
When on a transitive dependency, it will cause dependency resolution to fail if no version acceptable by this clause can be selected.

        then:
        outputContains(IvyComponentParser.PUBLICATION_WARNING_FOOTER)
        outputContains(IvyComponentParser.UNSUPPORTED_FEATURE)
        outputContains('commons-logging:commons-logging:1.1 declared as a dependency constraint')
        javaLibrary.assertPublished()

        javaLibrary.parsedIvy.configurations.keySet() == ["compile", "runtime", "default"] as Set

                warnings.addUnsupported(String.format("%s:%s:%s declared as a dependency constraint", constraint.getGroup(), constraint.getName(), constraint.getVersion()));
            }
        }
        if (!variant.getCapabilities().isEmpty()) {
            for (Capability capability : variant.getCapabilities()) {

    /**
     * Configures the variants of this configuration.
     */
    void variants(Action<? super NamedDomainObjectContainer<ConfigurationVariant>> configureAction);

    /**
     * Declares a capability for this configuration.
     *
     * @param notation the notation
     *
     * Valid notations are a <i>group:name:version</i> string (e.g: <i>org.test:capability:1.0</i>, or a map