### Tested

* 100% <abbr title="The amount of code that is automatically tested">test coverage</abbr>.
* 100% <abbr title="Python type annotations, with this your editor and external tools can give you better support">type annotated</abbr> code base.
* Used in production applications.

## Starlette features

        } else if (coverage != null) {
            return versionsFrom(coverage.value().newInstance(target, target).call() as List)
        } else {
            throw new RuntimeException("Target class '$target' is not annotated with @${TargetVersions.simpleName} nor with @${TargetCoverage.simpleName}.")
        }
    }

    @Override
    protected boolean isAvailable(DefaultVersionedTool version) {
        return true
    }

      auto block_arg = mlir::dyn_cast<BlockArgument>(operand);
      if (block_arg && block_arg.getOwner() == &replicate.GetBody()) {
        // Only mirrored args of ReplicateOp can be annotated.
        if (mirrored_replicate_args.count(block_arg.getArgNumber()) == 0) {
          continue;
        }
      } else if (!operand.getParentRegion()->isProperAncestor(
                     &replicate.getBody())) {

    ```

=== "Python 3.10+ nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python
    {!> ../../../docs_src/app_testing/app_b_py310/main.py!}
    ```

=== "Python 3.8+ nicht annotiert"

    !!! tip "Tipp"
        Bevorzugen Sie die `Annotated`-Version, falls möglich.

    ```Python
    {!> ../../../docs_src/app_testing/app_b/main.py!}
    ```

import org.jetbrains.kotlin.samWithReceiver.gradle.SamWithReceiverGradleSubplugin


/**
 * Configures the Kotlin compiler to recognise Gradle functional interface
 * annotated with [HasImplicitReceiver].
 */
abstract class KotlinDslCompilerPlugins : Plugin<Project> {

    override fun apply(project: Project): Unit = project.run {

            }
        }
    }
}
----
=====

The `LicenseTask` class encapsulates the task action logic and declares any inputs and outputs the task expects.

The task action is annotated with `@TaskAction`.
Inside, the logic first finds a file called "license.txt".
This file contains text for an Apache license:

.license.txt
[source,text]
----
/*
* Licensed under the Apache License

 *
 * <p>Sets the {@link org.gradle.integtests.fixtures.CrossVersionIntegrationSpec#previous} property of the test instance before executing it.
 *
 * <p>A test class can be annotated with {@link org.gradle.integtests.fixtures.TargetVersions} to specify the set of versions the test is compatible with, and {@link org.gradle.integtests.fixtures.IgnoreVersions} to specify the set of versions the

            if (classWithAnnotationAttached.getAnnotation(ThisIsAThing)?.invalid()) {
                visitor.visitTypeProblem {
                    it.label("Annotated as invalid thing!")
                }
            }
        }
    }

    private static class SimplePropertyAnnotationHandler extends AbstractPropertyAnnotationHandler {

                    .severity(Severity.ERROR)
                    .details(String.format("A property annotated with @ServiceReference must be of a type that implements '%s'", BuildService.class.getName()))
                    .solution(String.format("Make '%s' implement '%s'", typeVariables.get(0).getName(), BuildService.class.getName()))

    func.setType(
        FunctionType::get(func.getContext(), arg_types,
                          func.front().getTerminator()->getOperandTypes()));
    return WalkResult::advance();
  });

  // Remove the annotated op after since it is just a placeholder.
  DenseSet<tf_device::LaunchOp> launch_ops;
  getOperation().walk([&](Operation* op) {
    if (llvm::isa<TF::TPUAnnotateTensorsWithDynamicShapeOp>(op)) {