public void Equality_Default()
        {
            var a = new ComposedExpression();
            var b = new ComposedExpression();

            Assert.AreEqual(a, b);
            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
        }
        public void SettingValues()
        {
            var sut = new ComposedExpression {
                References = Refs("a")
            };

            Assert.AreEqual(Refs("a"), sut.References);
        }
        public void DefaultValues()
        {
            var sut = new ComposedExpression();

            Assert.AreEqual(Lists.NewList <IVariableReference>(), sut.References);
            Assert.AreNotEqual(0, sut.GetHashCode());
            Assert.AreNotEqual(1, sut.GetHashCode());
        }
        public void ComposedExpression()
        {
            var actual   = SSTUtil.ComposedExpression("a", "b");
            var expected = new ComposedExpression {
                References = Lists.NewList(Ref("a"), Ref("b"))
            };

            Assert.AreEqual(expected, actual);
        }
        public void Equality_DifferentReferences()
        {
            var a = new ComposedExpression {
                References = Refs("a")
            };
            var b = new ComposedExpression {
                References = Refs("b")
            };

            Assert.AreNotEqual(a, b);
            Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
        }
        public void Equality_ReallyTheSame()
        {
            var a = new ComposedExpression {
                References = Refs("a")
            };
            var b = new ComposedExpression {
                References = Refs("a")
            };

            Assert.AreEqual(a, b);
            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
        }
        public void ComposedExpression()
        {
            var sst = new ComposedExpression
            {
                References =
                {
                    SSTUtil.VariableReference("a"),
                    SSTUtil.VariableReference("b"),
                    SSTUtil.VariableReference("c")
                }
            };

            AssertPrint(sst, "composed(a, b, c)");
        }
Exemple #8
0
        private FilterExpression GetExportFilter()
        {
            PicklistItem i1 = new PicklistItem("Sample field");
            MultiplePicklistFieldValue v1 = new MultiplePicklistFieldValue("yes");

            v1.Add(i1);
            AtomicExpression e1 = new AtomicExpression(v1, AtomicExpression.Operator.Contains);

            MultipleStringFieldValue v2 = new MultipleStringFieldValue("Sample text field");

            v2.Add("new item");
            AtomicExpression e2 = new AtomicExpression(v2, AtomicExpression.Operator.Contains);

            ComposedExpression filter = new ComposedExpression(e1, ComposedExpression.Operator.Or, e2);

            return(filter);
        }
        private FilterExpression GetFilterAdvanced()
        {
            #region "AdvancedCriterion1"
            PicklistItem fieldName1 = new PicklistItem("Customer");
            MultiplePicklistFieldValue fieldValue1 = new MultiplePicklistFieldValue("Microsoft");
            fieldValue1.Add(fieldName1);
            AtomicExpression expression1 = new AtomicExpression(fieldValue1, AtomicExpression.Operator.Equal);
            #endregion

            #region "AdvancedCriterion2"
            MultipleStringFieldValue fieldName2 = new MultipleStringFieldValue("Project id");
            fieldName2.Add("2010");
            AtomicExpression expression2 = new AtomicExpression(fieldName2, AtomicExpression.Operator.Contains);
            #endregion

            #region "AdvancedFilter"
            ComposedExpression filter = new ComposedExpression(expression1, ComposedExpression.Operator.Or, expression2);
            return(filter);

            #endregion
        }
        public void VisitorWithReturnIsImplemented()
        {
            var sut = new ComposedExpression();

            sut.Accept(23).VerifyWithReturn(v => v.Visit(sut, 23));
        }