// status is set and is an accepted value
	if !validConditionStatuses.Has(string(condition.Status)) {
		allErrs = append(allErrs, field.NotSupported(fldPath.Child("status"), condition.Status, validConditionStatuses.List()))
	}

	if condition.LastUpdateTime.IsZero() {
		allErrs = append(allErrs, field.Required(fldPath.Child("lastTransitionTime"), "must be set"))
	}

    def "produces reasonable error message when nested buildFile evaluation fails"() {
        createDirs("child")
        settingsFile << """
include 'child'
"""
        buildFile << """
    evaluationDependsOn 'child'
    task t
"""
        final childBuildFile = file("child/build.gradle")
        childBuildFile << """
    def broken = { ->
        throw new RuntimeException('failure')
    }

    public ModelRuleDescriptor append(ModelRuleDescriptor child) {
        return new NestedModelRuleDescriptor(this, child);
    }

    @Override
    public ModelRuleDescriptor append(String child) {
        return append(new SimpleModelRuleDescriptor(child));
    }

    @Override
    @FormatMethod
    public ModelRuleDescriptor append(@FormatString String child, Object... args) {
        return append(String.format(child, args));

    /**
     * Merges values from the specified parent model into the given child model. Implementations are expected to keep
     * parent and child completely decoupled by injecting deep copies of objects into the child rather than the original
     * objects from the parent.
     *
     * @param child The child model into which to merge the values inherited from the parent, must not be
     *            <code>null</code>.

		allErrs = append(allErrs, validateInstanceName(instanceName, idxPath.Child("name"))...)
		if instanceNames.Has(instanceName) {
			allErrs = append(allErrs, field.Duplicate(idxPath.Child("name"), instanceName))
		} else {
			instanceNames.Insert(instanceName)
		}
		allErrs = append(allErrs, validateAttributes(instance.Attributes, idxPath.Child("attributes"))...)
	}
	return allErrs
}

var (

        def configureBuildSrc = buildSrc.child({ it.startsWith("Configure build") })
        configureBuildSrc.child("Configure project :buildSrc")
        configureBuildSrc.child("Configure project :buildSrc:a")
        configureBuildSrc.child("Configure project :buildSrc:b")

        def buildSrcTasks = buildSrc.child({ it.startsWith("Run tasks") })

class DeferredTaskFailureIntegrationTest extends AbstractDeferredTaskDefinitionIntegrationTest {
    def "reports failure in task constructor when task realized"() {
        createDirs("child")
        settingsFile << """
            include "child"
        """
        file("child/build.gradle") << """
            class Broken extends DefaultTask {
                Broken() {
                    throw new RuntimeException("broken task")
                }

            dependenciesById.get(id).children = entry.getValue().collect {
                def child = dependenciesById.get(it)
                if (child == null) {
                    child = new TestResolvedDependency()
                    dependenciesById.put(it, child)
                }
                child
            } as Set
        }
        def root = dependenciesById.remove(0)

	w.varint(uint64(typ.PtrBytes))
	w.varint(uint64(len(typName)))
	w.stringData(typName)

	// Recursively walk all child nodes.
	for i := range node.children {
		child := node.children[i].Load()
		if child == nil {
			continue
		}
		w = dumpTypesRec((*traceMapNode)(child), w)
	}
	return w

    private val topLevelDeclarations: Sequence<KtDeclaration>
        get() {
            return sequence {
                for (child in kotlinFile.declarations) {
                    if (child is KtScript) {
                        yieldAll(child.declarations)
                    } else {
                        yield(child)
                    }
                }
            }
        }