assertDependencyMetaDataReadTimeout(moduleA)
        failure.assertHasErrorOutput("There are 2 more failures with identical causes.")
        outputDoesNotContain("Could not resolve ${mavenModuleCoordinates(moduleD)}")
        outputDoesNotContain("Could not resolve ${mavenModuleCoordinates(moduleE)}")
        !downloadedLibsDir.isDirectory()

		}

	case *Interface:
		if w.ctxt == nil {
			if t == universeAnyAlias.Type().Underlying() {
				// When not hashing, we can try to improve type strings by writing "any"
				// for a type that is pointer-identical to universeAny.
				// TODO(rfindley): this logic should not be necessary with
				// gotypesalias=1. Remove once that is always the case.
				w.string("any")
				break
			}

	OpConcat                       // matches concatenation of Subs
	OpAlternate                    // matches alternation of Subs
)

const opPseudo Op = 128 // where pseudo-ops start

// Equal reports whether x and y have identical structure.
func (x *Regexp) Equal(y *Regexp) bool {
	if x == nil || y == nil {
		return x == y
	}
	if x.Op != y.Op {
		return false
	}
	switch x.Op {
	case OpEndText:

			// clusterID must be unique even across multiple secrets
			kubeConfigSha := sha256.Sum256(kubeConfig)
			if bytes.Equal(kubeConfigSha[:], prev.kubeConfigSha[:]) {
				logger.Infof("skipping update (kubeconfig are identical)")
				continue
			}
			// stop previous remote cluster
			prev.Stop()
		} else if c.cs.Contains(cluster.ID(clusterID)) {
			// if the cluster has been registered before by another secret, ignore the new one.

	if l.Type() == nil || r.Type() == nil {
		return l, r, nil
	}
	t := l.Type()
	if t.Kind() == types.TIDEAL {
		t = r.Type()
	}
	aop := ir.OXXX
	if n.Op().IsCmp() && t.Kind() != types.TIDEAL && !types.Identical(l.Type(), r.Type()) {
		// comparison is okay as long as one side is
		// assignable to the other.  convert so they have
		// the same type.
		//
		// the only conversion that isn't a no-op is concrete == interface.

			If("p", blockn(i+1), "exit")))
	}

	blocs = append(blocs,
		Bloc(blockn(size), Goto("exit")),
		Bloc("exit", Exit("mem")),
	)

	return blocs
}

// genMaxPredValue is identical to genMaxPred but contains an
// additional value.
func genMaxPredValue(size int) []bloc {
	var blocs []bloc
	blocs = append(blocs,
		Bloc("entry",
			Valu("mem", OpInitMem, types.TypeMem, 0, nil),

	}
	testCases := []struct {
		name        string
		expected    *flowcontrolv1.PriorityLevelConfiguration
		actual      *flowcontrolv1.PriorityLevelConfiguration
		specChanged bool
	}{
		{
			name:        "identical priority-level should work",
			expected:    bootstrap.MandatoryPriorityLevelConfigurationCatchAll,
			actual:      bootstrap.MandatoryPriorityLevelConfigurationCatchAll,
			specChanged: false,
		},
		{

				// one that may be generated for the service as the default route, do not generate it.
				// Otherwise, Envoy will complain about having filter chains with identical matches
				// and will reject the config.
				sort.Strings(virtualServiceDestinationSubnets)
				sort.Strings(destinationCIDRs)
				if slices.Equal(virtualServiceDestinationSubnets, destinationCIDRs) {

			name2, offset2 := t2.Zone()
			return t1.Equal(t2) && name1 == name2 && offset1 == offset2
		}

		for _, tz := range []*Location{UTC, Local} {
			// Parsing as RFC3339 or RFC3339Nano should be identical.
			t1, err1 := ParseAny(RFC3339, s, UTC, tz)
			t2, err2 := ParseAny(RFC3339Nano, s, UTC, tz)
			switch {
			case (err1 == nil) != (err2 == nil):

			Conditions:     setConditions(obj.Generation, currentConditions, conds),
		})
	}
	// Ensure output is deterministic.
	// TODO: will we fight over other controllers doing similar (but not identical) ordering?
	sort.SliceStable(parents, func(i, j int) bool {
		return parentRefString(parents[i].ParentRef) > parentRefString(parents[j].ParentRef)
	})
	return parents
}

type ParentErrorReason string