public void DigitalWrite(CInterpreter state)
{
var pin = state.ReadArg(0).Int16Value;
var value = state.ReadArg(1).Int16Value;
Pins[pin].DigitalValue = value;
}
public void TestReadInput_TryReadEmptyInputArray_ReturnsEmptyArray()
{
IInterpreter interpreter = new CInterpreter();
int[] testValue = new int[] { 5 };
/*program looks like
* t <- [int]
*/
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("t", new CReadInputASTNode(new CValueASTNode(new int[] { 0 })))
});
int[][] inputData = new int[1][];
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
Assert.AreEqual(result, CIntrinsicsUtils.mNullArray);
});
}
static void AssertU16AreEqual(CInterpreter state)
{
var expected = state.ReadArg(0);
var actual = state.ReadArg(1);
Assert.AreEqual((ushort)expected, (ushort)actual);
}
static void AssertBoolsAreEqual(CInterpreter state)
{
var expected = state.ReadArg(0);
var actual = state.ReadArg(1);
Assert.AreEqual((int)expected, (int)actual);
}
public void TestEval_TestReadArbitraryParameter_ReturnsReadParameter(int index)
{
IInterpreter interpreter = new CInterpreter();
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("x", new CReadInputASTNode(new CValueASTNode(new int[] { index })))
});
int[][] inputData = new int[][]
{
new int[] { 4 }, //x
};
int[] expectedResult = new int[] { 2, 2, 2, 2 };
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
if (index < inputData.Length)
{
Assert.AreEqual(result.Length, 1);
Assert.AreEqual(inputData[index][0], result[0]);
}
else
{
Assert.AreSame(CIntrinsicsUtils.mNullArray, result);
}
});
}
static void AssertFloatsAreEqual(CInterpreter state)
{
var expected = state.ReadArg(0);
var actual = state.ReadArg(1);
Assert.AreEqual((float)expected, (float)actual, 1.0e-6);
}
public void TestEval_TestPassArrayAsIfVar_ShouldProcessCorrectlyWithoutExceptions()
{
IInterpreter interpreter = new CInterpreter(E_INTERPRETER_ATTRIBUTES.IA_IS_SAFE_DIVISION_ENABLED);
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("x", new CIfThenElseASTNode(new CReadInputASTNode(new CValueASTNode(new int[] { 0 })),
new CLambdaPredicateASTNode(E_LOGIC_OP_TYPE.LOT_NEQ, new CValueASTNode(new int[] { -8 }), null),
new CValueASTNode(new int[] { 0 }),
new CValueASTNode(new int[] { -1 })))
});
int[][] inputData = new int[][]
{
new int[] { 4 }, //x
};
int[] expectedResult = new int[] { 2, 2, 2, 2 };
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
});
}
public void PinMode(CInterpreter state)
{
var pin = state.ReadArg(0).Int16Value;
var mode = state.ReadArg(1).Int16Value;
Pins[pin].Mode = mode;
}
public void TestIfStatement_FalseCondition_ReturnsEvaluatedExpressionOfChosenBranch()
{
IInterpreter interpreter = new CInterpreter();
int[] testValue = new int[] { 5 };
/*program looks like
* t <- 5
* r <- if t (!= 5) then 5 else -1
*/
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("t", new CValueASTNode(testValue)),
new CAssignmentASTNode("r", new CIfThenElseASTNode(new CIdentifierASTNode("t"),
new CLambdaPredicateASTNode(E_LOGIC_OP_TYPE.LOT_NEQ, new CValueASTNode(testValue), null),
new CValueASTNode(testValue),
new CValueASTNode(new int[] { -1 })))
});
int[][] inputData = new int[3][];
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
Assert.AreEqual(result.Length, 1);
Assert.AreEqual(result[0], -1);
});
}
public void AnalogRead(CInterpreter state)
{
var pin = state.ReadArg(0).Int16Value;
var value = Pins[pin].AnalogValue;
state.Push(value);
}
static void AssertDoublesAreEqual(CInterpreter state)
{
var expected = state.ReadArg(0);
var actual = state.ReadArg(1);
Assert.AreEqual((double)expected, (double)actual, 1.0e-12);
}
public void DigitalRead(CInterpreter state)
{
var pin = state.ReadArg(0).Int16Value;
var value = Pins[pin].DigitalValue;
state.Push(value);
}
public void TestEval_TestSafeDivisionOption_ReturnsCorrectDivisionResult()
{
IInterpreter interpreter = new CInterpreter(E_INTERPRETER_ATTRIBUTES.IA_IS_SAFE_DIVISION_ENABLED);
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("x", new CCallASTNode(E_INTRINSIC_FUNC_TYPE.IFT_MAP, new List <IASTNode>()
{
new CUnaryLambdaFuncASTNode(E_OPERATION_TYPE.OT_DIV, new CValueASTNode(new int[] { 0 })),
new CValueASTNode(new int[] { 0, 1, 2, 3, 4 })
}))
});
int[][] inputData = new int[][]
{
new int[] { 4 }, //x
};
int[] expectedResult = new int[] { 2, 2, 2, 2 };
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
});
}
public void TestEval_TestReferencingByIdentifierInExpr_ReturnsValueStoredWithinVar()
{
IInterpreter interpreter = new CInterpreter();
/*program looks like
* x <- int
* y <- IF x (> 0) THEN x ELSE NULL
*/
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("x", new CReadInputASTNode(new CValueASTNode(new int[] { 0 }))),
new CAssignmentASTNode("z", new CIfThenElseASTNode(new CIdentifierASTNode("x", E_NODE_ATTRIBUTES.NA_ID_SHOULD_EXIST),
new CLambdaPredicateASTNode(E_LOGIC_OP_TYPE.LOT_GT, new CValueASTNode(new int[] { 0 }), null),
new CIdentifierASTNode("x", E_NODE_ATTRIBUTES.NA_ID_SHOULD_EXIST),
new CValueASTNode(CIntrinsicsUtils.mNullArray)))
});
int[][] inputData = new int[][]
{
new int[] { 4 }, //x
};
int[] expectedResult = new int[] { 2, 2, 2, 2 };
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
Assert.AreEqual(result.Length, 1);
Assert.AreEqual(inputData[0][0], result[0]);
});
}
public void TestVisitLValueIdentifierNode_CorrectArgument_ReturnsName()
{
IVisitor <Object> interpreter = new CInterpreter();
IIdentifierASTNode identifierNode = new CIdentifierASTNode("TestId", E_NODE_ATTRIBUTES.NA_LVALUE);
var result = interpreter.VisitIdentifierNode(identifierNode);
Assert.AreEqual(result, identifierNode.Name);
}
public void TestVisitValueNode_CorrectArgument_ReturnsName()
{
IVisitor <Object> interpreter = new CInterpreter();
IValueASTNode valueNode = new CValueASTNode(new int[] { 1, 2 });
var result = interpreter.VisitValueNode(valueNode);
Assert.AreEqual(result, valueNode.Value);
}
static void AssertAreEqual(CInterpreter state)
{
var expected = state.ReadArg(0).Int16Value;
var actual = state.ReadArg(1).Int16Value;
if (expected != actual)
{
Console.WriteLine($"{expected} != {actual}");
}
//Assert.AreEqual ((short)expected, (short)actual);
}
//[TestCase(E_OPERATION_TYPE.OT_POW, 3, 2, 9)] works only for double, need to find some trick to implement it
public void TestVisitBinaryLambdaFuncNode_CheckLambdaFunctorGeneration_ReturnsLambdaFunctor(E_OPERATION_TYPE type, int x, int y, int res)
{
IVisitor <Object> interpreter = new CInterpreter();
Func <int, int, int> lambdaFunctor = null;
Assert.DoesNotThrow(() => {
lambdaFunctor = (Func <int, int, int>)interpreter.VisitBinaryLambdaFuncNode(new CBinaryLambdaFuncASTNode(type));
});
Assert.AreEqual(res, lambdaFunctor(x, y));
}
string ReadString(int pi, CInterpreter state)
{
var b = (byte)state.ReadMemory(pi);
var bytes = new List <byte> ();
while (b != 0)
{
bytes.Add(b);
pi++;
b = (byte)state.ReadMemory(pi);
}
return(Encoding.UTF8.GetString(bytes.ToArray()));
}
public void TestVisitUnaryLambdaFuncNode_CheckSimpleLambdaPredicateGeneration_ReturnsLambdaPredicate(E_OPERATION_TYPE type, int x, int value, int res)
{
IVisitor <Object> interpreter = new CInterpreter();
Func <int, int> lambdaFunctor = null;
Assert.DoesNotThrow(() => {
lambdaFunctor = (Func <int, int>)interpreter.VisitUnaryLambdaFuncNode(
new CUnaryLambdaFuncASTNode(type, new CValueASTNode(new int[] { value })));
});
Assert.AreEqual(res, lambdaFunctor(x));
}
public void TestVisitLambdaPredicateNode_CheckLambdaPredicateGeneration_ReturnsLambdaPredicate(E_LOGIC_OP_TYPE type, int x, int value, bool res)
{
IVisitor <Object> interpreter = new CInterpreter();
Func <int, bool> lambdaPredicate = null;
Assert.DoesNotThrow(() => {
lambdaPredicate = (Func <int, bool>)interpreter.VisitLambdaPredicateNode(
new CLambdaPredicateASTNode(type, new CValueASTNode(new int[] { value }), null));
});
Assert.AreEqual(res, lambdaPredicate(x));
}
public void TestEval_NullArguments_ThrowsNullArgumentException()
{
IInterpreter interpreter = new CInterpreter();
IASTNode program = new CProgramASTNode();
int[][] input = new int[1][];
IInputStream inputStream = new CInputStream(input);
Assert.Throws <ArgumentNullException>(() => { interpreter.Eval(program, null); });
Assert.Throws <ArgumentNullException>(() => { interpreter.Eval(null, inputStream); });
}
public void TestVisitCallNode_SimpleProgram_ReturnsValue()
{
IInterpreter interpreter = new CInterpreter();
int[][] inputData = new int[3][];
int[] testArray = new int[] { 5, 4, -3, 1 };
int sum = 0;
foreach (int unit in testArray)
{
sum += unit;
}
int[] expectedValue = new int[] { testArray[0], sum };
// simple program that returns a sum of length and a first element of an array
// program's code looks like this
// a <- [5, 4, -3, 1]
// t <- head a
// s <- sum a
// r <- concat t s
IASTNode program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("a", new CValueASTNode(testArray)),
new CAssignmentASTNode("t", new CCallASTNode(E_INTRINSIC_FUNC_TYPE.IFT_HEAD, new List <IASTNode>()
{
new CIdentifierASTNode("a")
})),
new CAssignmentASTNode("s", new CCallASTNode(E_INTRINSIC_FUNC_TYPE.IFT_SUM, new List <IASTNode>()
{
new CIdentifierASTNode("a")
})),
new CAssignmentASTNode("r", new CCallASTNode(E_INTRINSIC_FUNC_TYPE.IFT_CONCAT, new List <IASTNode>()
{
new CIdentifierASTNode("t"), new CIdentifierASTNode("s")
}))
});
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() => {
var result = interpreter.Eval(program, inputStream);
for (int i = 0; i < result.Length; ++i)
{
Assert.AreEqual(expectedValue[i], result[i]);
}
});
}
public void TestVisitLambdaPredicateNode_CheckModuloComparisonLambdaPredicate_ReturnsLambdaPredicate(int x, int value, int secondOp, bool res)
{
IVisitor <Object> interpreter = new CInterpreter();
Func <int, bool> lambdaPredicate = null;
Assert.DoesNotThrow(() => {
lambdaPredicate = (Func <int, bool>)interpreter.VisitLambdaPredicateNode(
new CLambdaPredicateASTNode(E_LOGIC_OP_TYPE.LOT_MOD, new CValueASTNode(new int[] { value }),
new CValueASTNode(new int[] { secondOp })));
});
Assert.AreEqual(res, lambdaPredicate(x));
}
public void TestEval_EmptyProgram_ReturnsEmptyArray()
{
IInterpreter interpreter = new CInterpreter();
IASTNode program = new CProgramASTNode();
int[][] input = new int[1][];
IInputStream inputStream = new CInputStream(input);
var result = interpreter.Eval(program, inputStream);
Assert.IsNotNull(result);
Assert.IsInstanceOf <int[]>(result);
Assert.IsEmpty(result);
}
public void TestEval_SimpleProgramWithInputAndIntrinsics_ReturnsResult()
{
IInterpreter interpreter = new CInterpreter();
/*program looks like
* x <- [int]
* y <- [int]
* z <- VecOp (-) x y
*/
var program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("x", new CReadInputASTNode(new CValueASTNode(new int[] { 0 }))),
new CAssignmentASTNode("y", new CReadInputASTNode(new CValueASTNode(new int[] { 1 }))),
new CAssignmentASTNode("z", new CCallASTNode(E_INTRINSIC_FUNC_TYPE.IFT_VECOP,
new List <IASTNode>()
{
new CBinaryLambdaFuncASTNode(E_OPERATION_TYPE.OT_SUB),
new CIdentifierASTNode("x"),
new CIdentifierASTNode("y")
}))
});
int[][] inputData = new int[][]
{
new int[] { 4, 4, 4, 4 }, //x
new int[] { 2, 2, 2, 2 } //y
};
int[] expectedResult = new int[] { 2, 2, 2, 2 };
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() =>
{
var result = interpreter.Eval(program, inputStream);
for (int i = 0; i < Math.Min(result.Length, expectedResult.Length); ++i)
{
Assert.AreEqual(expectedResult[i], result[i]);
}
});
}
public void TestVisitUnaryLambdaFuncNode_CheckNestedLambdaPredicateGeneration_ReturnsLambdaPredicate()
{
IVisitor <Object> interpreter = new CInterpreter();
Func <int, int> lambdaFunctor = null;
Func <int, int> expectedLambdaFunctor = (int x) => { return(x + x * (x - 2)); };
int inputParameter = 5;
Assert.DoesNotThrow(() => {
// the interpreter should infer x + x * (x - 2) expression
lambdaFunctor = (Func <int, int>)interpreter.VisitUnaryLambdaFuncNode(
new CUnaryLambdaFuncASTNode(E_OPERATION_TYPE.OT_ADD,
new CUnaryLambdaFuncASTNode(E_OPERATION_TYPE.OT_MUL,
new CUnaryLambdaFuncASTNode(E_OPERATION_TYPE.OT_SUB, new CValueASTNode(new int[] { 2 })))));
});
Assert.AreEqual(expectedLambdaFunctor(inputParameter), lambdaFunctor(inputParameter));
}
public void TestVisitAssigmentNode_SingleAssigmentOfValue_ReturnsValue()
{
IInterpreter interpreter = new CInterpreter();
int[][] inputData = new int[3][];
int[] expectedValue = new int[] { 42 };
// simple program that should assign 42 to a variable t
IASTNode program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("t", new CValueASTNode(expectedValue))
});
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() => {
var result = interpreter.Eval(program, inputStream);
Assert.AreEqual(result, expectedValue);
});
}
public void TestVisitAssigmentNode_SequentialAssigmentOfValueViaReference_ReturnsValue()
{
IInterpreter interpreter = new CInterpreter();
int[][] inputData = new int[3][];
int[] expectedValue = new int[] { 42 };
// simple program that should assign 42 to a variable t
// now program looks like t <- 42 \n v <- t
IASTNode program = new CProgramASTNode(new List <IASTNode>()
{
new CAssignmentASTNode("t", new CValueASTNode(expectedValue)),
new CAssignmentASTNode("v", new CIdentifierASTNode("t"))
});
IInputStream inputStream = new CInputStream(inputData);
Assert.DoesNotThrow(() => {
var result = interpreter.Eval(program, inputStream);
Assert.AreEqual(result, expectedValue);
});
}
public void SerialPrintlnS(CInterpreter state)
{
var p = state.ReadArg(0).PointerValue;
SerialOut.WriteLine(state.ReadString(p));
}
