defaultSubstitutions = commonDefaultSubstitutions
            testRoot.convention(restRootDir)
        }

        // TODO: This effectively makes testRoot not customizable, which we don't do anyway atm
        project.sourceSets.test.output.dir(restRootDir, builtBy: buildRestTests)
    }

    @Override
    public TaskProvider<? extends Task> createTask(Project project) {
        Configuration loggerUsageConfig = project.getConfigurations().create("loggerUsagePlugin");
        // this makes it easier to test by not requiring this project to be always available in our
        // test sample projects
        if (project.findProject(":test:logger-usage") != null) {

And we know that editors can't provide a lot of support (like completion) for `dict`s, because they can't know their keys and value types.

We can do better...

## What makes a dependency { #what-makes-a-dependency }

Up to now you have seen dependencies declared as functions.

But that's not the only way to declare dependencies (although it would probably be the more common).

@defaultMessage EntityTemplate is easy to mess up and forget to set content type
org.apache.http.entity.EntityTemplate#<init>(org.apache.http.entity.ContentProducer)

@defaultMessage SerializableEntity uses java serialization and makes it easy to forget to set content type

 * under the License.
 */
package org.apache.maven.execution;

import java.util.Optional;

/**
 * Instances of this class are responsible for determining whether it makes sense to "resume" a build using
 * the {@code --resume} flag.
 */
public interface BuildResumptionAnalyzer {
    /**
     * Construct an instance of {@link BuildResumptionData} based on the outcome of the current Maven build.

 * While it would be more technically correct to do so, the effort/complexity does not warrant it, since for the expected usage it makes
 * no difference.
 */

public class RemoveWarnings implements RestTestTransformByParentObject {

    private final Set<String> warnings;
    private String testName;

    /**

// initialized when the provided function returns nil.

// Init represents the structure.
type Init struct {
	done uint32
	m    sync.Mutex
}

// Do is similar to sync.Once.Do - makes one successful
// call to the function. ie, it invokes the function
// if it is not successful yet.
func (l *Init) Do(f func() error) error {
	if atomic.LoadUint32(&l.done) == 0 {
		return l.do(f)
	}
	return nil
}

1. Creating a PR and observing the presubmit test results
2. Running the CI scripts locally, as explained below
3. **Google employees only**: Google employees can use an internal-only tool
called "MLCI" that makes testing more convenient: it can execute any full CI job
against a pending change. Search for "MLCI" internally to find it.

You may invoke a CI script of your choice by following these instructions:

```bash

To see how to achieve this parallelism in production see the section about [Deployment](deployment/index.md).

## `async` and `await` { #async-and-await }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionSerializationEqualTester<E> extends AbstractCollectionTester<E> {
  @CollectionFeature.Require(SERIALIZABLE)
  /*
   * As the class docs say, this test only makes sense for collections that define equals().
   * Accordingly, our testing framework adds it only when testing an implementation of List, Set, or
   * Multiset.
   */
  @SuppressWarnings("UndefinedEquals")