public void CloneTest()
{
var exp = new LessOrEqual(new Number(2), new Number(3));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public Dict(LessOrEqual leq)
{
_leq = leq;
_head = new Node { _key = null };
_head._prev = _head;
_head._next = _head;
}
public override bool Visit(LessOrEqual node)
{
traverse(node.left);
outputCode(" <= ", false, false);
traverse(node.right);
//Visit((LogicalBinaryExpression) node);
return(true);
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The result of analysis.</returns>
public string Analyze(LessOrEqual exp)
{
if (exp.Parent is BinaryExpression && !(exp.Parent is While))
{
return(ToString(exp, "({0} <= {1})"));
}
return(ToString(exp, "{0} <= {1}"));
}
public void CalculateLessFalseTest()
{
var parameters = new ParameterCollection {
new Parameter("x", 666)
};
var lessOrEqual = new LessOrEqual(Variable.X, new Number(10));
Assert.False((bool)lessOrEqual.Execute(parameters));
}
public void CalculateLessTrueTest2()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 10)
};
var lessThen = new LessOrEqual(Variable.X, new Number(10));
Assert.True((bool)lessThen.Execute(parameters));
}
public void CalculateLessFalseTest()
{
var parameters = new ParameterCollection()
{
new Parameter("x", 666)
};
var lessThen = new LessOrEqual(new Variable("x"), new Number(10));
Assert.Equal(false, lessThen.Execute(parameters));
}
public void Check_Whether_First_Is_Less_Than_Or_Equal_To_Second(object param1, object param2, bool expected)
{
// given
var sut = new LessOrEqual(param1, param2);
// when
var result = Evaluator.Evaluate(sut);
// then
Assert.Equal(expected, result);
}
public void Visit(LessOrEqual bin)
{
var left = bin.Left;
var right = bin.Right;
PrepareBinaryOperation(left, right);
Emit("cgt");
Emit($"ldc.{MiniType.Bool.ToPrimitive()} 0");
EmitStackDown("ceq");
}
public PriorityHeap(int initialSize, LessOrEqual leq)
{
_leq = leq;
_nodes = new int[initialSize + 1];
_handles = new HandleElem[initialSize + 1];
_size = 0;
_max = initialSize;
_freeList = 0;
_initialized = false;
_nodes[1] = 1;
_handles[1] = new HandleElem { _key = null };
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property == null)
{
return;
}
EditorGUI.BeginChangeCheck();
LessOrEqual greaterOrEqualAttribute = (LessOrEqual)attribute;
int intThreshold = greaterOrEqualAttribute.intThreshold;
float floatThreshold = greaterOrEqualAttribute.floatThreshold;
EditorGUI.PropertyField(position, property, label);
if (property.propertyType == SerializedPropertyType.Integer)
{
if (property.intValue > intThreshold)
{
property.intValue = intThreshold;
}
}
else
{
if (property.propertyType == SerializedPropertyType.Float)
{
if (property.floatValue > floatThreshold)
{
property.floatValue = floatThreshold;
}
}
}
if (EditorGUI.EndChangeCheck())
{
property.serializedObject.ApplyModifiedProperties();
}
}
public void Reset(int initialSize, LessOrEqual leq)
{
_leq = leq;
if (_nodes.Count < initialSize + 1)
{
_nodes.AddRange(new int[initialSize + 1 - _nodes.Count]);
}
if (_handles.Count < initialSize + 1)
{
_handles.AddRange(new HandleElem[initialSize + 1 - _handles.Count]);
}
_size = 0;
_max = initialSize;
_freeList = 0;
_initialized = false;
_nodes[1] = 1;
_handles[1] = new HandleElem {
_key = null
};
}
public void TestLessOrEqualUndefined()
{
var exp = new LessOrEqual(Variable.X, Variable.X);
Test(exp, ResultType.Undefined);
}
public InnerGenericDelegate(LessOrEqual leq)
{
_leq = leq;
}
public void LessOrEqualToString()
{
var exp = new LessOrEqual(new Number(5), new Number(5));
Assert.Equal("5 <= 5", exp.ToString(commoonFormatter));
}
public void TestLessOrEqualBoolNumberException()
{
var exp = new LessOrEqual(new Bool(true), new Number(10));
TestBinaryException(exp);
}
public void TestLessOrEqualNumber()
{
var exp = new LessOrEqual(new Number(10), new Number(10));
Test(exp, ResultType.Boolean);
}
public virtual T Visit(LessOrEqual node)
{
return(Visit((ComparisonBinaryExpression)node));
}
protected override EP_VP1 Visit(LessOrEqual node)
{
node.Children[1].Visit(this);
node.Children[0].Visit(this);
return(this);
}
internal protected virtual T Visit(LessOrEqual node)
{
return(Visit(node as Expression));
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>
/// The result of analysis.
/// </returns>
/// <exception cref="System.NotSupportedException">Always.</exception>
public virtual TResult Analyze(LessOrEqual exp)
{
throw new NotSupportedException();
}
public void SetLEQ(LessOrEqual leq)
{
_leq = leq;
}
public static ParamLessInstruction GetInstructionForOperator(
string operatorVal,
bool twoArg = true,
DatSymbolType leftSideType = DatSymbolType.Void)
{
ParamLessInstruction instruction = new ParamLessInstruction();
switch (operatorVal)
{
case "=":
instruction = GetAssignInstructionForDatSymbolType(leftSideType);
break;
case "+=":
instruction = new AssignAdd();
break;
case "-=":
instruction = new AssignSubtract();
break;
case "*=":
instruction = new AssignMultiply();
break;
case "/=":
instruction = new AssignDivide();
break;
case "+":
if (twoArg)
{
instruction = new Add();
}
else
{
instruction = new Plus();
}
break;
case "-":
if (twoArg)
{
instruction = new Subtract();
}
else
{
instruction = new Minus();
}
break;
case "<<":
instruction = new ShiftLeft();
break;
case ">>":
instruction = new ShiftRight();
break;
case ">":
instruction = new Greater();
break;
case ">=":
instruction = new GreaterOrEqual();
break;
case "<":
instruction = new Less();
break;
case "<=":
instruction = new LessOrEqual();
break;
case "==":
instruction = new Equal();
break;
case "!=":
instruction = new NotEqual();
break;
case "!":
instruction = new Not();
break;
case "~":
instruction = new Negate();
break;
case "*":
instruction = new Multiply();
break;
case "/":
instruction = new Divide();
break;
case "%":
instruction = new Modulo();
break;
case "&":
instruction = new BitAnd();
break;
case "|":
instruction = new BitOr();
break;
case "&&":
instruction = new LogAnd();
break;
case "||":
instruction = new LogOr();
break;
}
if (instruction == null)
{
throw new Exception($"'{operatorVal}' does't have insctruction");
}
return(instruction);
}
public void CalculateInvalidTypeTest()
{
var lessOrEqual = new LessOrEqual(new Bool(true), new Bool(true));
Assert.Throws <ResultIsNotSupportedException>(() => lessOrEqual.Execute());
}
//-----------------------------------------------------------
public Type Visit(LessOrEqual node)
{
VisitBinaryNumericOperator(".le.", node);
return(Type.LOGICAL);
}
public override bool Visit(LessOrEqual node)
{
Visit((ComparisonBinaryExpression)node);
return(true);
}
public void TestLessOrEqualException()
{
var exp = new LessOrEqual(new Bool(true), new Bool(false));
TestException(exp);
}
