expect:
        def snapshot1 = snapshotter.snapshot([])
        snapshot1 instanceof ListValueSnapshot
        snapshot1 == snapshotter.snapshot([])
        snapshot1 != snapshotter.snapshot("abc")

        def snapshot2 = snapshotter.snapshot(["123"])
        snapshot2 instanceof ListValueSnapshot
        snapshot2 == snapshotter.snapshot(["123"])
        snapshot2 != snapshot1
    }

        def adapter2 = new ProxyDispatchAdapter<ProxyTest>(dispatch, ProxyTest, Runnable).source

        expect:
        adapter1 instanceof Runnable
        adapter1 instanceof ProxyTest
        adapter2 instanceof Runnable
        adapter2 instanceof ProxyTest
    }
}

interface ProxyTest {
    void doStuff(String param)

        if (dependencyNotation instanceof Configuration) {
            throw new GradleException("Adding a Configuration as a dependency is no longer allowed as of Gradle 8.0.");
        } else if (dependencyNotation instanceof ProviderConvertible<?>) {

    public boolean isExecutable() {
        return binary instanceof NativeExecutableBinarySpec || binary instanceof NativeTestSuiteBinarySpec;
    }

    @Override
    public ProjectType getProjectType() {
        return binary instanceof SharedLibraryBinarySpec ? ProjectType.DLL
            : binary instanceof StaticLibraryBinarySpec ? ProjectType.LIB
            : binary instanceof NativeExecutableBinarySpec ? ProjectType.EXE

        @Override
        public void convert(Object notation, NotationConvertResult<? super String> result) throws TypeConversionException {
            if (notation instanceof CharSequence || notation instanceof Number || notation instanceof Boolean || notation instanceof Character || notation instanceof File) {
                result.converted(notation.toString());
            }
        }

        @Override

                if (message instanceof UserResponse) {
                    stdinHandler.onUserResponse((UserResponse) message);
                } else if (message instanceof ForwardInput) {
                    stdinHandler.onInput((ForwardInput) message);
                } else if (message instanceof CloseInput) {
                    stdinHandler.onEndOfInput();
                } else {

    @Override
    public boolean equals(@Nullable Object obj) {
      return obj instanceof ConstructorParameterSingleValue;
    }

    @Override
    public int hashCode() {
      return 1;
    }

    public static class Singleton {
      public static final Singleton INSTANCE = new Singleton();

      private Singleton() {}
    }
  }

    checkNotNull(type);
    if (type instanceof TypeVariable) {
      return typeTable.resolve((TypeVariable<?>) type);
    } else if (type instanceof ParameterizedType) {
      return resolveParameterizedType((ParameterizedType) type);
    } else if (type instanceof GenericArrayType) {
      return resolveGenericArrayType((GenericArrayType) type);
    } else if (type instanceof WildcardType) {

        def task = project.tasks['compileGroovy']

        then:
        task instanceof GroovyCompile
        task.description == 'Compiles the main Groovy source.'
        dependsOn(JvmConstants.COMPILE_JAVA_TASK_NAME).matches(task)

        when:
        task = project.tasks['compileTestGroovy']

        then:
        task instanceof GroovyCompile
        task.description == 'Compiles the test Groovy source.'

        if (event instanceof ProgressStartEvent) {
            onStart((ProgressStartEvent) event);
        } else if (event instanceof RenderableOutputEvent) {
            handleOutput((RenderableOutputEvent) event);
        } else if (event instanceof ProgressCompleteEvent) {
            onComplete((ProgressCompleteEvent) event);
        } else if (event instanceof EndOutputEvent) {