Esempio n. 1
0
        public void AddType()
        {
            var x        = new WTF.TypeProblem2(new TestScopeConverter());
            var hello    = x.CreateType(x.Root, new NameKey("Hello"), new TestExplictTypeConverter());
            var hello_x  = x.CreateMember(hello, new NameKey("x"), new TestMemberConverter(new NameKey("x")));
            var hello_y  = x.CreateMember(hello, new NameKey("y"), new TestMemberConverter(new NameKey("y")));
            var solution = x.Solve(new TestExplictTypeConverter());

            var resultHello = solution.GetExplicitType(hello).GetValue();

            HasCount(2, resultHello);
            HasMember(resultHello, new NameKey("x"));
            HasMember(resultHello, new NameKey("y"));
        }
Esempio n. 2
0
        public void AddMethod()
        {
            var x = new WTF.TypeProblem2(new TestScopeConverter());

            var hello   = x.CreateType(x.Root, new NameKey("hello"), new TestExplictTypeConverter());
            var hello_x = x.CreateMember(hello, new NameKey("x"), new TestMemberConverter(new NameKey("x")));
            var hello_y = x.CreateMember(hello, new NameKey("y"), new TestMemberConverter(new NameKey("y")));

            var input  = x.CreateValue(x.Root, new NameKey("hello"), new TestValueConverter());
            var method = x.CreateMethod(x.Root, "input", new TestMethodConverter(), new TestMemberConverter(new NameKey("input")), new TestMemberConverter(new NameKey("result")));

            var input_x = x.CreateHopefulMember(method.Input(), new NameKey("x"), new TestMemberConverter(new NameKey("x")));
            var input_y = x.CreateHopefulMember(method.Input(), new NameKey("y"), new TestMemberConverter(new NameKey("y")));

            var method_x = x.CreateMember(method, new NameKey("x"), new TestMemberConverter(new NameKey("x")));
            var method_y = x.CreateMember(method, new NameKey("y"), new TestMemberConverter(new NameKey("y")));

            input_x.AssignTo(method_x);
            input_y.AssignTo(method_y);

            method.Input().AssignTo(method.Returns());

            input.AssignTo(method.Input());

            var result = x.Solve(new TestExplictTypeConverter());

            var methodResult = result.GetMethod(method).GetValue();

            HasCount(4, methodResult);
            HasMember(methodResult, new NameKey("x"));
            HasMember(methodResult, new NameKey("y"));
            var inputResult = MemberToType(HasMember(methodResult, new NameKey("input")));

            HasCount(2, inputResult);
            HasMember(inputResult, new NameKey("x"));
            HasMember(inputResult, new NameKey("y"));

            var helloResult = result.GetExplicitType(hello).GetValue();

            HasCount(2, helloResult);
            HasMember(helloResult, new NameKey("x"));
            HasMember(helloResult, new NameKey("y"));

            // things don't flow downstream
            var methodReturns = MemberToType(result.GetMember(method.Returns()).GetValue());

            HasCount(0, methodReturns);
        }