when:
        buildA.buildFile << """
            assert isComposite(gradle)
            assert !isNested(gradle)
"""

        then:
        execute(buildA, "jar")
    }

    def "included build is flagged as a nested build without composite parent on initial configuration"() {
        when:
        buildB.buildFile << """
            assert !isComposite(gradle)
            assert isNested(gradle)

void ResourceConstructingOps::print(raw_ostream &os) const {
  llvm::interleaveComma(ops, os << "[");
  os << "]";
}

IsComposite::IsComposite(Operation *op) {}

IsComposite IsComposite::EntryState(MLIRContext *context) {
  return IsComposite();
}

IsComposite IsComposite::EntryState(Value value) {
  IsComposite result;
  if (auto barg = mlir::dyn_cast<BlockArgument>(value)) {
    if (func::FuncOp func =

};

struct IsComposite {
  explicit IsComposite(Operation *op = nullptr);
  static IsComposite EntryState(MLIRContext *context);
  static IsComposite EntryState(Value value);
  bool operator==(const IsComposite &rhs) const {
    return is_on_composite_device == rhs.is_on_composite_device;
  }

  static IsComposite join(const IsComposite &lhs, const IsComposite &rhs);
  void print(raw_ostream &os) const;

        then:
        1 * target.started(test, testStartEvent)
    }

    TestDescriptorInternal test(String id) {
        [isComposite: {false}, getId: {id}, toString: {id}] as TestDescriptorInternal
    }

    TestDescriptorInternal suite(String id) {
        [isComposite: {true}, getId: {id}, toString: {id}] as TestDescriptorInternal
    }

            return null;
        }
    }

    @Override
    public String getName() {
        return descriptor.getName();
    }

    @Override
    public boolean isComposite() {
        return descriptor.isComposite();
    }

        if (test.isComposite()) {
            testListener.beforeSuite(test);
        } else {
            testListener.beforeTest(test);
        }
    }

    @Override
    public void completed(TestDescriptorInternal test, TestResult result, TestCompleteEvent completeEvent) {
        if (test.isComposite()) {
            testListener.afterSuite(test, result);
        } else {

        this.processor = processor;
    }

    @Override
    public void started(TestDescriptorInternal test, TestStartEvent event) {
        if (rootId == null) {
            assert test.isComposite();
            rootId = test.getId();
        } else if (event.getParentId() == null) {
            event = event.withParentId(rootId);
        }
        processor.started(test, event);
    }

    @Override

        super(id, name);
    }

    @Override
    public String toString() {
        return "Test suite '"+ getName() + "'";
    }

    @Override
    public boolean isComposite() {
        return true;
    }

        return "Unknown test (possible bug, please report)";
    }

    @Override
    public String getClassName() {
        return null;
    }

    @Override
    public boolean isComposite() {
        return false;
    }

    @Override
    public TestDescriptorInternal getParent() {
        return null;
    }

    @Override
    public String getDisplayName() {
        return getName();

        this.displayName = displayName;
    }

    @Override
    public String toString() {
        return "Test " + getName() + "(" + className + ")";
    }

    @Override
    public boolean isComposite() {
        return false;
    }

    @Override
    public String getClassName() {
        return className;
    }

    @Override
    public String getMethodName() {
        return getName();