def empty = ImmutableActionSet.empty()

        expect:
        def set = empty.mergeFrom(empty)
        set.is(empty)
    }

    def "can merge empty set into singleton set"() {
        def action = Mock(Action)
        def singleton = ImmutableActionSet.of(action)

        expect:
        def set = singleton.mergeFrom(ImmutableActionSet.empty())
        set.is(singleton)
    }

                    left.mergeFrom(this);
                    left.maybeSplit();
                    return;
                } else {
                    // There are only enough entries to make up 1 block, so move the entries of the left sibling into
                    // this block and discard the left sibling. Might also need to merge the parent
                    left.mergeFrom(this);
                    parent.maybeMerge();

  if (!cg_mu_) {
    return Status(absl::StatusCode::kFailedPrecondition,
                  "This QueueRunner doesn't collect a cost graph.");
  }
  mutex_lock l(*cg_mu_);
  cost_graph->MergeFrom(*cost_graph_);
  return absl::OkStatus();
}

void QueueRunner::SetRunArgumentsAndCostGraph(const RunOptions& run_options) {
  cg_mu_.reset(new mutex());
  {
    mutex_lock l(*cg_mu_);

        public AbstractDomainObjectCreatingProvider(String name, Class<I> type, @Nullable Action<? super I> configureAction) {
            super(name, type);
            this.onCreate = ImmutableActionSet.<I>empty().mergeFrom(getEventRegister().getAddActions());

            if (configureAction != null) {
                configure(configureAction);
            }
        }

        @Override

        return new SetWithManyActions<T>(set);
    }

    /**
     * Creates a new set that includes the actions from this set plus the actions from the given set.
     */
    public ImmutableActionSet<T> mergeFrom(ImmutableActionSet<? super T> sibling) {
        if (sibling == this) {
            return this;
        }
        if (sibling.isEmpty()) {
            return this;
        }
        if (isEmpty()) {

                    } else {
                        onCreate = Cast.uncheckedCast(taskProvider.getOnCreateActions().mergeFrom(getEventRegister().getAddActions()));
                    }

                    add(task, onCreate);
                    return; // Exit early as we are reusing the create actions from the provider