expect:
        changesBetween(
            impl(SimpleTask), [impl(TestAction)],
            impl(SimpleTask), [impl(TestAction)]
        ).empty
    }

    def "not up-to-date when task name changed"() {
        expect:
        changesBetween(
            impl(PreviousTask), [impl(TestAction)],
            impl(SimpleTask), [impl(TestAction)]

        super(xmlTransformer);
    }

    public BuildAction getBuildAction() {
        return new BuildAction(getOrAppendNode(getXml(), "BuildAction"));
    }

    public TestAction getTestAction() {
        return new TestAction(getOrAppendNode(getXml(), "TestAction"));
    }

    public LaunchAction getLaunchAction() {
        return new LaunchAction(getOrAppendNode(getXml(), "LaunchAction"));
    }

        processed.displayName == original.displayName
        processed.workerAction instanceof TestAction
        processed.workerAction.value == original.workerAction.value
    }

    private static class TestAction implements Action<WorkerProcessContext>, Serializable {
        private final String value
        private TestAction(String value) {
            this.value = value
        }

        @Override

    </BuildAction>
    <TestAction
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       shouldUseLaunchSchemeArgsEnv = "YES">
       <Testables>
       </Testables>
       <AdditionalOptions>
       </AdditionalOptions>
    </TestAction>
    <LaunchAction

        given:
        Action<Task> testAction = Mock(Action)

        when:
        defaultTask.doFirst(testAction)
        Thread.currentThread().contextClassLoader = new ClassLoader(getClass().classLoader) {}
        defaultTask.actions[0].execute(defaultTask)

        then:
        1 * testAction.execute(defaultTask) >> {

    def "setup"() {
        generator.loadDefaults()
    }

    def "empty scheme file"() {
        expect:
        schemeFile.file.exists()
        ["BuildAction", "TestAction", "LaunchAction", "ProfileAction", "AnalyzeAction", "ArchiveAction"].each {
            schemeFile.schemeXml."$it".size() == 1
        }
    }

    private SchemeFile getSchemeFile() {

                            spec.getClasspath().from(getClasspath());
                        });
                        workQueue.submit(TestAction.class, x -> {});
                    }
                }

                public static abstract class TestAction implements WorkAction<WorkParameters.None> {
                    @Override
                    public void execute() {

     * classloader, the proxy class executes the given action.
     */
    def <T> Action<T> serializable(Action<T> action, ClassLoader target) {
        String src = """
class TestAction implements ${Action.class.name}, ${Serializable.class.name}
{
    Object key

    void execute(Object target) {
        def action = ${SerializableMockHelper.class.name}.ACTIONS.remove(key)

                    buildActionEntry.setBuildableReference(toBuildableReference(xcodeTarget));
                }
            });
        }
    }

    private void configureTestAction(XcodeSchemeFile.TestAction action) {
        action.setBuildConfiguration(BUILD_DEBUG);

        for (final XcodeTarget xcodeTarget : xcodeProject.getTargets()) {
            if (xcodeTarget.isUnitTest()) {

        def result = serialize(event, serializer)
        result instanceof ReadStdInEvent
    }

    def "can serialize Build message"() {
        expect:
        def action = new TestAction()
        def clientMetadata = new GradleLauncherMetaData()
        def params = new DefaultBuildActionParameters([:], [:], new File("some-dir"), LogLevel.ERROR, true, ClassPath.EMPTY)