*/
class DependencyConstraintsIntegrationTest extends AbstractPolyglotIntegrationSpec {
    private final String resolveName = 'resolve-fixture'
    private final ResolveTestFixture resolve = new ResolveTestFixture(testDirectory.file("${resolveName}.gradle"), "conf").expectDefaultConfiguration("runtime")

    def setup() {
        buildSpec {
            settings {
                rootProjectName = 'test'

				"common":    *spec.Int64Property(),
				"confusion": *confusionSchema,
			},
		},
	}}
}

type simpleActivation struct {
	foo any
	bar any
}

func (a *simpleActivation) ResolveName(name string) (interface{}, bool) {
	switch name {
	case "foo":
		return a.foo, true
	case "bar":
		return a.bar, true
	default:
		return nil, false
	}
}

type evaluationActivation struct {
	object, oldObject, params, request, namespace, authorizer, requestResourceAuthorizer, variables interface{}
}

// ResolveName returns a value from the activation by qualified name, or false if the name
// could not be found.
func (a *evaluationActivation) ResolveName(name string) (interface{}, bool) {
	switch name {
	case ObjectVarName:
		return a.object, true
	case OldObjectVarName:
		return a.oldObject, true

	if err != nil {
		return nil, nil, err
	}
	// TODO: change to NewExpressions after 1.28
	env, err := envSet.Env(environment.StoredExpressions)
	return env, variablesType, err
}

func (a *testActivation) ResolveName(name string) (any, bool) {
	switch name {
	case "variables":
		return a.variables, true
	default:
		return nil, false
	}
}

func (a *testActivation) Parent() interpreter.Activation {

            || resolveToOuter(type);
    }

    private boolean resolveFromResolver(ClassNode type, String name) {
        ClassNodeResolver.LookupResult result = classNodeResolver.resolveName(name, compilationUnit);
        if (result != null && result.isClassNode()) {
            type.setRedirect(result.getClassNode());
            return true;
        }
        return false;
    }

	res := &validationActivation{
		self: UnstructuredToVal(obj, sts),
	}
	return res, res
}

func (a *validationActivation) ResolveName(name string) (interface{}, bool) {
	switch name {
	case ScopedVarName:
		return a.self, true
	case OldScopedVarName:
		return a.oldSelf, a.hasOldSelf
	default:
		return nil, false
	}
}