Class <org.gradle.api.DefaultTask> extends/implements org.gradle.api.internal.AbstractTask that is Gradle Internal API in (DefaultTask.java:0)
Class <org.gradle.api.ExtensiblePolymorphicDomainObjectContainer> extends/implements org.gradle.api.internal.rules.NamedDomainObjectFactoryRegistry that is Gradle Internal API in (ExtensiblePolymorphicDomainObjectContainer.java:0)

        def configCache = newConfigurationCacheFixture()
        scriptFileFor(scriptTarget) << """
            import org.gradle.api.flow.*
            import org.gradle.api.services.*

            class LavaLampPlugin implements Plugin<$targetType> {

                final FlowScope flowScope
                final FlowProviders flowProviders

                @Inject

                String getVeryDeepMessage()
            }

            interface SideModel extends BaseModel {
            }

            abstract class AbstractModel implements DeepChildModel {
            }

            class DefaultModel extends AbstractModel implements ShallowChildModel, DeepChildModel, VeryDeepChildModel, SideModel, java.io.Serializable {

                private final String message

				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BaseOptions) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 0
	_ = z
	err = en.Append(0x80)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BaseOptions) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())

import org.gradle.api.problems.internal.ProblemLocation

/*
 * A deserialized representation of a problem received from the build operation trace.
 */
@CompileStatic
class ReceivedProblem implements Problem {
    private final long operationId
    private final ReceivedProblemDefinition definition
    private final String contextualLabel
    private final String details
    private final List<String> solutions

        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) {

         given:
         def configurationCache = newConfigurationCacheFixture()

         buildFile("""
            import org.gradle.api.provider.*

            abstract class GreetValueSource implements ValueSource<String, ValueSourceParameters.None> {
                String obtain() {
                    return "Hello!"
                }
            }

            abstract class MyTask extends DefaultTask {

        buildFile << """
            class Placeholder implements Serializable {
                String value

                private Object readResolve() {
                    return new OtherBean(prop: "[\$value]")
                }
            }

            class OtherBean implements Serializable {
                String prop

                private Object writeReplace() {

  }

  public static class NoOpRunnable implements Runnable {
    @Override
    public void run() {}
  }

  public static class NoOpCallable implements Callable<Object> {
    @Override
    public Object call() {
      return Boolean.TRUE;
    }
  }

  public static final String TEST_STRING = "a test string";

  public static class StringTask implements Callable<String> {
    @Override

// an error is not warranted.
func NewEmptyWatch() Interface {
	ch := make(chan Event)
	close(ch)
	return emptyWatch(ch)
}

// Stop implements Interface
func (w emptyWatch) Stop() {
}

// ResultChan implements Interface
func (w emptyWatch) ResultChan() <-chan Event {
	return chan Event(w)
}

// FakeWatcher lets you test anything that consumes a watch.Interface; threadsafe.