UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-18 16:27:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

Allow tests to print progress.

Browse Source
This commit is contained in:
Jacob Young
2017-08-31 22:51:52 -04:00
parent 2e105036ff
commit ebeabd677e
8 changed files with 92 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
poincare/test/complex.cpp
View File

@@ -14,6 +14,8 @@ constexpr Expression::ComplexFormat Polar = Expression::ComplexFormat::Polar;
template<typename T>
void assert_cartesian_complex_converts_to(T a, T b, const char * result, Expression::FloatDisplayMode mode = Scientific, Expression::ComplexFormat format = Cartesian, int significantDigits = 7, int bufferSize = 13+13+7+1) {
quiz_print(result);
int tagSize = 8;
unsigned char tag = 'X';
char * taggedBuffer = new char[bufferSize+2*tagSize];

163
poincare/test/function.cpp
View File

@@ -8,143 +8,44 @@
using namespace Poincare;
QUIZ_CASE(poincare_parse_function) {
Expression * e = Expression::parse("abs(-1)");
assert(e->type() == Expression::Type::AbsoluteValue);
delete e;
char argText[10] = {'a', 'r', 'g', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
e = Expression::parse(argText);
assert(e->type() == Expression::Type::ComplexArgument);
delete e;
e = Expression::parse("binomial(10, 4)");
assert(e->type() == Expression::Type::BinomialCoefficient);
delete e;
e = Expression::parse("ceil(0.2)");
assert(e->type() == Expression::Type::Ceiling);
delete e;
e = Expression::parse("diff(2*x, 2)");
assert(e->type() == Expression::Type::Derivative);
delete e;
assert_parsed_expression_type("abs(-1)", Expression::Type::AbsoluteValue);
assert_parsed_expression_type("arg(2+I)", Expression::Type::ComplexArgument);
assert_parsed_expression_type("binomial(10, 4)", Expression::Type::BinomialCoefficient);
assert_parsed_expression_type("ceil(0.2)", Expression::Type::Ceiling);
assert_parsed_expression_type("diff(2*x, 2)", Expression::Type::Derivative);
#if MATRICES_ARE_DEFINED
e = Expression::parse("dim([[2]])");
assert(e->type() == Expression::Type::MatrixDimension);
delete e;
e = Expression::parse("det([[1,2,3][4,5,6][7,8,9]])");
assert(e->type() == Expression::Type::Determinant);
delete e;
assert_parsed_expression_type("dim([[2]])", Expression::Type::MatrixDimension);
assert_parsed_expression_type("det([[1,2,3][4,5,6][7,8,9]])", Expression::Type::Determinant);
#endif
e = Expression::parse("confidence(0.1, 100)");
assert(e->type() == Expression::Type::ConfidenceInterval);
delete e;
e = Expression::parse("conj(2)");
assert(e->type() == Expression::Type::Conjugate);
delete e;
e = Expression::parse("floor(2.3)");
assert(e->type() == Expression::Type::Floor);
delete e;
e = Expression::parse("frac(2.3)");
assert(e->type() == Expression::Type::FracPart);
delete e;
e = Expression::parse("gcd(2,3)");
assert(e->type() == Expression::Type::GreatCommonDivisor);
delete e;
char imText[10] = {'i', 'm', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
e = Expression::parse(imText);
assert(e->type() == Expression::Type::ImaginaryPart);
delete e;
e = Expression::parse("int(x, 2, 3)");
assert(e->type() == Expression::Type::Integral);
delete e;
assert_parsed_expression_type("confidence(0.1, 100)", Expression::Type::ConfidenceInterval);
assert_parsed_expression_type("conj(2)", Expression::Type::Conjugate);
assert_parsed_expression_type("floor(2.3)", Expression::Type::Floor);
assert_parsed_expression_type("frac(2.3)", Expression::Type::FracPart);
assert_parsed_expression_type("gcd(2,3)", Expression::Type::GreatCommonDivisor);
assert_parsed_expression_type("im(2+I)", Expression::Type::ImaginaryPart);
assert_parsed_expression_type("int(x, 2, 3)", Expression::Type::Integral);
#if MATRICES_ARE_DEFINED
e = Expression::parse("inverse([[1,2,3][4,5,6][7,8,9]])");
assert(e->type() == Expression::Type::MatrixInverse);
delete e;
assert_parsed_expression_type("inverse([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixInverse);
#endif
e = Expression::parse("lcm(2,3)");
assert(e->type() == Expression::Type::LeastCommonMultiple);
delete e;
e = Expression::parse("ln(2)");
assert(e->type() == Expression::Type::NaperianLogarithm);
delete e;
e = Expression::parse("log(2)");
assert(e->type() == Expression::Type::Logarithm);
delete e;
e = Expression::parse("permute(10, 4)");
assert(e->type() == Expression::Type::PermuteCoefficient);
delete e;
e = Expression::parse("prediction(0.1, 100)");
assert(e->type() == Expression::Type::ConfidenceInterval);
delete e;
e = Expression::parse("prediction95(0.1, 100)");
assert(e->type() == Expression::Type::PredictionInterval);
delete e;
e = Expression::parse("product(n, 4, 10)");
assert(e->type() == Expression::Type::Product);
delete e;
e = Expression::parse("quo(29, 10)");
assert(e->type() == Expression::Type::DivisionQuotient);
delete e;
char reText[10] = {'r', 'e', '(', '2', '+', Ion::Charset::IComplex, ')', 0};
e = Expression::parse(reText);
assert(e->type() == Expression::Type::ReelPart);
delete e;
e = Expression::parse("rem(29, 10)");
assert(e->type() == Expression::Type::DivisionRemainder);
delete e;
e = Expression::parse("root(2,3)");
assert(e->type() == Expression::Type::NthRoot);
delete e;
char text[5] = {Ion::Charset::Root, '(', '2', ')', 0};
e = Expression::parse(text);
assert(e->type() == Expression::Type::SquareRoot);
delete e;
e = Expression::parse("round(2,3)");
assert(e->type() == Expression::Type::Round);
delete e;
e = Expression::parse("sum(n, 4, 10)");
assert(e->type() == Expression::Type::Sum);
delete e;
assert_parsed_expression_type("lcm(2,3)", Expression::Type::LeastCommonMultiple);
assert_parsed_expression_type("ln(2)", Expression::Type::NaperianLogarithm);
assert_parsed_expression_type("log(2)", Expression::Type::Logarithm);
assert_parsed_expression_type("permute(10, 4)", Expression::Type::PermuteCoefficient);
assert_parsed_expression_type("prediction(0.1, 100)", Expression::Type::ConfidenceInterval);
assert_parsed_expression_type("prediction95(0.1, 100)", Expression::Type::PredictionInterval);
assert_parsed_expression_type("product(n, 4, 10)", Expression::Type::Product);
assert_parsed_expression_type("quo(29, 10)", Expression::Type::DivisionQuotient);
assert_parsed_expression_type("re(2+I)", Expression::Type::ReelPart);
assert_parsed_expression_type("rem(29, 10)", Expression::Type::DivisionRemainder);
assert_parsed_expression_type("root(2,3)", Expression::Type::NthRoot);
assert_parsed_expression_type("R(2)", Expression::Type::SquareRoot);
assert_parsed_expression_type("round(2,3)", Expression::Type::Round);
assert_parsed_expression_type("sum(n, 4, 10)", Expression::Type::Sum);
#if MATRICES_ARE_DEFINED
e = Expression::parse("trace([[1,2,3][4,5,6][7,8,9]])");
assert(e->type() == Expression::Type::MatrixTrace);
delete e;
e = Expression::parse("transpose([[1,2,3][4,5,6][7,8,9]])");
assert(e->type() == Expression::Type::MatrixTranspose);
delete e;
assert_parsed_expression_type("trace([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTrace);
assert_parsed_expression_type("transpose([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTranspose);
#endif
e = Expression::parse("6!");
assert(e->type() == Expression::Type::Factorial);
delete e;
assert_parsed_expression_type("6!", Expression::Type::Factorial);
}

53
poincare/test/helper.cpp
View File

@@ -8,30 +8,45 @@
using namespace Poincare;
template<typename T>
void assert_parsed_expression_evaluates_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
static Expression * parse_expression(const char * expression) {
quiz_print(expression);
char buffer[200];
strlcpy(buffer, expression, 200);
for (size_t i=0; i<strlen(buffer); i++) {
if (buffer[i] == 'E') {
buffer[i] = Ion::Charset::Exponent;
}
if (buffer[i] == 'X') {
buffer[i] = Ion::Charset::Exponential;
}
if (buffer[i] == 'I') {
buffer[i] = Ion::Charset::IComplex;
}
if (buffer[i] == 'R') {
buffer[i] = Ion::Charset::Root;
}
if (buffer[i] == 'P') {
buffer[i] = Ion::Charset::SmallPi;
strlcpy(buffer, expression, sizeof(buffer));
for (char *c = buffer; *c; c++) {
switch (*c) {
case 'E': *c = Ion::Charset::Exponent; break;
case 'X': *c = Ion::Charset::Exponential; break;
case 'I': *c = Ion::Charset::IComplex; break;
case 'R': *c = Ion::Charset::Root; break;
case 'P': *c = Ion::Charset::SmallPi; break;
}
}
Expression * result = Expression::parse(buffer);
assert(result);
return result;
}
void assert_parsed_expression_type(const char * expression, Poincare::Expression::Type type) {
Expression * e = parse_expression(expression);
assert(e->type() == type);
delete e;
}
void assert_parsed_simplified_expression_type(const char * expression, Poincare::Expression::Type type) {
Expression * e = parse_expression(expression);
Expression * e2 = e->simplify();
assert(e2);
assert(e2->type() == type);
delete e;
delete e2;
}
template<typename T>
void assert_parsed_expression_evaluates_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
GlobalContext globalContext;
Expression * a = Expression::parse(buffer);
Expression * a = parse_expression(expression);
Evaluation<T> * m = a->evaluate<T>(globalContext, angleUnit);
assert(m);
assert(m->numberOfRows() == numberOfRows);
assert(m->numberOfColumns() == numberOfColumns);
for (int i = 0; i < m->numberOfOperands(); i++) {

2
poincare/test/helper.h
View File

@@ -3,6 +3,8 @@
constexpr Poincare::Expression::AngleUnit Degree = Poincare::Expression::AngleUnit::Degree;
constexpr Poincare::Expression::AngleUnit Radian = Poincare::Expression::AngleUnit::Radian;
void assert_parsed_expression_type(const char * expression, Poincare::Expression::Type type);
void assert_parsed_simplified_expression_type(const char * expression, Poincare::Expression::Type type);
template<typename T>
void assert_parsed_expression_evaluates_to(const char * expression, Poincare::Complex<T> * results, int numberOfRows, int numberOfColumns = 1, Poincare::Expression::AngleUnit angleUnit = Degree);
template<typename T>

28
poincare/test/symbol.cpp
View File

@@ -8,29 +8,11 @@
using namespace Poincare;
QUIZ_CASE(poincare_parse_symbol) {
char piText[2] = {Ion::Charset::SmallPi, 0};
Expression * e = Expression::parse(piText);
assert(e->type() == Expression::Type::Symbol);
delete e;
char eText[2] = {Ion::Charset::Exponential, 0};
e = Expression::parse(eText);
assert(e->type() == Expression::Type::Symbol);
delete e;
char iText[10] = {Ion::Charset::IComplex, 0};
e = Expression::parse(iText);
assert(e->type() == Expression::Type::Complex);
delete e;
char floatText[10] = {'1', '.', '2', Ion::Charset::Exponent, '3', 0};
e = Expression::parse(floatText);
assert(e->type() == Expression::Type::Complex);
delete e;
e = Expression::parse("ans");
assert(e->type() == Expression::Type::Symbol);
delete e;
assert_parsed_expression_type("P", Expression::Type::Symbol);
assert_parsed_expression_type("X", Expression::Type::Symbol);
assert_parsed_expression_type("I", Expression::Type::Complex);
assert_parsed_expression_type("1.2E3", Expression::Type::Complex);
assert_parsed_expression_type("ans", Expression::Type::Symbol);
}

96
poincare/test/trigo.cpp
View File

@@ -7,90 +7,18 @@
using namespace Poincare;
QUIZ_CASE(poincare_parse_trigo) {
{
Expression * e = Expression::parse("sin(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::Sine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("cos(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::Cosine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("tan(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::Tangent);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("cosh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicCosine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("sinh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicSine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("tanh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicTangent);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("acos(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::ArcCosine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("asin(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::ArcSine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("atan(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::ArcTangent);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("acosh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicArcCosine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("asinh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicArcSine);
delete e;
delete e2;
}
{
Expression * e = Expression::parse("atanh(0)");
Expression * e2 = e->simplify();
assert(e2->type() == Expression::Type::HyperbolicArcTangent);
delete e;
delete e2;
}
assert_parsed_simplified_expression_type("sin(0)", Expression::Type::Sine);
assert_parsed_simplified_expression_type("cos(0)", Expression::Type::Cosine);
assert_parsed_simplified_expression_type("tan(0)", Expression::Type::Tangent);
assert_parsed_simplified_expression_type("cosh(0)", Expression::Type::HyperbolicCosine);
assert_parsed_simplified_expression_type("sinh(0)", Expression::Type::HyperbolicSine);
assert_parsed_simplified_expression_type("tanh(0)", Expression::Type::HyperbolicTangent);
assert_parsed_simplified_expression_type("acos(0)", Expression::Type::ArcCosine);
assert_parsed_simplified_expression_type("asin(0)", Expression::Type::ArcSine);
assert_parsed_simplified_expression_type("atan(0)", Expression::Type::ArcTangent);
assert_parsed_simplified_expression_type("acosh(0)", Expression::Type::HyperbolicArcCosine);
assert_parsed_simplified_expression_type("asinh(0)", Expression::Type::HyperbolicArcSine);
assert_parsed_simplified_expression_type("atanh(0)", Expression::Type::HyperbolicArcTangent);
}
QUIZ_CASE(poincare_trigo_evaluate) {

1
quiz/include/quiz.h
View File

@@ -14,6 +14,7 @@ extern "C" {
#endif
void quiz_assert_true(bool condition);
void quiz_print(const char * message);
#ifdef __cplusplus
}

7
quiz/src/runner.cpp
View File

@@ -1,9 +1,10 @@
#include "quiz.h"
#include "symbols.h"
#include <string.h>
#include <kandinsky.h>
#include <ion.h>
void print(const char * message) {
void quiz_print(const char * message) {
#if QUIZ_USE_CONSOLE
Ion::Console::writeLine(message);
#else
@@ -23,11 +24,11 @@ void ion_app() {
int i = 0;
while (quiz_cases[i] != NULL) {
QuizCase c = quiz_cases[i];
quiz_print(quiz_case_names[i]);
c();
print(quiz_case_names[i]);
i++;
}
print("ALL TESTS FINISHED");
quiz_print("ALL TESTS FINISHED");
#if !QUIZ_USE_CONSOLE
while (1) {
Ion::msleep(1000);