}

    def createsANonBlockingActorForATargetObject() {
        when:
        def actor = factory.createActor(target)

        then:
        actor != null
    }

    def cachesTheNonBlockingActorForATargetObject() {
        when:
        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(target)

        then:
        actor2.is(actor1)
    }

        then:
        1 * factory.create() >> processor1
        1 * actorFactory.createActor(processor1) >> actor1
        1 * actor1.getProxy(TestClassProcessor) >> asyncProcessor1

        when:
        processor.processTestClass(test)

        then:
        1 * factory.create() >> processor2
        1 * actorFactory.createActor(processor2) >> actor2
        1 * actor2.getProxy(TestClassProcessor) >> asyncProcessor2

    }

    @Override
    public void startProcessing(TestResultProcessor resultProcessor) {
        // Create a processor that processes events in its own thread
        resultProcessorActor = actorFactory.createActor(resultProcessor);
        this.resultProcessor = resultProcessorActor.getProxy(TestResultProcessor.class);
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        if (stoppedNow) {

public interface ActorFactory {
    /**
     * Creates an asynchronous actor for the given target object.
     *
     * @param target The target object.
     * @return The actor.
     */
    Actor createActor(Object target);

    /**
     * Creates a synchronous actor for the given target object.
     *
     * @param target The target object.
     * @return The actor.
     */

import org.gradle.internal.dispatch.ProxyDispatchAdapter;
import org.gradle.internal.dispatch.ReflectionDispatch;

public class TestActorFactory implements ActorFactory {
    @Override
    public Actor createActor(Object target) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Actor createBlockingActor(final Object target) {
        return new Actor() {
            @Override

            } finally {
                nonBlockingActors.clear();
            }
        }
    }

    @Override
    public Actor createActor(Object target) {
        if (target instanceof NonBlockingActor) {
            return (NonBlockingActor) target;
        }
        synchronized (lock) {
            if (blockingActors.containsKey(target)) {

      gather_op.getDimensionNumbers().getStartIndexMap().end());

  auto offset_dims = builder_.CreateVector(offset_dims_vec);
  auto collapsed_slice_dims = builder_.CreateVector(collapsed_slice_dims_vec);
  auto start_index_map = builder_.CreateVector(start_index_map_vec);
  auto slice_sizes = builder_.CreateVector(
      mlir::GetOptionalVector<int64_t>(gather_op.getSliceSizes()));

      CreateOpMetadata(
          fb_builder, 3, 1,
          fb_builder.CreateVector(std::vector<float>({-1.0, 2.0}))),
  };
  const auto subgraphs = {CreateSubgraphMetadata(
      fb_builder, fb_builder.CreateVector(ops.begin(), ops.size()))};

  const auto metadata = CreateRuntimeMetadata(
      fb_builder, hardwares,
      fb_builder.CreateVector(subgraphs.begin(), subgraphs.size()));

      flatbuffers::Offset<flatbuffers::Vector<float>> per_device_cost_offset;

      if (per_device_cost.has_value()) {
        per_device_cost_offset = builder->CreateVector(*per_device_cost);
      }

      OpMetadataBuilder op_builder(*builder);
      op_builder.add_index(index);
      uint8_t hardware = hardware_map.at(*device_name);
      op_builder.add_hardware(hardware);

  auto window_strides__ = window_strides ? _fbb.CreateVector<int64_t>(*window_strides) : 0;
  auto base_dilations__ = base_dilations ? _fbb.CreateVector<int64_t>(*base_dilations) : 0;
  auto window_dilations__ = window_dilations ? _fbb.CreateVector<int64_t>(*window_dilations) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int64_t>(*padding) : 0;