TestFile addMissingScript(TestFile dir, ScriptLanguage scriptLanguage)

        String getDisplayName(String scriptExtension)
    }

    static class MissingBuild implements Scenario {

        @Override
        void setup(AbstractIntegrationSpec spec) {}

        @Override
        void createInitialBuildLayoutIn(TestFile dir, ScriptLanguage scriptLanguage) {

# Adding new progress event

* project `build-events`
  * `org.gradle.internal.build.event.types` 
     * `public class Default*Event extends AbstractProgressEvent<Internal*Descriptor> implements Serializable, Internal*Event`
     * `public class Default*Descriptor implements Serializable, Internal*Descriptor`
* project `tooling-api`
  * `org.gradle.tooling.internal.protocol`
     * `public interface Internal*Event extends InternalProgressEvent`

    }
    assertFalse(errorNotThrown);
  }

  private static class ClassWhichDoesNotImplementEquals implements Serializable {
    private static final long serialVersionUID = 1L;
  }

  private static class ClassWhichIsAlwaysEqualButHasDifferentHashcodes implements Serializable {
    private static final long serialVersionUID = 2L;

    @SuppressWarnings("EqualsHashCode")
    @Override

    }
    assertFalse(errorNotThrown);
  }

  private static class ClassWhichDoesNotImplementEquals implements Serializable {
    private static final long serialVersionUID = 1L;
  }

  private static class ClassWhichIsAlwaysEqualButHasDifferentHashcodes implements Serializable {
    private static final long serialVersionUID = 2L;

    @SuppressWarnings("EqualsHashCode")
    @Override

}

class CustomModel implements Serializable {
    List<CustomThing> things = new ArrayList()

    CustomModel(int heapSizeMb) {
        for(int i = 0; i < heapSizeMb; i++) {
            things.add(new CustomThing())
        }
    }
}

class CustomThing implements Serializable {
    byte[] payload = new byte[1024 * 1024]
}

class CustomBuilder implements ToolingModelBuilder {

import org.gradle.internal.resource.ReadableContent;

import java.io.IOException;
import java.io.InputStream;
import java.net.URI;

public class ProgressLoggingExternalResourceUploader extends AbstractProgressLoggingHandler implements ExternalResourceUploader {
    private final ExternalResourceUploader delegate;
    private final BuildOperationRunner buildOperationRunner;

        class MyBinaryDeclarationModel implements Plugin<Project> {
            void apply(final Project project) {}

            static class Rules extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }
            }
        }

        class MyBinaryCreationPlugin implements Plugin<Project> {

		Suffix:       suffix,
	}
}

// String implements the Stringer interface.
func (v MajorVersion) String() string {
	return fmt.Sprintf("%d", v.Major)
}

// String implements the Stringer interface.
func (v MinorVersion) String() string {
	return fmt.Sprintf("%s.%d", v.MajorVersion, v.Minor)
}

// String implements the Stringer interface.
func (v PatchVersion) String() string {

import org.gradle.tooling.internal.protocol.events.InternalTransformDescriptor;

import java.util.Set;

public class DefaultTransformOperationDescriptor extends DefaultOperationDescriptor implements TransformOperationDescriptor {

    private final TransformerDescriptor transformer;
    private final SubjectDescriptor subject;
    private final Set<OperationDescriptor> dependencies;

import static org.gradle.util.Matchers.matchesRegexp
import static org.hamcrest.Matchers.containsString

class ArtifactTransformValuesInjectionIntegrationTest extends AbstractDependencyResolutionTest implements ArtifactTransformTestFixture, ValidationMessageChecker {

    def "transform can receive parameters, workspace and input artifact via abstract getter"() {
        createDirs("a", "b", "c")
        settingsFile << """