displayName == 'Notify beforeEvaluate listeners of :foo'
            children*.displayName == ["Execute Project.beforeEvaluate listener"]
            children.first().children*.displayName == ["Apply script '${relativePath('foo/before.gradle')}' to project ':foo'"]
            parentId == configOp.id
        }

			ci := tst.children[i]
			ciRange := ci.timeRange()
			for j := i + 1; j < len(tst.children); j++ {
				cj := tst.children[j]
				cjRange := cj.timeRange()
				if ciRange.overlaps(cjRange) {
					return fmt.Errorf("test %s: child %s[%s] overlaps with child %s[%s]",
						tst.name, ci.name, ciRange, cj.name, cjRange)
				}
			}
		}
	}

	// Now check the children.

    private final List<T> children;

    public CompositeOperation(Iterable<? extends T> children) {
        this.children = Lists.newArrayList(children);
    }

    public List<T> getOperations() {
        return children;
    }

    @Override
    public Iterator<T> iterator() {
        return children.iterator();
    }

    @Override
    long getElapsedTime() {

      val children = node.children!!
      var child = children[childIndex]
      if (child == null) {
        child = Node()
        children[childIndex] = child
      }
      node = child
    }

    val shift = 8 - accumulatorBitCount
    val start = (code shl shift) and 0xff
    val end = 1 shl shift
    node.children!!.fill(terminal, start, start + end)
  }

        if (children == null) {
            children = new HashSet<ProgressOperation>();
        }
        return children.add(operation);
    }

    public boolean removeChild(ProgressOperation operation) {
        if (children == null) {
            throw new IllegalStateException(String.format("Cannot remove child operation [%s] from operation with no children [%s]", operation, this));
        }

		}

		if pcok {
			pc.mu.Lock()
			if len(pc.children) != 1 || !contains(pc.children, cc) {
				t.Errorf("bad linkage: pc.children = %v, cc = %v", pc.children, cc)
			}
			pc.mu.Unlock()
		}

		cancel()

		if pcok {
			pc.mu.Lock()
			if len(pc.children) != 0 {
				t.Errorf("child's cancel didn't remove self from pc.children = %v", pc.children)
			}
			pc.mu.Unlock()
		}

        elementOrFailure {
            val children = tree.children(node)

            var identifier: Syntactic<String>? = null
            var expression: CheckedResult<ElementResult<Expr>>? = null
            children.forEach {
                when (val tokenType = it.tokenType) {
                    MODIFIER_LIST -> {
                        val modifiers = tree.children(it)
                        modifiers.forEach { modifier ->

			err(obj, alt)
		}
	}

	j := -1 // index of s in p.children
	for i, ch := range p.children {
		if ch == s {
			j = i
			break
		}
	}
	assert(j >= 0)
	k := len(p.children) - 1
	p.children[j] = p.children[k]
	p.children = p.children[:k]

	p.children = append(p.children, s.children...)

	s.children = nil
	s.elems = nil
}

			err(obj, alt)
		}
	}

	j := -1 // index of s in p.children
	for i, ch := range p.children {
		if ch == s {
			j = i
			break
		}
	}
	assert(j >= 0)
	k := len(p.children) - 1
	p.children[j] = p.children[k]
	p.children = p.children[:k]

	p.children = append(p.children, s.children...)

	s.children = nil
	s.elems = nil
}

        private final String prefix;
        private final List<Node> children;

        Node(String prefix) {
            this.prefix = prefix;
            this.children = ImmutableList.of();
        }

        public Node(String prefix, List<Node> children) {
            this.prefix = prefix;
            this.children = children;
        }

        Node plus(String path) {