public void testExecute_bitwiseOr_assertResults()
{
Assert.Equal((2 | 4), PolicyOperator <int, int> .BITWISE_OR.Execute(2, 4));
Assert.NotEqual((2 | 5), PolicyOperator <int, int> .BITWISE_OR.Execute(2, 4));
Assert.Equal((2 | 4), PolicyOperator.BitwiseOr(2, 4));
Assert.Equal("|", PolicyOperator.BitwiseOr <int, int>().GetOperatorToken());
}
public void TestExecute_LogicalOr_AssertResults()
{
OperatorBase equalsOperator = PolicyOperator.FromToken(("=_" + "Boolean_Boolean").GetHashCode());
equalsOperator.Should().NotBeNull();
Assert.True(PolicyOperator <bool> .LOGICAL_OR.Execute(true, true));
Assert.True(PolicyOperator <bool> .LOGICAL_OR.Execute(true, false));
Assert.True(PolicyOperator <bool> .LOGICAL_OR.Execute(false, true));
Assert.False(PolicyOperator <bool> .LOGICAL_OR.Execute(false, false));
}
public void TestEqualsFindTokenOperators()
{
OperatorBase equalsOperator = PolicyOperator.FromToken(("=_" + "Boolean_Boolean").GetHashCode());
equalsOperator.Should().NotBeNull();
equalsOperator = PolicyOperator.FromToken(("=_" + "Int32_Int32").GetHashCode());
equalsOperator.Should().NotBeNull();
equalsOperator = PolicyOperator.FromToken(("=_" + "String_String").GetHashCode());
equalsOperator.Should().NotBeNull();
}
public void TestGetInstance_AssertExpression()
{
IList <IPolicyExpression> operands = new List <IPolicyExpression>();
operands.Add(new LiteralPolicyExpression <bool>(true));
operands.Add(new LiteralPolicyExpression <bool>(false));
OperationPolicyExpression expression = new OperationPolicyExpression(PolicyOperator.BitwiseAnd <bool, bool>(), operands);
expression.Should().NotBeNull();
expression.GetPolicyOperator().Should().Be(PolicyOperator.BitwiseAnd <bool, bool>());
expression.GetExpressionType().Should().Be(PolicyExpressionType.OPERATION);
expression.GetOperands().ShouldBeEquivalentTo(operands);
}
public void Combine(IPolicyExpressionRoot right, PolicyOperator @operator)
{
if (right == null)
{
throw new ArgumentNullException(nameof(right));
}
PolicyExpressionWithOperator exp = new PolicyExpressionWithOperator(@operator, expression, right.Expression);
if (isPolicyOnly)
{
isPolicyOnly = false;
policyName = null;
}
expression = exp;
result = exp.Result;
}
public void TestExecute_NotEquals_Convertparamspecial_AssertResults()
{
Assert.False(PolicyOperator <Int64, Int64, bool> .NOT_EQUALS.Execute("00F74F1C4FE4E1762E".HexAsLong(), "f74f1c4fe4e1762e".HexAsLong()));
Assert.False(PolicyOperator <Int64, String, bool> .NOT_EQUALS.Execute("00F74F1C4FE4E1762E".HexAsLong(), "f74f1c4fe4e1762e"));
Assert.True(PolicyOperator <Int64, String, bool> .NOT_EQUALS.Execute("00F74F1C4FE4E17600".HexAsLong(), "f74f1c4fe4e1762e"));
Delegate del = PolicyOperator <Int64, String, bool> .NOT_EQUALS.ExecuteRef;
Assert.False((bool)del.DynamicInvoke(new object[] { "00F74F1C4FE4E1762E".HexAsLong(), "f74f1c4fe4e1762e" }));
Assert.True((bool)del.DynamicInvoke(new object[] { "00F74F1C4FE4E17600".HexAsLong(), "f74f1c4fe4e1762e" }));
var tokenHashCode = "!=_Int32_String".GetHashCode();
OperatorBase operatorBase = PolicyOperator.FromToken(tokenHashCode);
operatorBase.Should().NotBeNull();
}
public PolicyExpressionWithOperator(PolicyOperator @operator, IPolicyExpression left, IPolicyExpression right)
{
this.@operator = @operator;
this.left = left;
this.right = right;
PolicyResult leftResult = left.Result;
PolicyResult rightResult = right.Result;
switch (@operator)
{
case PolicyOperator.And:
this.result = AndOperation[(int)leftResult, (int)rightResult];
break;
case PolicyOperator.Or:
default:
this.result = OrOperation[(int)leftResult, (int)rightResult];
break;
}
}
/**
* Builds an aggregated {@link PolicyExpression} from a parsed list of tokens.
* @param tokens Parsed list of tokens used to build the {@link PolicyExpression}.
* @param level Used for keeping track of depth of operations.
* @return A {@link PolicyExpression} built from the parsed list of tokens.
* @throws PolicyParseException
*/
protected IPolicyExpression BuildExpression(IEnumerator <TokenTypeAssociation> tokens, bool operandFrame)
{
if (!tokens.MoveNext())
{
return(null);
}
IList <IPolicyExpression> builtOperandExpressions = new List <IPolicyExpression>();
do
{
TokenTypeAssociation assos = tokens.Current;
switch (assos.GetTokenType())
{
case TokenType.START_LEVEL:
{
IncrementLevel();
IPolicyExpression expression = BuildExpression(tokens);
if (operandFrame)
{
return(expression);
}
builtOperandExpressions.Add(expression);
break;
}
case TokenType.END_LEVEL:
if (GetLevel() == 0)
{
throw new PolicyGrammarException("To many \")\" tokens. Delete this token");
}
if (builtOperandExpressions.Count == 0)
{
throw new PolicyGrammarException("Group must contain at least one expression.");
}
DecrementLevel();
return(builtOperandExpressions[0]);
case TokenType.OPERATOR_BINARY_EXPRESSION:
case TokenType.OPERATOR_UNARY_EXPRESSION:
{
// regardless if this is a unary or binary expression, then next set of tokens should consist
// of a parameter to this operator
IPolicyExpression subExpression = BuildExpression(tokens, true);
int tokenHashCode = 0;
if (subExpression != null)
{
//TODO Refactor
if (assos.GetTokenType() == TokenType.OPERATOR_UNARY_EXPRESSION)
{
tokenHashCode = (assos.GetToken() + "_" + GetOperandType(subExpression)).GetHashCode();
}
if (assos.GetTokenType() == TokenType.OPERATOR_BINARY_EXPRESSION)
{
string leftOperandType = GetOperandType(builtOperandExpressions.First());
string rightOperandType = GetOperandType(subExpression);
tokenHashCode = (assos.GetToken() + "_" + leftOperandType + "_" + rightOperandType).GetHashCode();
}
}
else //(subExpression == null)
{
throw new PolicyGrammarException("Missing parameter. Operator must be followed by an expression.");
}
builtOperandExpressions.Add(subExpression);
// get the operator for this token
OperatorBase operatorBase = PolicyOperator.FromToken(tokenHashCode);
// now add the parameters to the operator
if (builtOperandExpressions.Count == 1 && operatorBase is BinaryOperator)
{
throw new PolicyGrammarException("Missing parameter. Binary operators require two parameters.");
}
IPolicyExpression operatorExpression = new OperationPolicyExpression(operatorBase, builtOperandExpressions);
if (operandFrame)
{
return(operatorExpression);
}
builtOperandExpressions = new List <IPolicyExpression>();
builtOperandExpressions.Add(operatorExpression);
break;
}
case TokenType.LITERAL_EXPRESSION:
{
IPolicyExpression expression = new LiteralPolicyExpression <string>(new PolicyValue <string>(assos.GetToken()));
if (operandFrame)
{
return(expression); // exit this operand frame
}
builtOperandExpressions.Add(expression);
break;
}
case TokenType.CERTIFICATE_REFERENCE_EXPRESSION:
{
IPolicyExpression expression = BuildCertificateReferenceField(assos.GetToken());
if (operandFrame)
{
return(expression); // exit this operand frame
}
builtOperandExpressions.Add(expression);
break;
}
}
} while(tokens.MoveNext());
if (builtOperandExpressions.Count > 1)
{
throw new PolicyGrammarException("Erroneous expression.");
}
return(builtOperandExpressions[0]);
}
