//-------------------------------------------------------------------------------------------------------------------------------------------------
public static Operand <T> operator !(Operand <T> x)
{
if (TypeTemplate.Resolve <T>() == typeof(bool))
{
object result = new UnaryExpressionOperand <bool, bool>(
@operator: new UnaryOperators.OperatorLogicalNot(),
operand: (IOperand <bool>)x.OrNullConstant <T>());
return((Operand <T>)result);
}
else
{
throw new ArgumentException("Operator ! can only be applied to type Boolean.");
}
}
public void RegisterExpressionStatement_AddedToStatementList()
{
//-- Arrange
var statements = new StatementBlock();
var rootScope = new StatementScope(m_Class, m_Method, statements);
//-- Act
var expression = new UnaryExpressionOperand <int, int>(new UnaryOperators.OperatorNegation <int>(), new Constant <int>(111));
//-- Assert
Assert.That(statements.Count, Is.EqualTo(1));
Assert.That(statements[0], Is.InstanceOf <ExpressionStatement>());
Assert.That(((ExpressionStatement)statements[0]).Expression, Is.SameAs(expression));
}
public void RegisterExpressionAndContainingExpression_ContainedExpressionConsumed()
{
//-- Arrange
var statements = new StatementBlock();
var rootScope = new StatementScope(m_Class, m_Method, statements);
//-- Act
var innerExpression = new UnaryExpressionOperand <int, int>(new UnaryOperators.OperatorNegation <int>(), m_Method.TransparentWriter.Const(111));
var outerExpression = new UnaryExpressionOperand <int, int>(new UnaryOperators.OperatorPlus <int>(), innerExpression);
//-- Assert
Assert.That(statements.Count, Is.EqualTo(1));
Assert.That(statements[0], Is.InstanceOf <ExpressionStatement>());
Assert.That(((ExpressionStatement)statements[0]).Expression, Is.SameAs(outerExpression));
}
