then:
        1 * processor.started({it.id == 1}, {it.parentId == null})
        1 * processor.started({ it.id == 2 && it.name == "ignored2" && it.className == AnIgnoredTestClass.name }, { it.parentId == 1 })
        1 * processor.completed(2, { it.resultType == SKIPPED })
        1 * processor.started({ it.id == 3 && it.name == "ignored" && it.className == AnIgnoredTestClass.name }, { it.parentId == 1 })

    private final CompositeIdGenerator.CompositeId parentId;
    private final String displayName;

    public DefaultNestedTestSuiteDescriptor(Object id, String name, String displayName, CompositeIdGenerator.CompositeId parentId) {
        super(id, name);
        this.displayName = displayName;
        this.parentId = parentId;
    }

    public CompositeIdGenerator.CompositeId getParentId() {

    private final OperationIdentifier id;
    private final OperationIdentifier parentId;

    public DefaultProblemDescriptor(OperationIdentifier id, @Nullable OperationIdentifier parentId) {
        this.id = id;
        this.parentId = parentId;
    }

    @Override
    public Object getId() {
        return id;
    }

    @Override
    public String getName() {

            assert details.buildPath == buildLogicBuild
            assert parentId == workGraphOps[0].id
        }
        with(calculateWorkOps[1]) {
            assert details.buildPath == ':'
            assert parentId == workGraphOps[1].id
        }
        with(calculateWorkOps[2]) {
            assert details.buildPath == ':'
            assert parentId == workGraphOps[2].id
        }

        taskGraphOps[0].parentId == treeTaskGraphOps[0].id
        taskGraphOps[1].displayName == "Calculate task graph"
        taskGraphOps[1].details.buildPath == ':'
        taskGraphOps[1].parentId == treeTaskGraphOps[1].id

        def runMainTasks = ops.only(RunRequestedWorkBuildOperationType)
        runMainTasks.parentId == root.id

        def runTasksOps = ops.all(Pattern.compile("Run tasks.*"))

                + "Don't expect to see this assertion stack trace due to the current architecture";

            parentId = testMethodParentId.get(iTestResult.getMethod());
            assert parentId != null;
        }
        resultProcessor.started(testInternal, new TestStartEvent(iTestResult.getStartMillis(), parentId));

        if (iTestResult.getThrowable() instanceof UnrepresentableParameterException) {

	}
	// test newCmdCompletion with a valid shell.
	// use a dummy parent command as newCmdCompletion needs it.
	parentCmd := &cobra.Command{}
	args := []string{"completion", shells[0]}
	parentCmd.SetArgs(args)
	cmd := newCmdCompletion(&out, "")
	parentCmd.AddCommand(cmd)
	if err := parentCmd.Execute(); err != nil {
		t.Errorf("Cannot execute newCmdCompletion: %v", err)
	}
}

func TestRunCompletion(t *testing.T) {

            children*.displayName == ["Execute Project.beforeEvaluate listener"]
            children.first().children*.displayName == ["Apply script '${relativePath('foo/before.gradle')}' to project ':foo'"]
            parentId == configOp.id
        }
        with(operations.only(NotifyProjectAfterEvaluatedBuildOperationType, { it.details.projectPath == ':foo' })) {
            displayName == 'Notify afterEvaluate listeners of :foo'

        this.className = className;
        this.methodName = methodName;
        this.parentId = parentId;
        this.taskPath = taskPath;
    }

    @Override
    public OperationIdentifier getId() {
        return id;
    }

    @Override
    public String getName() {
        return operationName;
    }

    @Override
    public String getDisplayName() {
        return operationDisplayName;

    Map<String, ?> toSerializable() {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("displayName", displayName);

        map.put("id", id);

        if (parentId != null) {
            map.put("parentId", parentId);
        }

        map.put("startTime", startTime);
        map.put("endTime", endTime);
        map.put("duration", endTime - startTime);

        if (details != null) {