Пример #1
0
        public void VerifyCreateExclusiveOrExpression()
        {
            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual(0, vm.Expression.Single().ContainedRows.Count);

            var relationalExpression2 = new RelationalExpression(Guid.NewGuid(), this.cache, this.uri);

            this.exclusiveOrExpression.Term.Add(this.relationalExpression);
            this.exclusiveOrExpression.Term.Add(relationalExpression2);
            this.parametricConstraint.Expression.Add(relationalExpression2);
            this.parametricConstraint.Expression.Add(this.exclusiveOrExpression);

            vm.CreateExclusiveOrExpression.Execute(null);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual("XOR", vm.Expression.Single().Thing.StringValue);
            Assert.AreEqual(2, vm.Expression.Single().ContainedRows.Count);
            Assert.AreEqual(this.relationalExpression, vm.Expression.Single().ContainedRows.First().Thing);
            Assert.AreEqual(relationalExpression2, vm.Expression.Single().ContainedRows.Last().Thing);
            Assert.AreEqual(this.exclusiveOrExpression, vm.SelectedTopExpression);
            Assert.IsTrue(vm.OkCanExecute);
        }
Пример #2
0
        public void VerifyCreateNotExpression()
        {
            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual(0, vm.Expression.Single().ContainedRows.Count);

            this.notExpression.Term = this.relationalExpression;
            this.parametricConstraint.Expression.Add(this.notExpression);

            vm.CreateNotExpression.Execute(null);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual("NOT", vm.Expression.Single().Thing.StringValue);
            Assert.AreEqual(1, vm.Expression.Single().ContainedRows.Count);
            Assert.AreEqual(this.relationalExpression, vm.Expression.Single().ContainedRows.Single().Thing);
            Assert.AreEqual(this.notExpression, vm.SelectedTopExpression);
            Assert.IsTrue(vm.OkCanExecute);
        }
Пример #3
0
        public void VerifyCreateRelationalExpression()
        {
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));
            this.mrdl.ParameterType.Add(new SimpleQuantityKind(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "test"
            });

            this.parametricConstraint.Expression.Clear();
            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(0, vm.Expression.Count);
            this.parametricConstraint.Expression.Add(this.relationalExpression);
            vm.CreateRelationalExpression.Execute(null);
            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual(this.relationalExpression, vm.SelectedTopExpression);
            Assert.IsTrue(vm.OkCanExecute);
        }
        public void VerifyCreateNestedBooleanExpression()
        {
            var relationalExpression2 = new RelationalExpression(Guid.NewGuid(), this.cache, this.uri);

            relationalExpression2.ParameterType = new BooleanParameterType();
            var relationalExpression3 = new RelationalExpression(Guid.NewGuid(), this.cache, this.uri);

            relationalExpression3.ParameterType = new BooleanParameterType();
            this.exclusiveOrExpression.Term.Add(relationalExpression2);
            this.exclusiveOrExpression.Term.Add(relationalExpression3);
            this.notExpression.Term = this.relationalExpression;
            this.andExpression.Term.Add(this.notExpression);
            this.andExpression.Term.Add(this.exclusiveOrExpression);
            this.parametricConstraint.Expression.Add(relationalExpression2);
            this.parametricConstraint.Expression.Add(relationalExpression3);
            this.parametricConstraint.Expression.Add(this.notExpression);
            this.parametricConstraint.Expression.Add(this.exclusiveOrExpression);
            this.parametricConstraint.Expression.Add(this.andExpression);

            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual(2, vm.Expression.Single().ContainedRows.Count);

            // Check that we get the following tree structure
            // AND
            //  |_ NOT
            //  |   |_ this.relationalExpression
            //  |
            //  |_ XOR
            //      |- relationalExpression2
            //      |_ relationalExpression3

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.AreEqual("AND", vm.Expression.Single().Thing.StringValue);
            Assert.AreEqual(2, vm.Expression.Single().ContainedRows.Count);
            var notNode = vm.Expression.Single().ContainedRows.First();
            var andNode = vm.Expression.Single().ContainedRows.Last();

            Assert.AreEqual(this.notExpression, notNode.Thing);
            Assert.AreEqual(this.exclusiveOrExpression, andNode.Thing);
            Assert.AreEqual(1, notNode.ContainedRows.Count);
            Assert.AreEqual(this.relationalExpression, notNode.ContainedRows.Single().Thing);
            Assert.AreEqual(2, andNode.ContainedRows.Count);
            Assert.AreEqual(relationalExpression2, andNode.ContainedRows.First().Thing);
            Assert.AreEqual(relationalExpression3, andNode.ContainedRows.Last().Thing);
            Assert.AreEqual(this.andExpression, vm.SelectedTopExpression);
            Assert.IsTrue(vm.OkCanExecute);
        }
Пример #5
0
        public void VerifyThatPropertiesAreSet()
        {
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));
            this.mrdl.ParameterType.Add(new SimpleQuantityKind(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "test"
            });

            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
        }
Пример #6
0
        public void VerifyReactiveCommandsCanExecute()
        {
            this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
            this.session.Setup(x => x.ActivePerson).Returns(new Person(Guid.NewGuid(), null, this.uri));
            this.mrdl.ParameterType.Add(new SimpleQuantityKind(Guid.NewGuid(), null, this.uri)
            {
                ShortName = "test"
            });

            var vm = new ParametricConstraintDialogViewModel(
                this.parametricConstraint,
                this.thingTransaction,
                this.session.Object,
                true,
                ThingDialogKind.Create,
                this.thingDialogNavigationService.Object,
                this.clone);

            Assert.AreEqual(1, vm.Expression.Count);
            Assert.IsNull(vm.SelectedExpression);
            Assert.IsTrue(vm.CreateNotExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateAndExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateOrExpression.CanExecute(null));
            Assert.IsFalse(vm.CreateExclusiveOrExpression.CanExecute(null));

            vm.SelectedExpression = vm.Expression.First();

            var relationalExpression2   = new RelationalExpression(Guid.NewGuid(), this.cache, this.uri);
            var relationalExpressionRow = new RelationalExpressionRowViewModel(
                relationalExpression2,
                this.session.Object,
                vm);

            vm.Expression.Add(relationalExpressionRow);
            vm.BooleanExpression.Add(relationalExpressionRow.Thing);

            Assert.IsTrue(vm.CreateAndExpression.CanExecute(null));
            Assert.IsTrue(vm.CreateOrExpression.CanExecute(null));
            Assert.IsTrue(vm.CreateExclusiveOrExpression.CanExecute(null));
        }