*/

package org.gradle.internal.actor;

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.MethodInvocation;
import org.gradle.internal.dispatch.ProxyDispatchAdapter;
import org.gradle.internal.dispatch.ReflectionDispatch;

public class TestActorFactory implements ActorFactory {
    @Override

    /**
     * Adds a method invocation statement to this block
     */
    void methodInvocation(@Nullable String comment, String methodName, Object... methodArgs);

    /**
     * Adds a method invocation statement to this block
     */
    void methodInvocation(@Nullable String comment, BuildScriptBuilder.Expression target, String methodName, Object... methodArgs);

    /**

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.adapter;

interface MethodInvoker {
    void invoke(MethodInvocation invocation) throws Throwable;

        if (OperatingSystem.current().isWindows()) {
            buildScriptBuilder.methodInvocation("Swift tool chain does not support Windows. The following targets macOS and Linux:", "targetMachines.add", buildScriptBuilder.propertyExpression("machines.macOS.x86_64"));
            buildScriptBuilder.methodInvocation(null, "targetMachines.add", buildScriptBuilder.propertyExpression("machines.linux.x86_64"));
        } else {

 */

package org.gradle.internal.actor.internal

import org.gradle.internal.concurrent.ThreadSafe
import org.gradle.internal.dispatch.DispatchException
import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class DefaultActorFactorySpec extends ConcurrentSpec {
    private final TargetObject target = Mock()

import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.DispatchException;
import org.gradle.internal.dispatch.MethodInvocation;

/**
 * <p>An {@code Actor} dispatches method calls to a target object in a thread-safe manner. Methods are called either by
 * calling {@link Dispatch#dispatch(Object)} on the actor, or using the proxy object

     */
    public ContextClassLoaderProxy(Class<T> type, T target, ClassLoader contextClassLoader) {
        adapter = new ProxyDispatchAdapter<T>(new ContextClassLoaderDispatch<MethodInvocation>(new ReflectionDispatch(target), contextClassLoader), type);
    }

    public T getSource() {
        return adapter.getSource();
    }

                "cpp-unit-test")
            .block("Set the target operating system and architecture for this application", "application",
                b -> b.methodInvocation(null, "targetMachines.add", buildScriptBuilder.propertyExpression(getHostTargetMachineDefinition())));
    }

                "0.8.0");
        }

        builder.propertyAssignment(null, "rootProject.name", settings.getProjectName());
        if (!settings.getSubprojects().isEmpty()) {
            builder.methodInvocation(null, "include", settings.getSubprojects().toArray());
        }
        return builder;
    }

            .plugin("Apply the cpp-unit-test plugin to add support for building and running C++ test executables",
                "cpp-unit-test")
            .block(null,
                "library",
                b -> b.methodInvocation("Set the target operating system and architecture for this library", "targetMachines.add", buildScriptBuilder.propertyExpression(getHostTargetMachineDefinition())));
    }