Example #1
0
        public void AndOrNotTestWithQuotedStrings()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse(
                "(R:\"Human Resources\" OR R:\"General Managers\") AND NOT R:\"HR Specialist\"");

            Assert.AreEqual(typeof(AndOperator), expression.GetType());
            AndOperator andOperator = (AndOperator)expression;

            Assert.AreEqual(typeof(OrOperator), andOperator.Left.GetType());
            OrOperator orOperator = (OrOperator)andOperator.Left;

            Assert.AreEqual(typeof(RoleExpression), orOperator.Left.GetType());
            RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;

            Assert.AreEqual("Human Resources", hrRoleExpression.Word.Value);
            Assert.AreEqual(typeof(RoleExpression), orOperator.Right.GetType());
            RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;

            Assert.AreEqual("General Managers", gmRoleExpression.Word.Value);
            Assert.AreEqual(typeof(NotOperator), andOperator.Right.GetType());
            NotOperator notOperator = (NotOperator)andOperator.Right;

            Assert.AreEqual(typeof(RoleExpression), notOperator.Expression.GetType());
            RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;

            Assert.AreEqual("HR Specialist", specialistRoleExpression.Word.Value);
        }
Example #2
0
        public void RoleExpressionTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("R:Managers");

            Assert.AreEqual(typeof(RoleExpression), expression.GetType());
            RoleExpression roleExpression = (RoleExpression)expression;
        }
Example #3
0
        public void AndNotTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse("R:Managers AND NOT I:Bob");

            AndOperator andOperator = (AndOperator)expression;

            RoleExpression roleExpression = (RoleExpression)andOperator.Left;

            Assert.AreEqual("Managers", roleExpression.Word.Value);

            NotOperator notOperator = (NotOperator)andOperator.Right;

            IdentityExpression identityExpression = (IdentityExpression)notOperator.Expression;

            Assert.AreEqual("Bob", identityExpression.Word.Value);
        }
Example #4
0
        public void AndOrNotTest()
        {
            Parser            parser     = new Parser();
            BooleanExpression expression = parser.Parse(
                "(R:HumanSR OR R:GeneralManagers) AND NOT R:HRSpecialist");

            AndOperator andOperator = (AndOperator)expression;

            OrOperator orOperator = (OrOperator)andOperator.Left;

            RoleExpression hrRoleExpression = (RoleExpression)orOperator.Left;

            Assert.AreEqual("HumanSR", hrRoleExpression.Word.Value);

            RoleExpression gmRoleExpression = (RoleExpression)orOperator.Right;

            Assert.AreEqual("GeneralManagers", gmRoleExpression.Word.Value);

            NotOperator notOperator = (NotOperator)andOperator.Right;

            RoleExpression specialistRoleExpression = (RoleExpression)notOperator.Expression;

            Assert.AreEqual("HRSpecialist", specialistRoleExpression.Word.Value);
        }
        public void WordTest()
        {
            RoleExpression expression = new RoleExpression("Role1");

            Assert.AreEqual(typeof(WordExpression), expression.Word.GetType());
        }
        public void AnyTest()
        {
            RoleExpression expression = new RoleExpression("*");

            Assert.AreEqual(typeof(AnyExpression), expression.Word.GetType());
        }
        public void FalseTest()
        {
            RoleExpression expression = new RoleExpression("Admin");

            Assert.IsFalse(expression.Evaluate(this.principal));
        }
        public void TrueTest()
        {
            RoleExpression expression = new RoleExpression("Manager");

            Assert.IsTrue(expression.Evaluate(this.principal));
        }
 public void WordTest()
 {
     RoleExpression expression = new RoleExpression("Role1");
     Assert.AreEqual(typeof(WordExpression), expression.Word.GetType());
 }
 public void AnyTest()
 {
     RoleExpression expression = new RoleExpression("*");
     Assert.AreEqual(typeof(AnyExpression), expression.Word.GetType());
 }
 public void FalseTest()
 {
     RoleExpression expression = new RoleExpression("Admin");
     Assert.IsFalse(expression.Evaluate(principal));
 }
 public void TrueTest()
 {
     RoleExpression expression = new RoleExpression("Manager");
     Assert.IsTrue(expression.Evaluate(principal));
 }