caiyu/LibreVNA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cd4698d92f
LibreVNA/Software/PC_Application/LibreVNA-GUI/Traces/Math/parser/mpTest.cpp

1839 lines
71 KiB
C++
Raw Normal View History

Move project, add simple test
2022-10-01 23:10:44 +08:00
/** \file
\brief Implementation of the unit test for muParserX.
<pre>
__________ ____ ___
_____ __ _\______ \_____ _______ ______ __________\ \/ /
/ \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ /
| Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \
|__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \
\/ \/ \/ \/ \_/
Copyright (C) 2016 Ingo Berg
All rights reserved.
muParserX - A C++ math parser library with array and string support
Copyright (c) 2016, Ingo Berg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
</pre>
*/
#include "mpTest.h"
#include "mpValue.h"
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <complex>
#include <limits>
#define MUP_CONST_PI 3.141592653589793238462643
#define MUP_CONST_E 2.718281828459045235360287
using namespace std;
MUP_NAMESPACE_START
//-----------------------------------------------------------------------------------------------
//
// class OprtStrAdd
//
//-----------------------------------------------------------------------------------------------
class DbgSillyAdd : public IOprtBin
{
public:
DbgSillyAdd()
:IOprtBin(_T("++"), (int)prADD_SUB, oaLEFT)
{}
//-----------------------------------------------------------------------------------------------
void Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc)
{
assert(argc == 2);
float_type a = arg[0]->GetFloat();
float_type b = arg[1]->GetFloat();
*ret = a + b;
}
//-----------------------------------------------------------------------------------------------
const char_type* GetDesc() const
{
return _T("internally used operator without special meaning for unit testing");
}
//-----------------------------------------------------------------------------------------------
IToken* Clone() const
{
return new DbgSillyAdd(*this);
}
};
//------------------------------------------------------------------------------
class FunTest0 : public ICallback
{
public:
FunTest0() : ICallback(cmFUNC, _T("test0"), 0)
{}
virtual void Eval(ptr_val_type &ret, const ptr_val_type * /*a_pArg*/, int /*a_iArgc*/)
{
*ret = 0.0;
}
virtual const char_type* GetDesc() const
{
return _T("");
}
virtual IToken* Clone() const
{
return new FunTest0(*this);
}
}; // class FunTest0
//---------------------------------------------------------------------------
int ParserTester::c_iCount = 0;
//---------------------------------------------------------------------------
ParserTester::ParserTester()
:m_vTestFun()
, m_stream(&console())
{
AddTest(&ParserTester::TestParserValue);
AddTest(&ParserTester::TestUndefVar);
AddTest(&ParserTester::TestErrorCodes);
AddTest(&ParserTester::TestEqn);
AddTest(&ParserTester::TestIfElse);
AddTest(&ParserTester::TestStringFun);
AddTest(&ParserTester::TestMatrix);
AddTest(&ParserTester::TestComplex);
AddTest(&ParserTester::TestVector);
AddTest(&ParserTester::TestBinOp);
AddTest(&ParserTester::TestPostfix);
AddTest(&ParserTester::TestInfix);
AddTest(&ParserTester::TestMultiArg);
AddTest(&ParserTester::TestScript);
AddTest(&ParserTester::TestValReader);
AddTest(&ParserTester::TestIssueReports);
ParserTester::c_iCount = 0;
}
//---------------------------------------------------------------------------
int ParserTester::TestIssueReports()
{
int iNumErr = 0;
*m_stream << _T("testing github issue reports...");
// Github: Issue 55
iNumErr += ThrowTest(_T("{0,{0}}*{0,{0}}*{,{0}}*{0,{0}0,{0}}*{0,{0}}*{,{0}}*{0}*{000}"), ecUNEXPECTED_COMMA);
// Github: Issue 56
iNumErr += ThrowTest(_T("0M[,1][0/1M[0M]M]"), ecUNEXPECTED_COMMA);
// Github Issue 57:
iNumErr += ThrowTest(_T("{?{{{{:44"), ecUNEXPECTED_CONDITIONAL);
// Github Issue 60
iNumErr += ThrowTest(_T("0<01?1=:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1<:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1>:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1+:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1*:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1/:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1&:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1<<:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("0<01?1>>:1"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("{ ? 0 : 7m}-{7, -00007m}-{7M}"), ecUNEXPECTED_CONDITIONAL);
iNumErr += ThrowTest(_T("{ { { ? 2 }, 7:2 }*7m }"), ecUNEXPECTED_CONDITIONAL);
// Not too happy about the undefined code, but better than a crash of an assertion at runtime
iNumErr += ThrowTest(_T("{0<0?0,0:0<0}"), ecUNEXPECTED_COMMA);
// Github Issue 63
iNumErr += ThrowTest(_T("0<0-0--eye()"), ecINVALID_NUMBER_OF_PARAMETERS);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestUndefVar()
{
int iNumErr = 0;
*m_stream << _T("testing implicit definition of undefined variables...");
// Test 1: No variables defined, test detection of undefined variables
{
ParserX p;
p.SetExpr(_T("a+b+c+d"));
const mup::var_maptype &expr_var = p.GetExprVar();
const mup::var_maptype &var = p.GetVar();
// The expression contains 4 undefined variables
if (expr_var.size() != 4)
iNumErr++;
// There are no variables defined
if (var.size() != 0)
iNumErr++;
}
// Test 2: Variables were defined explicitely, test detection of variables
{
ParserX p;
// Now define the variables and perform the check again
Value vVarVal[] = { 1.0, 2.0, 3.0, 4.0 };
p.DefineVar(_T("a"), Variable(&vVarVal[0]));
p.DefineVar(_T("b"), Variable(&vVarVal[1]));
p.DefineVar(_T("c"), Variable(&vVarVal[2]));
p.DefineVar(_T("d"), Variable(&vVarVal[3]));
p.SetExpr(_T("a+b+c+d"));
const mup::var_maptype &expr_var = p.GetExprVar();
const mup::var_maptype &var = p.GetVar();
// The expression contains 4 undefined variables
if (expr_var.size() != 4)
iNumErr++;
// There are no variables defined
if (var.size() != 4)
iNumErr++;
}
// Test 3: Variables were defined implicitels, test detection of undefined variables
{
ParserX p;
// Now define the variables and perform the check again
p.EnableAutoCreateVar(true);
p.SetExpr(_T("a+b+c+d"));
const mup::var_maptype &expr_var = p.GetExprVar();
const mup::var_maptype &var = p.GetVar();
// The expression contains 4 undefined variables
if (expr_var.size() != 4)
iNumErr++;
// There are no variables defined
if (var.size() != 4)
iNumErr++;
}
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestMatrix()
{
int iNumErr = 0;
*m_stream << _T("testing matrix calculations...");
Value unity(3, 3, 0);
unity.At(0, 0) = 1.0;
unity.At(1, 1) = 1.0;
unity.At(2, 2) = 1.0;
Value va(3, 0);
va.At(0) = 1.0;
va.At(1) = 2.0;
va.At(2) = 3.0;
//Value m2(3, 3, 0);
//m2.At(0, 0) = 1; m2.At(0, 1) = 2; m2.At(0, 2) = 3;
//m2.At(1, 0) = 4; m2.At(1, 1) = 5; m2.At(1, 2) = 6;
//m2.At(2, 0) = 7; m2.At(2, 1) = 8; m2.At(2, 2) = 9;
Value m1_plus_m2(3, 3, 0);
m1_plus_m2.At(0, 0) = 2.0; m1_plus_m2.At(0, 1) = 2.0; m1_plus_m2.At(0, 2) = 3.0;
m1_plus_m2.At(1, 0) = 4.0; m1_plus_m2.At(1, 1) = 6.0; m1_plus_m2.At(1, 2) = 6.0;
m1_plus_m2.At(2, 0) = 7.0; m1_plus_m2.At(2, 1) = 8.0; m1_plus_m2.At(2, 2) = 10.0;
Value m2_minus_m1(3, 3, 0);
m2_minus_m1.At(0, 0) = 0.0; m2_minus_m1.At(0, 1) = 2.0; m2_minus_m1.At(0, 2) = 3.0;
m2_minus_m1.At(1, 0) = 4.0; m2_minus_m1.At(1, 1) = 4.0; m2_minus_m1.At(1, 2) = 6.0;
m2_minus_m1.At(2, 0) = 7.0; m2_minus_m1.At(2, 1) = 8.0; m2_minus_m1.At(2, 2) = 8.0;
Value m2_times_10(3, 3, 0);
m2_times_10.At(0, 0) = 10.0; m2_times_10.At(0, 1) = 20.0; m2_times_10.At(0, 2) = 30.0;
m2_times_10.At(1, 0) = 40.0; m2_times_10.At(1, 1) = 50.0; m2_times_10.At(1, 2) = 60.0;
m2_times_10.At(2, 0) = 70.0; m2_times_10.At(2, 1) = 80.0; m2_times_10.At(2, 2) = 90.0;
Value va_times_vb_transp(3, 3, 0);
va_times_vb_transp.At(0, 0) = 4.0; va_times_vb_transp.At(0, 1) = 3.0; va_times_vb_transp.At(0, 2) = 2.0;
va_times_vb_transp.At(1, 0) = 8.0; va_times_vb_transp.At(1, 1) = 6.0; va_times_vb_transp.At(1, 2) = 4.0;
va_times_vb_transp.At(2, 0) = 12.0; va_times_vb_transp.At(2, 1) = 9.0; va_times_vb_transp.At(2, 2) = 6.0;
Value size_3x6(1, 2, 0);
size_3x6.At(0, 0) = 3.0;
size_3x6.At(0, 1) = 6.0;
Value size_3x3(1, 2, 0);
size_3x3.At(0, 0) = 3.0;
size_3x3.At(0, 1) = 3.0;
Value size_3x1(1, 2, 0);
size_3x1.At(0, 0) = 3.0;
size_3x1.At(0, 1) = 1.0;
Value size_1x3(1, 2, 0);
size_1x3.At(0, 0) = 1.0;
size_1x3.At(0, 1) = 3.0;
// Check matrix dimension mismatch error
iNumErr += ThrowTest(_T("\"hallo\"+m1"), ecEVAL);
iNumErr += ThrowTest(_T("m1+\"hallo\""), ecEVAL);
iNumErr += ThrowTest(_T("va+m1"), ecMATRIX_DIMENSION_MISMATCH);
iNumErr += ThrowTest(_T("m1+va"), ecMATRIX_DIMENSION_MISMATCH);
iNumErr += ThrowTest(_T("va-m1"), ecMATRIX_DIMENSION_MISMATCH);
iNumErr += ThrowTest(_T("m1-va"), ecMATRIX_DIMENSION_MISMATCH);
iNumErr += ThrowTest(_T("va*m1"), ecMATRIX_DIMENSION_MISMATCH);
iNumErr += ThrowTest(_T("va+eye(2)"), ecMATRIX_DIMENSION_MISMATCH);
// Issue 63:
iNumErr += ThrowTest(_T("0-0-eye()"), ecINVALID_NUMBER_OF_PARAMETERS);
iNumErr += ThrowTest(_T("m1[1]"), ecINDEX_DIMENSION);
iNumErr += ThrowTest(_T("m1[1,2,3]"), ecINDEX_DIMENSION);
iNumErr += ThrowTest(_T("va[1,2]"), ecINDEX_OUT_OF_BOUNDS); // va has 1 column, 3 rows -> the coulumn index is referencing the third column
iNumErr += ThrowTest(_T("a+m1"), ecEVAL);
iNumErr += ThrowTest(_T("m1+a"), ecEVAL);
iNumErr += ThrowTest(_T("a-m1"), ecEVAL);
iNumErr += ThrowTest(_T("m1-a"), ecEVAL);
iNumErr += ThrowTest(_T("va[,1]"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("va[{1]"), ecMISSING_CURLY_BRACKET);
iNumErr += ThrowTest(_T("{,1}"), ecUNEXPECTED_COMMA);
// sample expressions
iNumErr += EqnTest(_T("m1"), unity, true);
iNumErr += EqnTest(_T("m1*m1"), unity, true);
iNumErr += EqnTest(_T("m1+m2"), m1_plus_m2, true);
iNumErr += EqnTest(_T("m2-m1"), m2_minus_m1, true);
iNumErr += EqnTest(_T("10*m2"), m2_times_10, true);
iNumErr += EqnTest(_T("m2*10"), m2_times_10, true);
iNumErr += EqnTest(_T("5*m2*b"), m2_times_10, true);
iNumErr += EqnTest(_T("b*m2*5"), m2_times_10, true);
iNumErr += EqnTest(_T("m1*va"), va, true);
// ones
Value ones_3(3, 1.0);
Value ones_3x3(3, 3, 1.0);
iNumErr += ThrowTest(_T("ones(1,2,3)"), ecINVALID_NUMBER_OF_PARAMETERS);
iNumErr += ThrowTest(_T("ones()"), ecINVALID_NUMBER_OF_PARAMETERS);
iNumErr += EqnTest(_T("ones(1,1)"), 1.0, true);
iNumErr += EqnTest(_T("ones(1)"), 1.0, true);
iNumErr += EqnTest(_T("ones(3,3)"), ones_3x3, true);
iNumErr += EqnTest(_T("ones(3,1)"), ones_3, true);
iNumErr += EqnTest(_T("ones(3)"), ones_3, true);
iNumErr += EqnTest(_T("size(ones(3,3))"), size_3x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(ones(1,3))"), size_1x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(ones(3,1))"), size_3x1, true); // check return value dimension
iNumErr += EqnTest(_T("size(ones(3))"), size_3x3, true); // check return value dimension
// zeros
iNumErr += ThrowTest(_T("zeros()"), ecINVALID_NUMBER_OF_PARAMETERS);
iNumErr += EqnTest(_T("size(zeros(3,3))"), size_3x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(zeros(1,3))"), size_1x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(zeros(3,1))"), size_3x1, true); // check return value dimension
iNumErr += EqnTest(_T("size(zeros(3))"), size_3x3, true); // check return value dimension
// eye
iNumErr += ThrowTest(_T("eye()"), ecINVALID_NUMBER_OF_PARAMETERS);
iNumErr += EqnTest(_T("size(eye(3,3))"), size_3x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(eye(1,3))"), size_1x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(eye(3,1))"), size_3x1, true); // check return value dimension
iNumErr += EqnTest(_T("size(eye(3))"), size_3x3, true); // check return value dimension
iNumErr += EqnTest(_T("size(eye(3,6))"), size_3x6, true); // check return value dimension
// transposition
iNumErr += EqnTest(_T("va'*vb"), 16.0, true);
iNumErr += EqnTest(_T("2*va'*vb"), 32.0, true);
iNumErr += EqnTest(_T("va*vb'"), va_times_vb_transp, true);
// index operator
// erster index: Zeilenindex, zweiter index: Spaltenindex
iNumErr += EqnTest(_T("va[0]"), 1.0, true);
iNumErr += EqnTest(_T("va[1]"), 2.0, true);
iNumErr += EqnTest(_T("va[2]"), 3.0, true);
// Use two dimensional index operator on a vector
iNumErr += EqnTest(_T("va[0,0]"), 1.0, true);
iNumErr += EqnTest(_T("va[1,0]"), 2.0, true);
iNumErr += EqnTest(_T("va[2,0]"), 3.0, true);
// Now test the same with a transposed vector:
iNumErr += EqnTest(_T("va'[0]"), 1.0, true);
iNumErr += EqnTest(_T("va'[1]"), 2.0, true);
iNumErr += EqnTest(_T("va'[2]"), 3.0, true);
// Use two dimensional index operator on a vector
iNumErr += EqnTest(_T("va'[0,0]"), 1.0, true);
iNumErr += EqnTest(_T("va'[0,1]"), 2.0, true);
iNumErr += EqnTest(_T("va'[0,2]"), 3.0, true);
iNumErr += EqnTest(_T("(va')[0,2]"), 3.0, true); // <- Index operator after closing bracket is ok
// vector creation
iNumErr += EqnTest(_T("{1,2,3}'"), va, true);
iNumErr += EqnTest(_T("{a,2,3}'"), va, true); // that was an actual bug: variable a was overwritten
// assignment to element:
iNumErr += ThrowTest(_T("va'[0]=123"), ecASSIGNEMENT_TO_VALUE);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestComplex()
{
int iNumErr = 0;
*m_stream << _T("testing complex calculations...");
// complex numbers
// ca=1+i, cb=2+3i, cc=3+4i
iNumErr += EqnTest(_T("ca==1+i"), true, true);
iNumErr += EqnTest(_T("ca==ca"), true, true);
iNumErr += EqnTest(_T("ca!=1+i"), false, true);
iNumErr += EqnTest(_T("ca!=ca"), false, true);
iNumErr += EqnTest(_T("ca!=cb"), true, true);
iNumErr += EqnTest(_T("ca!=va"), true, true);
iNumErr += EqnTest(_T("ca==va"), false, true);
// When comparing complex number Matlab/Octave compare only the real part
// I'll do the same...
iNumErr += EqnTest(_T("ca<10+i"), true, true);
iNumErr += EqnTest(_T("ca>10+i"), false, true);
iNumErr += EqnTest(_T("ca<=10+i"), true, true);
iNumErr += EqnTest(_T("ca>=10+i"), false, true);
iNumErr += EqnTest(_T("ca<=1"), true, true);
iNumErr += EqnTest(_T("ca>=1"), true, true);
// complex numbers
iNumErr += EqnTest(_T("i*i"), -1.0, true, 0);
iNumErr += EqnTest(_T("1i"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("norm(3+4i)"), 25.0, true, 0);
iNumErr += EqnTest(_T("norm(4i+3)"), 25.0, true, 0);
iNumErr += EqnTest(_T("norm(3i+4)"), 25.0, true, 0);
iNumErr += EqnTest(_T("real(4.1i+3.1)"), (float_type)3.1, true, 0);
iNumErr += EqnTest(_T("imag(3.1i+4.1)"), (float_type)3.1, true, 0);
iNumErr += EqnTest(_T("real(3.1)"), (float_type)3.1, true, 0);
iNumErr += EqnTest(_T("imag(2.1i)"), (float_type)2.1, true, 0);
iNumErr += EqnTest(_T("-(4i+5)"), cmplx_type(-5, -4), true, 0);
iNumErr += EqnTest(_T("sqrt(-1)"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("(-1)^0.5"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("(-3)^(4/3)"), std::pow(cmplx_type(-3, 0),
cmplx_type(4.0 / 3, 0)), true, 0);
// Issue 41: Complex pow of small numbers zeros out the imaginary part
// https://code.google.com/p/muparserx/issues/detail?id=41
iNumErr += EqnTest(_T("(1e-15 + 1e-15*i) ^ 2"), std::pow(cmplx_type(1e-15, 1e-15), 2), true, 0);
iNumErr += EqnTest(_T("sqrt(i*i)"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("sqrt(f)"), cmplx_type(0, 1), true, 1);
iNumErr += EqnTest(_T("sqrt(2-3)"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("sqrt(a-b)"), cmplx_type(0, 1), true, 2);
iNumErr += EqnTest(_T("sqrt((2-3))"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("sqrt((a-b))"), cmplx_type(0, 1), true, 2);
iNumErr += EqnTest(_T("sqrt(-(1))"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("sqrt((-1))"), cmplx_type(0, 1), true, 0);
iNumErr += EqnTest(_T("sqrt(-(-1))"), cmplx_type(1, 0), true, 0);
iNumErr += EqnTest(_T("sqrt(1)"), cmplx_type(1, 0), true, 0);
iNumErr += EqnTest(_T("a=1+2i"), cmplx_type(1, 2), true, 1);
iNumErr += EqnTest(_T("-(1+2i)"), cmplx_type(-1, -2), true, 0);
iNumErr += EqnTest(_T("-(-1-2i)"), cmplx_type(1, 2), true, 0);
iNumErr += EqnTest(_T("a*i"), cmplx_type(0, 1), true, 1);
iNumErr += EqnTest(_T("-(a+b*i)"), cmplx_type(-1, -2), true, 2);
iNumErr += EqnTest(_T("-(-a-b*i)"), cmplx_type(1, 2), true, 2);
iNumErr += EqnTest(_T("(2+4i)*(8-6i)"), cmplx_type(40, 20), true, 0);
// Issue 17: Wrong result on complex power.
iNumErr += EqnTest(_T("(-0.27 + 0.66*i)^2"), cmplx_type(-0.3627, -0.3564), true, 0);
iNumErr += EqnTest(_T("(-1+5i)^2"), cmplx_type(-24, -10), true, 0);
iNumErr += EqnTest(_T("c=(a=1+2i)"), cmplx_type(1, 2), true, 2);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestParserValue()
{
int iNumErr = 0;
*m_stream << _T("testing parser value types...");
// Define values and variables for each type
Value bVal = true;
Value fVal = (float_type)3.14;
Value sVal = string_type(_T("hello world"));
Value sVal1 = _T("hello world"); // Test assignment from const char* to string
Value cVal = cmplx_type(1, 1);
Value aVal(2, 0);
aVal.At(0) = (float_type)2.0;
aVal.At(1) = (float_type)3.0;
// Create a 3x3 matrix
Value matrix(3, 0);
matrix.At(0) = Value(3, 0);
matrix.At(1) = Value(3, 0);
matrix.At(2) = Value(3, 0);
Variable bVar(&bVal),
fVar(&fVal),
sVar(&sVal),
sVar1(&sVal1),
cVar(&cVal),
aVar(&aVal);
// Check the value types
try
{
// Test if matrix values do work
if (!matrix.IsMatrix() || matrix.GetRows() != 3)
iNumErr++;
std::size_t sz = matrix.GetRows();
for (std::size_t i = 0; i < sz; ++i)
{
std::size_t dim_row = matrix.At(static_cast<int>(i)).GetRows();
if (dim_row != 3)
{
iNumErr++;
console() << _T("\n Array dimension mismatch in matrix row ") << i
<< _T(" (expected=3; dim=") << dim_row << _T(")");
}
}
// test type checking of values
if (!fVal.IsScalar() || fVal.IsMatrix() || fVal.GetType() != 'f') iNumErr++;
if (!cVal.IsScalar() || cVal.IsMatrix() || cVal.GetType() != 'c') iNumErr++;
if (aVal.IsScalar() || !aVal.IsMatrix() || aVal.GetType() != 'm') iNumErr++;
if (sVal.IsScalar() || sVal.IsMatrix() || sVal.GetType() != 's') iNumErr++;
if (sVal1.IsScalar() || sVal1.IsMatrix() || sVal1.GetType() != 's') iNumErr++;
if (bVal.IsScalar() || bVal.IsMatrix() || bVal.GetType() != 'b') iNumErr++;
// test type checking of variables
if (!fVar.IsScalar() || fVar.IsMatrix() || fVar.GetType() != 'f') iNumErr++;
if (!cVar.IsScalar() || cVar.IsMatrix() || cVar.GetType() != 'c') iNumErr++;
if (aVar.IsScalar() || !aVar.IsMatrix() || aVar.GetType() != 'm') iNumErr++;
if (sVar.IsScalar() || sVar.IsMatrix() || sVar.GetType() != 's') iNumErr++;
if (sVar1.IsScalar() || sVar1.IsMatrix() || sVar1.GetType() != 's') iNumErr++;
if (bVar.IsScalar() || bVar.IsMatrix() || bVar.GetType() != 'b') iNumErr++;
// Issue 33: https://code.google.com/p/muparserx/issues/detail?id=33
// Remark: Type information was not properly set when invoking +=, -= operators
{
Value x = 1.0;
Value y = cmplx_type(0, 1);
x += y;
if (x.GetImag() != 1 || x.GetFloat() != 1 || x.GetType() != 'c')
{
*m_stream << _T("\nValue::operator+=(...) failed.");
iNumErr++;
}
x = 1.0;
y = cmplx_type(0, 1);
x -= y;
if (x.GetImag() != -1 || x.GetFloat() != 1 || x.GetType() != 'c')
{
*m_stream << _T("\nValue::operator-=(...) failed.");
iNumErr++;
}
}
}
catch (...)
{
iNumErr++;
}
bool bError;
#define VALUE_THROWCHECK(VAR, FAIL, MEMBER) \
bError = (FAIL); \
try \
{ \
VAR.MEMBER(); \
} \
catch (...) \
{ \
bError ^= true; \
} \
iNumErr += (bError) ? 1 : 0; \
c_iCount++;
// Check if the getter functions really throw an exception
// when used with an incorrect value type
// Case 1: test float values
VALUE_THROWCHECK(fVal, false, GetFloat)
VALUE_THROWCHECK(fVal, false, GetImag)
VALUE_THROWCHECK(fVal, true, GetBool)
VALUE_THROWCHECK(fVal, true, GetString)
VALUE_THROWCHECK(fVal, true, GetArray)
// for variables
VALUE_THROWCHECK(fVar, false, GetFloat)
VALUE_THROWCHECK(fVar, false, GetImag)
VALUE_THROWCHECK(fVar, true, GetBool)
VALUE_THROWCHECK(fVar, true, GetString)
VALUE_THROWCHECK(fVar, true, GetArray)
// Case 2: test bool values
VALUE_THROWCHECK(bVal, false, GetFloat)
VALUE_THROWCHECK(bVal, true, GetImag)
VALUE_THROWCHECK(bVal, false, GetBool)
VALUE_THROWCHECK(bVal, true, GetString)
VALUE_THROWCHECK(bVal, true, GetArray)
// for variables
VALUE_THROWCHECK(bVar, false, GetFloat)
VALUE_THROWCHECK(bVar, true, GetImag)
VALUE_THROWCHECK(bVar, false, GetBool)
VALUE_THROWCHECK(bVar, true, GetString)
VALUE_THROWCHECK(bVar, true, GetArray)
// Case 3: test string values
// VALUE_THROWCHECK(sVal, true, GetFloat)
VALUE_THROWCHECK(sVal, true, GetImag)
VALUE_THROWCHECK(sVal, true, GetBool)
VALUE_THROWCHECK(sVal, false, GetString)
VALUE_THROWCHECK(sVal, true, GetArray)
// for variables
// VALUE_THROWCHECK(sVar, true, GetFloat)
VALUE_THROWCHECK(sVar, true, GetImag)
VALUE_THROWCHECK(sVar, true, GetBool)
VALUE_THROWCHECK(sVar, false, GetString)
VALUE_THROWCHECK(sVar, true, GetArray)
// Case 4: test array values
// VALUE_THROWCHECK(aVal, true, GetFloat)
VALUE_THROWCHECK(aVal, true, GetImag)
VALUE_THROWCHECK(aVal, true, GetBool)
VALUE_THROWCHECK(aVal, true, GetString)
VALUE_THROWCHECK(aVal, false, GetArray)
// for variables
// VALUE_THROWCHECK(aVar, true, GetFloat)
VALUE_THROWCHECK(aVar, true, GetImag)
VALUE_THROWCHECK(aVar, true, GetBool)
VALUE_THROWCHECK(aVar, true, GetString)
VALUE_THROWCHECK(aVar, false, GetArray)
// Case 5: test complex values
// VALUE_THROWCHECK(cVal, false, GetFloat)
VALUE_THROWCHECK(cVal, false, GetImag)
VALUE_THROWCHECK(cVal, true, GetBool)
VALUE_THROWCHECK(cVal, true, GetString)
VALUE_THROWCHECK(cVal, true, GetArray)
// for variables
// VALUE_THROWCHECK(cVar, false, GetFloat)
VALUE_THROWCHECK(cVar, false, GetImag)
VALUE_THROWCHECK(cVar, true, GetBool)
VALUE_THROWCHECK(cVar, true, GetString)
VALUE_THROWCHECK(cVar, true, GetArray)
#undef VALUE_THROWCHECK
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestErrorCodes()
{
int iNumErr = 0;
*m_stream << _T("testing error codes...");
iNumErr += ThrowTest(_T("a,b"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("(a,b)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("((a,b))"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("2*1,2"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sin(1,2)"), ecTOO_MANY_PARAMS);
// Invalid expression
// Issue 20: http://code.google.com/p/muparserx/issues/detail?id=20
iNumErr += ThrowTest(_T(" "), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("sin(nonexistent_var)"), ecUNASSIGNABLE_TOKEN, 4, _T("nonexistent_var"));
// Invalid function argument types
iNumErr += ThrowTest(_T("sin(\"test\")"), ecEVAL, 0);
iNumErr += ThrowTest(_T("max(1, \"test\")"), ecEVAL, 0);
iNumErr += ThrowTest(_T("max(1,sin(8), \"t\")"), ecEVAL, 0);
iNumErr += ThrowTest(_T("str2dbl(sin(3.14))"), ecEVAL, 0);
// Invalid unary operator argument types
iNumErr += ThrowTest(_T("\"test\"n"), ecEVAL, 6); // (nano can only be applied to floats)
iNumErr += ThrowTest(_T("(1+3i)/(8*9i)+\"hallo\""), ecEVAL);
iNumErr += ThrowTest(_T("(1+3i)/(8*9i)-\"hallo\""), ecEVAL);
iNumErr += ThrowTest(_T("(1+3i)/(8*9i)*\"hallo\""), ecEVAL);
iNumErr += ThrowTest(_T("(1+3i)/(8*9i)/\"hallo\""), ecEVAL);
iNumErr += ThrowTest(_T("10+va"), ecEVAL, 2);
// Type conflicts in binary operators
iNumErr += ThrowTest(_T("\"test\" // 8"), ecEVAL, 7);
iNumErr += ThrowTest(_T("8//\"test\""), ecEVAL, 1);
iNumErr += ThrowTest(_T("5//8"), ecEVAL, 1);
iNumErr += ThrowTest(_T("\"t\"//sin(8)"), ecEVAL, 3);
iNumErr += ThrowTest(_T("sin(8)//\"t\""), ecEVAL, 6);
// Unexpected end of expression
iNumErr += ThrowTest(_T("3+"), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("8*"), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("3+("), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("3+sin"), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("(2+"), ecUNEXPECTED_EOF);
iNumErr += ThrowTest(_T("3+)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("3)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("(3))"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("()"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("(2+)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("sin(cos)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("sin(())"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("sin()"), ecTOO_FEW_PARAMS);
iNumErr += ThrowTest(_T("sin)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("pi)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("a)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("2(-m)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("2(m)"), ecUNEXPECTED_PARENS);
iNumErr += ThrowTest(_T("(1+2"), ecMISSING_PARENS);
iNumErr += ThrowTest(_T("((3)"), ecMISSING_PARENS);
// The behaviour in the next function depends on whether
// implicit variable creation is allowed or not. (momentarily its active)
iNumErr += ThrowTest(_T("5z)"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("sin(3)xyz"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("5t6"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("5 t 6"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("ksdfj"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("-m"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("m4"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("sin(m)"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("m m"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("m(8)"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("4 + m"), ecUNASSIGNABLE_TOKEN);
// unexpected operator
iNumErr += ThrowTest(_T("5+*3)"), ecUNEXPECTED_OPERATOR);
// unexpected comma (used without a function)
iNumErr += ThrowTest(_T(",3"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sin(,sin(8))"), ecUNEXPECTED_COMMA);
// unexpected variable
iNumErr += ThrowTest(_T("a _xxx_ b"), ecUNASSIGNABLE_TOKEN, 2); // if a variable factory is installed ecUNEXPECTED_VAR
iNumErr += ThrowTest(_T("sin(3)cos(3)"), ecUNEXPECTED_FUN);
iNumErr += ThrowTest(_T("sin(3)3"), ecUNEXPECTED_VAL);
iNumErr += ThrowTest(_T("sin(3)+"), ecUNEXPECTED_EOF);
// value recognition
iNumErr += ThrowTest(_T("0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value
iNumErr += ThrowTest(_T("1+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value
iNumErr += ThrowTest(_T("a+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value
// index operator
iNumErr += ThrowTest(_T("3n[1]"), ecINDEX_OUT_OF_BOUNDS); // Indexing a scalar is ok, but this index is out of bounds (0 would be ok)
iNumErr += ThrowTest(_T("min(3,]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("sin(]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("va[]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("3+]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("sin[a)"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("1+[8]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("1[8]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("[1]"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("]1"), ecUNEXPECTED_SQR_BRACKET);
iNumErr += ThrowTest(_T("va[[3]]"), ecUNEXPECTED_SQR_BRACKET);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestStringFun()
{
int iNumErr = 0;
*m_stream << _T("testing string functions...");
// escape sequences
iNumErr += EqnTest(_T("\"\\\"quoted_string\\\"\""), _T("\"quoted_string\""), true); // "\"quoted_string\"" -> "quoted_string"
iNumErr += EqnTest(_T("\"\\\"\\\"\""), _T("\"\""), true); // "\"\"" -> ""
iNumErr += EqnTest(_T("\"\\\\\""), _T("\\"), true); // "\\" -> \ (single backslash)
// String functions
iNumErr += EqnTest(_T("strlen(\"12345\")"), 5.0, true);
iNumErr += EqnTest(_T("strlen(toupper(\"abcde\"))"), 5.0, true);
iNumErr += EqnTest(_T("sin(0)+(float)strlen(\"12345\")"), (float_type)5.0, true);
iNumErr += EqnTest(_T("10*(float)strlen(toupper(\"12345\"))"), (float_type)50.0, true);
iNumErr += EqnTest(_T("\"hello \"//\"world\""), string_type(_T("hello world")), true);
iNumErr += EqnTest(_T("toupper(\"hello \")//\"world\""), string_type(_T("HELLO world")), true);
iNumErr += EqnTest(_T("\"hello \"//toupper(\"world\")//\" !!!\""), string_type(_T("hello WORLD !!!")), true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestPostfix()
{
int iNumErr = 0;
*m_stream << _T("testing postfix operators...");
// application
iNumErr += EqnTest(_T("1n"), (float_type)1e-9, true);
iNumErr += EqnTest(_T("8n"), (float_type)8e-9, true);
iNumErr += EqnTest(_T("8n"), (float_type)123.0, false);
iNumErr += EqnTest(_T("3m+5"), (float_type)5.003, true);
iNumErr += EqnTest(_T("1000m"), (float_type)1.0, true);
iNumErr += EqnTest(_T("1000 m"), (float_type)1.0, true);
iNumErr += EqnTest(_T("(a)m"), (float_type)1e-3, true);
iNumErr += EqnTest(_T("-(a)m"), (float_type)-1e-3, true);
iNumErr += EqnTest(_T("-2m"), (float_type)-2e-3, true);
iNumErr += EqnTest(_T("a++b"), 3.0, true);
iNumErr += EqnTest(_T("a ++ b"), 3.0, true);
iNumErr += EqnTest(_T("1++2"), 3.0, true);
iNumErr += EqnTest(_T("1 ++ 2"), 3.0, true);
iNumErr += EqnTest(_T("2+(a*1000)m"), (float_type)3.0, true);
// some incorrect results
iNumErr += EqnTest(_T("1000m"), (float_type)0.1, false);
iNumErr += EqnTest(_T("(a)m"), (float_type)2.0, false);
// factorial operator
iNumErr += EqnTest(_T("5!"), 120.0, true);
iNumErr += EqnTest(_T("-5!"), -120.0, true);
iNumErr += ThrowTest(_T("(-5)!"), ecDOMAIN_ERROR);
// Special tests for systems not supporting IEEE 754
if (!std::numeric_limits<float_type>::is_iec559)
{
iNumErr += ThrowTest(_T("123456!"), ecOVERFLOW);
}
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestInfix()
{
int iNumErr = 0;
*m_stream << _T("testing infix operators...");
float_type a = 1;
float_type b = 2;
iNumErr += EqnTest(_T("-1"), (float_type)-1.0, true);
iNumErr += EqnTest(_T("-(-1)"), (float_type)1.0, true);
iNumErr += EqnTest(_T("-(-1)*2"), (float_type)2.0, true);
iNumErr += EqnTest(_T("-(-2)*sqrt(4)"), (float_type)4.0, true);
iNumErr += EqnTest(_T("-a"), -a, true);
iNumErr += EqnTest(_T("-(a)"), -(a), true);
iNumErr += EqnTest(_T("-(-a)"), -(-a), true);
iNumErr += EqnTest(_T("-(-a)*2"), -(-a) * 2, true);
iNumErr += EqnTest(_T("-(8)"), (float_type)-8.0, true);
iNumErr += EqnTest(_T("-8"), (float_type)-8.0, true);
iNumErr += EqnTest(_T("-(2+1)"), (float_type)-3.0, true);
//iNumErr += EqnTest("-(f1of1(1+2*3)+1*2)", -9.0, true);
//iNumErr += EqnTest("-(-f1of1(1+2*3)+1*2)", 5.0, true);
iNumErr += EqnTest(_T("-sin(8)"), (float_type)-0.989358, true);
iNumErr += EqnTest(_T("-sin(8)"), (float_type)0.989358, false);
iNumErr += EqnTest(_T("3-(-a)"), (float_type)4.0, true);
iNumErr += EqnTest(_T("3--a"), (float_type)4.0, true);
iNumErr += EqnTest(_T("2++4"), (float_type)6.0, true);
iNumErr += EqnTest(_T("--1"), (float_type)1.0, true);
// sign precedence
// Issue 14: https://code.google.com/p/muparserx/issues/detail?id=14
iNumErr += EqnTest(_T("-3^2"), -9.0, true);
iNumErr += EqnTest(_T("-b^2^3-b^8"), -std::pow(b, std::pow(2.0, 3.0)) - std::pow(b, 8), true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestMultiArg()
{
int iNumErr = 0;
*m_stream << _T("testing multiarg functions...");
// Multiarg functions being called without any parameters
iNumErr += ThrowTest(_T("min()"), ecTOO_FEW_PARAMS);
iNumErr += ThrowTest(_T("max()"), ecTOO_FEW_PARAMS);
iNumErr += ThrowTest(_T("sum()"), ecTOO_FEW_PARAMS);
// application
iNumErr += EqnTest(_T("max(1,8,9,(int)6)"), (float_type)9.0, true);
iNumErr += EqnTest(_T("max((int)6, 1+2, 4, -9)"), (float_type)6.0, true);
iNumErr += EqnTest(_T("min((int)6, 1+2, 4, -9)"), (float_type)-9.0, true);
//
iNumErr += EqnTest(_T("a=test0()"), (float_type)0, true);
iNumErr += EqnTest(_T("b=a+test0()"), (float_type)1, true);
// added as response to this bugreport:
// http://code.google.com/p/muparserx/issues/detail?id=1
// cause of the error: Function tokens were not cloned in the tokenreader when beeing found.
// a pointer to the one and only function onject was returned instead
// consequently the argument counter was overwritten by the second function call
// causing an assertion later on.
iNumErr += EqnTest(_T("sum(1,2)/sum(3,4)"), (float_type)0.428571, true);
iNumErr += EqnTest(_T("3/sum(3,4,5)"), (float_type)0.25, true);
iNumErr += EqnTest(_T("sum(3)/sum(3,4,5)"), (float_type)0.25, true);
iNumErr += EqnTest(_T("sum(3)+sum(3,4,5)"), (float_type)15, true);
iNumErr += EqnTest(_T("sum(1,2)/sum(3,4,5)"), (float_type)0.25, true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestVector()
{
int iNumErr = 0;
*m_stream << _T("testing vector operations...");
// Vector operations
iNumErr += ThrowTest(_T("10+2*va"), ecEVAL); // fail: number + vector
iNumErr += ThrowTest(_T("10+va*2"), ecEVAL); // fail: number + vector
iNumErr += ThrowTest(_T("va+vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size
iNumErr += ThrowTest(_T("va-vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size
iNumErr += ThrowTest(_T("va*vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size
iNumErr += ThrowTest(_T("va*vb"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch
iNumErr += ThrowTest(_T("va*va"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch
iNumErr += ThrowTest(_T("(va*vb)*b"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch
iNumErr += ThrowTest(_T("va[1.23]"), ecTYPE_CONFLICT_IDX, 7); // fail: float value used as index
iNumErr += ThrowTest(_T("va[sin(8)]"), ecTYPE_CONFLICT_IDX, 9); // fail: float value used as index
iNumErr += ThrowTest(_T("va[-1]"), ecINDEX_OUT_OF_BOUNDS); // fail: negative value used as an index
iNumErr += ThrowTest(_T("va[c]"), ecINDEX_OUT_OF_BOUNDS);
iNumErr += ThrowTest(_T("va[(3)]"), ecINDEX_OUT_OF_BOUNDS);
iNumErr += ThrowTest(_T("a[1]"), ecINDEX_OUT_OF_BOUNDS); // indexing a scalar is ok, but this index is out of bounds (0 would be ok...)
iNumErr += ThrowTest(_T("va[1"), ecMISSING_SQR_BRACKET);
iNumErr += ThrowTest(_T("va[1]]"), ecUNEXPECTED_SQR_BRACKET);
//iNumErr += ThrowTest(_T("va==9"), ecEVAL);
//iNumErr += ThrowTest(_T("va==a"), ecEVAL);
//iNumErr += ThrowTest(_T("a==va"), ecEVAL);
//iNumErr += ThrowTest(_T("9==va"), ecEVAL);
Value v(3, 0);
v.At(0) = (float_type)5.0;
v.At(1) = (float_type)5.0;
v.At(2) = (float_type)5.0;
iNumErr += EqnTest(_T("va+vb"), v, true);
v.At(0) = (float_type)5.0;
v.At(1) = (float_type)5.0;
v.At(2) = (float_type)6.0;
iNumErr += EqnTest(_T("va+vb"), v, false);
v.At(0) = (float_type)-1.0;
v.At(1) = (float_type)-2.0;
v.At(2) = (float_type)-3.0;
iNumErr += EqnTest(_T("-va"), v, true);
iNumErr += EqnTest(_T("sizeof(va+vb)"), 3.0, true);
iNumErr += EqnTest(_T("sizeof(va-vb)"), 3.0, true);
iNumErr += EqnTest(_T("va==vb"), false, true);
iNumErr += EqnTest(_T("va!=vb"), true, true);
//iNumErr += EqnTest(_T("va<vb"), false, true);
//iNumErr += EqnTest(_T("va>vb"), true, true);
//iNumErr += EqnTest(_T("va<=vb"), false, true);
//iNumErr += EqnTest(_T("va>=vb"), true, true);
iNumErr += EqnTest(_T("vb[va[0]]"), 3.0, true);
iNumErr += EqnTest(_T("m1[0,0]+m1[1,1]+m1[2,2]"), 3.0, true);
iNumErr += EqnTest(_T("vb[m1[0,0]]"), 3.0, true);
iNumErr += EqnTest(_T("m1[0,0]=2"), 2.0, true);
iNumErr += EqnTest(_T("m1[1,1]=2"), 2.0, true);
iNumErr += EqnTest(_T("m1[2,2]=2"), 2.0, true);
iNumErr += EqnTest(_T("va[0]=12.3"), (float_type)12.3, true);
iNumErr += EqnTest(_T("va[1]=12.3"), (float_type)12.3, true);
iNumErr += EqnTest(_T("va[2]=12.3"), (float_type)12.3, true);
iNumErr += EqnTest(_T("va[0]"), 1.0, true);
iNumErr += EqnTest(_T("va[1]"), 2.0, true);
iNumErr += EqnTest(_T("va[2]"), 3.0, true);
iNumErr += EqnTest(_T("(va[2])"), 3.0, true);
iNumErr += EqnTest(_T("va[a]"), 2.0, true);
iNumErr += EqnTest(_T("(va[a])"), 2.0, true);
iNumErr += EqnTest(_T("va[b]"), 3.0, true);
iNumErr += EqnTest(_T("va[(2)]"), 3.0, true);
iNumErr += EqnTest(_T("va[-(-2)]"), 3.0, true);
iNumErr += EqnTest(_T("(va[(2)])"), 3.0, true);
iNumErr += EqnTest(_T("(va[-(-2)])"), 3.0, true);
iNumErr += EqnTest(_T("va[1+1]"), 3.0, true);
iNumErr += EqnTest(_T("va[(int)sin(8)+1]"), 2.0, true);
iNumErr += EqnTest(_T("va[2]+4"), 7.0, true);
iNumErr += EqnTest(_T("4+va[2]"), 7.0, true);
iNumErr += EqnTest(_T("va[2]*4"), 12.0, true);
iNumErr += EqnTest(_T("4*va[2]"), 12.0, true);
iNumErr += EqnTest(_T("va[2]+a"), 4.0, true);
iNumErr += EqnTest(_T("a+va[2]"), 4.0, true);
iNumErr += EqnTest(_T("va[2]*b"), 6.0, true);
iNumErr += EqnTest(_T("b*va[2]"), 6.0, true);
// Issue 68 (and related issues):
iNumErr += EqnTest(_T("(abs(-3)+2)>=min(6,5)"), true, true);
iNumErr += EqnTest(_T("(abs(-3))>abs(2)"), true, true);
iNumErr += EqnTest(_T("min(1,2,-3)>-4"), true, true);
iNumErr += EqnTest(_T("(abs(-3))>-2"), true, true);
iNumErr += EqnTest(_T("abs(-3)>abs(2)"), true, true);
// Issue 42:
// https://code.google.com/p/muparserx/issues/detail?id=42
v.At(0) = (float_type)1.0;
v.At(1) = (float_type)0.0;
v.At(2) = (float_type)0.0;
iNumErr += EqnTest(_T("{1,0,0}'"), v, true);
iNumErr += EqnTest(_T("{(1),0,0}'"), v, true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestBinOp()
{
int iNumErr = 0;
*m_stream << _T("testing binary operators...");
float_type a = 1;
// standard aperators
iNumErr += EqnTest(_T("1+7"), (float_type)8.0, true);
iNumErr += EqnTest(_T("10-1"), (float_type)9.0, true);
iNumErr += EqnTest(_T("3*4"), (float_type)12.0, true);
iNumErr += EqnTest(_T("10/2"), (float_type)5.0, true);
// operator associativity
iNumErr += EqnTest(_T("2^2^3"), (float_type)256.0, true);
iNumErr += EqnTest(_T("3+4*2/(1-5)^2^3"), (float_type)3.0001220703125, true);
iNumErr += EqnTest(_T("1/2/3"), (float_type)1.0 / (float_type)6.0, true);
// operator precedencs
iNumErr += EqnTest(_T("1+2-3*4/5^6"), (float_type)2.99923, true);
iNumErr += EqnTest(_T("a+b-c*4/5^6"), (float_type)2.99923, true);
iNumErr += EqnTest(_T("1^2/3*4-5+6"), (float_type)2.3333, true);
iNumErr += EqnTest(_T("a^b/c*4-5+6"), (float_type)2.3333, true);
iNumErr += EqnTest(_T("1+2*3"), (float_type)7.0, true);
iNumErr += EqnTest(_T("a+b*c"), (float_type)7.0, true);
iNumErr += EqnTest(_T("(1+2)*3"), (float_type)9.0, true);
iNumErr += EqnTest(_T("(a+b)*c"), (float_type)9.0, true);
iNumErr += EqnTest(_T("(1+2)*(-3)"), (float_type)-9.0, true);
iNumErr += EqnTest(_T("(a+b)*(-c)"), (float_type)-9.0, true);
iNumErr += EqnTest(_T("2/4"), (float_type)0.5, true);
iNumErr += EqnTest(_T("4&4"), 4.0, true);
iNumErr += EqnTest(_T("2+2&(a+b+c)"), 4.0, true);
iNumErr += EqnTest(_T("3&3"), 3.0, true);
iNumErr += EqnTest(_T("c&3"), 3.0, true);
iNumErr += EqnTest(_T("(c)&3"), 3.0, true);
iNumErr += EqnTest(_T("(a+b)&3"), 3.0, true);
iNumErr += EqnTest(_T("(a+b+c)&6"), 6.0, true);
iNumErr += EqnTest(_T("(1+2+3)&6"), 6.0, true);
iNumErr += EqnTest(_T("3&c"), 3.0, true);
iNumErr += EqnTest(_T("(a<<1)+2"), 4.0, true);
iNumErr += EqnTest(_T("(a<<2)+2"), 6.0, true);
iNumErr += EqnTest(_T("(a<<3)+2"), 10.0, true);
iNumErr += EqnTest(_T("(a<<4)+2"), 18.0, true);
iNumErr += EqnTest(_T("(a<<5)+2"), 34.0, true);
iNumErr += EqnTest(_T("1<<31"), (float_type)2147483648, true);
iNumErr += EqnTest(_T("-1<<31"), (float_type)-2147483648.0, true);
iNumErr += EqnTest(_T("1<<45"), (float_type)35184372088832.0, true);
iNumErr += EqnTest(_T("-1<<45"), (float_type)-35184372088832.0, true);
iNumErr += EqnTest(_T("8<<-2"), 2.0, true);
iNumErr += EqnTest(_T("8<<-4"), 0.0, true);
// Issue 25: http://code.google.com/p/muparserx/issues/detail?id=25
iNumErr += ThrowTest(_T("55<<2222222"), ecOVERFLOW);
// Issue 16: http://code.google.com/p/muparserx/issues/detail?id=16
iNumErr += EqnTest(_T("true == true && false"), true == true && false, true);
iNumErr += EqnTest(_T("false == true && false"), false == true && false, true);
iNumErr += EqnTest(_T("a==1.0 && a==1.0"), a == 1.0 && a == 1.0, true);
// bool operators for comparing values
iNumErr += EqnTest(_T("a<b"), true, true);
iNumErr += EqnTest(_T("b>a"), true, true);
iNumErr += EqnTest(_T("a>a"), false, true);
iNumErr += EqnTest(_T("a<a"), false, true);
iNumErr += EqnTest(_T("a>a"), false, true);
iNumErr += EqnTest(_T("a<=a"), true, true);
iNumErr += EqnTest(_T("a<=b"), true, true);
iNumErr += EqnTest(_T("b<=a"), false, true);
iNumErr += EqnTest(_T("a>=a"), true, true);
iNumErr += EqnTest(_T("b>=a"), true, true);
iNumErr += EqnTest(_T("a>=b"), false, true);
// The following equations were raising type conflict errors once
// since the result of sqrt(1) is 1 which is an integer as fas as muParserX
// is concerned:
iNumErr += EqnTest(_T("sqrt(a)<sin(8)"), false, true);
iNumErr += EqnTest(_T("sqrt(a)<=sin(8)"), false, true);
iNumErr += EqnTest(_T("sqrt(a)>sin(8)"), true, true);
iNumErr += EqnTest(_T("sqrt(a)>=sin(8)"), true, true);
iNumErr += EqnTest(_T("sqrt(a)==sin(8)"), false, true);
iNumErr += EqnTest(_T("sqrt(a)!=sin(8)"), true, true);
iNumErr += EqnTest(_T("sqrt(a)+1.01"), (float_type)2.01, true);
iNumErr += EqnTest(_T("sqrt(a)-1.01"), (float_type)-0.01, true);
// interaction with sign operator
iNumErr += EqnTest(_T("3-(-a)"), 4.0, true);
iNumErr += EqnTest(_T("3--a"), 4.0, true);
// Problems with small bogus real/imag values introduced due to limited floating point accuracy
iNumErr += EqnTest(_T("(-2)^3"), -8.0, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i)
iNumErr += EqnTest(_T("imag((-2)^3)==0"), true, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i)
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestIfElse()
{
int iNumErr = 0;
*m_stream << _T("testing if-else conditional...");
float_type a = 1;
// test case copied from muparser (https://oss-fuzz.com/testcase-detail/4777121158529024)
iNumErr += ThrowTest(_T("3!=min(false?2>2,2>5,1:6)"), ecUNEXPECTED_COMMA);
// test case copied from muparser (https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22922#c1)
iNumErr += ThrowTest(_T("1?2:0?(7:1)"), ecMISPLACED_COLON);
// test case copied from muparser (https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=23410)
// with variations
iNumErr += ThrowTest(_T(R"(false ? 4 : "", ? 4 : "", ? 4 : "")"), ecUNEXPECTED_COMMA);
iNumErr += EqnTest(_T(R"(false ? "four" : 4)"), 4, true);
iNumErr += EqnTest(_T(R"(true ? "four" : 4)"), "four", true);
iNumErr += EqnTest(_T(R"(true ? "foo" : "bar")"), "foo", true);
// test case and variations copied from muparser https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22938
iNumErr += ThrowTest(_T("sum(false?1,0,0:3)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(false?(1,0,0):3)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(2>3?2,4,2:4)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(2>3?2,4,sin(2):4)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(2>3?sin(2),4,2:4)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(2>3?sin(a),4,2:4)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("sum(2>3?sin(2),4,2:4)"), ecUNEXPECTED_COMMA);
// Test error detection
iNumErr += ThrowTest(_T(": 2"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("? 1 : 2"), ecUNEXPECTED_CONDITIONAL);
iNumErr += ThrowTest(_T("(a<b) ? (b<c) ? 1 : 2"), ecMISSING_ELSE_CLAUSE);
iNumErr += ThrowTest(_T("(a<b) ? 1"), ecMISSING_ELSE_CLAUSE);
iNumErr += ThrowTest(_T("(a<b) ? a"), ecMISSING_ELSE_CLAUSE);
iNumErr += ThrowTest(_T("(a<b) ? a+b"), ecMISSING_ELSE_CLAUSE);
iNumErr += ThrowTest(_T("a : b"), ecMISPLACED_COLON, 2);
iNumErr += ThrowTest(_T("1 : 2"), ecMISPLACED_COLON, 2);
iNumErr += ThrowTest(_T("(true) ? 1 : 2 : 3"), ecMISPLACED_COLON);
iNumErr += ThrowTest(_T("1==?"), ecUNEXPECTED_CONDITIONAL);
iNumErr += ThrowTest(_T("1+?"), ecUNEXPECTED_CONDITIONAL); // bin oprt + ?
iNumErr += ThrowTest(_T("1m?"), ecUNEXPECTED_CONDITIONAL); // postfix + ?
iNumErr += ThrowTest(_T("-?"), ecUNEXPECTED_CONDITIONAL); // infix + ?
iNumErr += EqnTest(_T("(true) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("(1<2) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("(a<b) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("((a>b) ? true : false) ? 1 : 2"), 2.0, true);
iNumErr += EqnTest(_T("((a>b) ? true : false) ? 1 : sum((a>b) ? 1 : 2)"), 2.0, true);
iNumErr += EqnTest(_T("((a>b) ? false : true) ? 1 : sum((a>b) ? 1 : 2)"), 1.0, true);
iNumErr += EqnTest(_T("(true) ? 10 : 11"), 10.0, true);
iNumErr += EqnTest(_T("(true) ? a+b : c+d"), 3.0, true);
iNumErr += EqnTest(_T("(true) ? false : true"), false, true);
iNumErr += EqnTest(_T("(false) ? 10 : 11"), 11.0, true);
iNumErr += EqnTest(_T("(false) ? a+b : c+d"), 1.0, true);
iNumErr += EqnTest(_T("(false) ? false : true"), true, true);
iNumErr += EqnTest(_T("(a<b) ? 10 : 11"), 10.0, true);
iNumErr += EqnTest(_T("(a>b) ? 10 : 11"), 11.0, true);
iNumErr += EqnTest(_T("(a<b) ? c : d"), 3.0, true);
iNumErr += EqnTest(_T("(a>b) ? c : d"), -2.0, true);
iNumErr += EqnTest(_T("(a>b) ? true : false"), false, true);
// With multiarg functions
iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2)"), 2.0, true);
iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2, 100)"), 102.0, true);
iNumErr += EqnTest(_T("sum((true) ? 1 : 2)"), 1.0, true);
iNumErr += EqnTest(_T("sum((true) ? 1 : 2, 100)"), 101.0, true);
iNumErr += EqnTest(_T("sum(3, (a>b) ? 3 : 10)"), 13.0, true);
iNumErr += EqnTest(_T("sum(3, (a<b) ? 3 : 10)"), 6., true);
iNumErr += EqnTest(_T("sum(3, (a>b) ? 3 : 10)*10"), 130.0, true);
iNumErr += EqnTest(_T("sum(3, (a<b) ? 3 : 10)*10"), 60.0, true);
iNumErr += EqnTest(_T("10*sum(3, (a>b) ? 3 : 10)"), 130.0, true);
iNumErr += EqnTest(_T("10*sum(3, (a<b) ? 3 : 10)"), 60.0, true);
iNumErr += EqnTest(_T("(a<b) ? sum(3, (a<b) ? 3 : 10)*10 : 99"), 60.0, true);
iNumErr += EqnTest(_T("(a>b) ? sum(3, (a<b) ? 3 : 10)*10 : 99"), 99.0, true);
iNumErr += EqnTest(_T("(a<b) ? sum(3, (a<b) ? 3 : 10,10,20)*10 : 99"), 360.0, true);
iNumErr += EqnTest(_T("(a>b) ? sum(3, (a<b) ? 3 : 10,10,20)*10 : 99"), 99.0, true);
iNumErr += EqnTest(_T("(a>b) ? sum(3, (a<b) ? 3 : 10,10,20)*10 : sum(3, (a<b) ? 3 : 10)*10"), 60.0, true);
iNumErr += EqnTest(_T("(a<b)&&(a<b) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("(a>b)&&(a<b) ? 128 : 255"), 255.0, true);
iNumErr += EqnTest(_T("(1<2)&&(1<2) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("(1>2)&&(1<2) ? 128 : 255"), 255.0, true);
iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255.0, true);
iNumErr += EqnTest(_T("((a<b)&&(a<b)) ? 128 : 255"), 128.0, true);
iNumErr += EqnTest(_T("((a>b)&&(a<b)) ? 128 : 255"), 255.0, true);
// nested conditionals with brackets
iNumErr += EqnTest(_T("(a<b) ? ((b<c) ? 2*(a+b) : 2) : 3"), 6., true);
iNumErr += EqnTest(_T("(a<b) ? 3 : ((b<c) ? 2*(a+b) : 2)"), 3., true);
iNumErr += EqnTest(_T("(a<b) ? ((b>c) ? 1 : 2) : 3"), 2., true);
iNumErr += EqnTest(_T("(a>b) ? ((b<c) ? 1 : 2) : 3"), 3., true);
iNumErr += EqnTest(_T("(a>b) ? ((b>c) ? 1 : 2) : 3"), 3., true);
// nested conditionals without brackets
iNumErr += EqnTest(_T("(a<b) ? (b<c) ? 1 : 2 : 3"), 1., true);
iNumErr += EqnTest(_T("(a<b) ? (b>c) ? 1 : 2 : 3"), 2., true);
iNumErr += EqnTest(_T("(a>b) ? (b<c) ? 1 : 2 : 3"), 3., true);
iNumErr += EqnTest(_T("(a>b) ? (b>c) ? 1 : 2 : 3"), 3., true);
// Neue Tests
iNumErr += EqnTest(_T("(a<b)&&(a<b) ? 128 : 255"), 128., true);
iNumErr += EqnTest(_T("(a>b)&&(a<b) ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("(1<2)&&(1<2) ? 128 : 255"), 128., true);
iNumErr += EqnTest(_T("(1>2)&&(1<2) ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128., true);
iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("((a<b)&&(a<b)) ? 128 : 255"), 128., true);
iNumErr += EqnTest(_T("((a>b)&&(a<b)) ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 255., true);
iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 :(1>0 ? 32 : 64)"), 255., true);
iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 128., true);
iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 :(1>2 ? 32 : 64)"), 128., true);
iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 32., true);
iNumErr += EqnTest(_T("1>2 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 64., true);
iNumErr += EqnTest(_T("1>0 ? 50 : 1>0 ? 128 : 255"), 50., true);
iNumErr += EqnTest(_T("1>0 ? 50 : (1>0 ? 128 : 255)"), 50., true);
iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 50"), 128., true);
iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 1>2 ? 64 : 16"), 32., true);
iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 :(1>2 ? 64 : 16)"), 32., true);
iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : 1>0 ? 32 :1>2 ? 64 : 16"), 255., true);
iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : (1>0 ? 32 :1>2 ? 64 : 16)"), 255., true);
iNumErr += EqnTest(_T("true ? false ? 128 : 255 : true ? 32 : 64"), 255., true);
// assignment operators
iNumErr += EqnTest(_T("a= false ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("a=((a>b)&&(a<b)) ? 128 : 255"), 255., true);
iNumErr += EqnTest(_T("c=(a<b)&&(a<b) ? 128 : 255"), 128., true);
iNumErr += EqnTest(_T("a=true?b=true?3:4:5"), 3., true);
iNumErr += EqnTest(_T("a=false?b=true?3:4:5"), 5., true);
iNumErr += EqnTest(_T("a=true?5:b=true?3:4"), 5., true);
iNumErr += EqnTest(_T("a=false?5:b=true?3:4"), 3., true);
// Issue 42: ?: operator must be last in expression
// https://code.google.com/p/muparserx/issues/detail?id=42
iNumErr += EqnTest(_T("abs(0.1) < 0.25 ? (-1) : (1) + 1"), fabs(0.1) < 0.25 ? (-1.) : (1.) + 1, true);
iNumErr += EqnTest(_T("abs(a) < 0.25 ? (-1) : (1) + 1"), fabs(a) < 0.25 ? (-1.) : (1.) + 1, true);
iNumErr += EqnTest(_T("(abs(a) < 0.25 ? -1 : 1)"), (abs(a) < 0.25 ? -1. : 1.), true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestEqn()
{
int iNumErr = 0;
*m_stream << _T("testing sample equations...");
// test case copied from muparser: https://oss-fuzz.com/testcase-detail/5106868061208576
iNumErr += ThrowTest(_T(R"("","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",8)"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T(R"("","",9)"), ecUNEXPECTED_COMMA);
// test case copied from muparser: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=23330#c1
iNumErr += ThrowTest(_T("6, +, +, +, +, +, +, +, +, +, +, +, +, +, +, 1, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +, +"), ecUNEXPECTED_COMMA);
iNumErr += ThrowTest(_T("1e1234"), ecUNASSIGNABLE_TOKEN);
iNumErr += ThrowTest(_T("-1e1234"), ecUNASSIGNABLE_TOKEN);
iNumErr += EqnTest(_T("-2--8"), (float_type)6.0, true);
iNumErr += EqnTest(_T("2*(a=9)*3"), 54., true);
// Functions
iNumErr += EqnTest(_T("10*strlen(toupper(\"12345\"))"), 50., true);
// hex value recognition
iNumErr += EqnTest(_T("0xff"), 255., true);
iNumErr += EqnTest(_T("10+0xff"), 265., true);
iNumErr += EqnTest(_T("0xff+10"), 265., true);
iNumErr += EqnTest(_T("10*0xff"), 2550., true);
iNumErr += EqnTest(_T("0xff*10"), 2550., true);
iNumErr += EqnTest(_T("10+0xff+1"), 266., true);
iNumErr += EqnTest(_T("1+0xff+10"), 266., true);
// ...
iNumErr += EqnTest(_T("exp(ln(7))"), 7., true);
iNumErr += EqnTest(_T("e^ln(7)"), 7., true);
iNumErr += EqnTest(_T("e^(ln(7))"), 7., true);
iNumErr += EqnTest(_T("(e^(ln(7)))"), 7., true);
iNumErr += EqnTest(_T("1-(e^(ln(7)))"), -6., true);
iNumErr += EqnTest(_T("2*(e^(ln(7)))"), 14., true);
iNumErr += EqnTest(_T("10^log10(5)"), 5., true);
iNumErr += EqnTest(_T("10^log10(5)"), 5., true);
iNumErr += EqnTest(_T("2^log2(4)"), (float_type)4.0, true);
iNumErr += EqnTest(_T("-(sin(0)+1)"), (float_type)-1.0, true);
iNumErr += EqnTest(_T("-(2^1.1)"), (float_type)-2.14354692, true);
// infix + postfix operator in arguments for binary operators (Reference: Matlab)
iNumErr += EqnTest(_T("-sin(8)m*6"), (float_type)-0.00593615, true);
iNumErr += EqnTest(_T("-sin(8)m/6"), (float_type)-1.6489e-4, true);
iNumErr += EqnTest(_T("-sin(8)m+6"), (float_type)5.99901, true);
iNumErr += EqnTest(_T("-sin(8)m-6"), (float_type)-6.000989, true);
iNumErr += EqnTest(_T("(cos(2.41)/b)"), (float_type)-0.372056, true);
// long formula (Reference: Matlab)
iNumErr += EqnTest(
_T("(((-9))-e/(((((((pi-(((-7)+(-3)/4/e))))/(((-5))-2)-((pi+(-0))*(sqrt((e+e))*(-8))*(((-pi)+(-pi)-(-9)*(6*5))")
_T("/(-e)-e))/2)/((((sqrt(2/(-e)+6)-(4-2))+((5/(-2))/(1*(-pi)+3))/8)*pi*((pi/((-2)/(-6)*1*(-1))*(-6)+(-e)))))/")
_T("((e+(-2)+(-e)*((((-3)*9+(-e)))+(-9)))))))-((((e-7+(((5/pi-(3/1+pi)))))/e)/(-5))/(sqrt((((((1+(-7))))+((((-")
_T("e)*(-e)))-8))*(-5)/((-e)))*(-6)-((((((-2)-(-9)-(-e)-1)/3))))/(sqrt((8+(e-((-6))+(9*(-9))))*(((3+2-8))*(7+6")
_T("+(-5))+((0/(-e)*(-pi))+7)))+(((((-e)/e/e)+((-6)*5)*e+(3+(-5)/pi))))+pi))/sqrt((((9))+((((pi))-8+2))+pi))/e")
_T("*4)*((-5)/(((-pi))*(sqrt(e)))))-(((((((-e)*(e)-pi))/4+(pi)*(-9)))))))+(-pi)"), (float_type)-12.23016549, true);
// long formula (Reference: Matlab)
iNumErr += EqnTest(_T("1+2-3*4/5^6*(2*(1-5+(3*7^9)*(4+6*7-3)))+12"), (float_type)-7995810.09926, true);
/* <ibg 20100321 atan currently unsupported/>
// long formula (Reference: Matlab)
iNumErr += EqnTest(
"(atan(sin((((((((((((((((pi/cos((a/((((0.53-b)-pi)*e)/b))))+2.51)+a)-0.54)/0.98)+b)*b)+e)/a)+b)+a)+b)+pi)/e"
")+a)))*2.77)", -2.16995656, true);
*/
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestScript()
{
int iNumErr = 0;
*m_stream << _T("testing script features...");
// Test error detection
iNumErr += ThrowTest(_T("sin(\n"), ecUNEXPECTED_NEWLINE);
iNumErr += ThrowTest(_T("1+\n"), ecUNEXPECTED_NEWLINE);
iNumErr += ThrowTest(_T("a*\n"), ecUNEXPECTED_NEWLINE);
iNumErr += ThrowTest(_T("va[\n"), ecUNEXPECTED_NEWLINE);
iNumErr += ThrowTest(_T("(true) ? \n"), ecUNEXPECTED_NEWLINE);
iNumErr += ThrowTest(_T("(true) ? 10:\n"), ecUNEXPECTED_NEWLINE);
// Expressions spanning multiple lines
iNumErr += EqnTest(_T("a=1\n")
_T("b=2\n")
_T("c=3\n")
_T("a+b+c"), 6., true);
// Ending an expression with a newline
iNumErr += EqnTest(_T("3\n"), 3., true);
iNumErr += EqnTest(_T("1+2\n"), 3., true);
iNumErr += EqnTest(_T("\n1+2\n"), 3., true);
iNumErr += EqnTest(_T("\n1+2\n\na+b"), 3., true);
// Testing comments
/* 20130107 Not yet...
iNumErr += EqnTest(_T("a=10 % this is a comment\n")
_T("b=23 % this is another comment\n")
_T("a+b"), 33, true);
*/
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
int ParserTester::TestValReader()
{
int iNumErr = 0;
*m_stream << _T("testing value reader...");
// Hex value reader
iNumErr += EqnTest(_T("0x1"), 1., true);
iNumErr += EqnTest(_T("0x1+0x2"), 3., true);
iNumErr += EqnTest(_T("0xff"), 255., true);
// Reading of binary values
iNumErr += EqnTest(_T("0b1"), 1., true);
iNumErr += EqnTest(_T("0b01"), 1., true);
iNumErr += EqnTest(_T("0b11"), 3., true);
iNumErr += EqnTest(_T("0b011"), 3., true);
iNumErr += EqnTest(_T("0b11111111"), 255., true);
iNumErr += EqnTest(_T("b*0b011"), 6.0, true);
iNumErr += EqnTest(_T("0b1111111111111111111111111111111"), 2147483647., true);
iNumErr += EqnTest(_T("0b10000000000000000000000000000000"), -2147483647. - 1, true);
iNumErr += EqnTest(_T("0b11111111111111111111111111111111"), -1., true);
iNumErr += ThrowTest(_T("0b100000000000000000000000000000000"), ecUNDEFINED);
// string value reader
iNumErr += EqnTest(_T("\"hallo\""), _T("hallo"), true);
// boolean value reader
iNumErr += EqnTest(_T("true"), true, true);
iNumErr += EqnTest(_T("false"), false, true);
// boolean value reader
iNumErr += EqnTest(_T("true"), true, true);
iNumErr += EqnTest(_T("false"), false, true);
// mixed
iNumErr += EqnTest(_T("0b011+0xef"), 242., true);
Assessment(iNumErr);
return iNumErr;
}
//---------------------------------------------------------------------------
void ParserTester::AddTest(testfun_type a_pFun)
{
m_vTestFun.push_back(a_pFun);
}
//---------------------------------------------------------------------------
void ParserTester::Run()
{
int iStat = 0;
try
{
for (int i = 0; i < (int)m_vTestFun.size(); ++i)
iStat += (this->*m_vTestFun[i])();
}
catch (ParserError &e)
{
*m_stream << e.GetMsg() << endl;
*m_stream << e.GetToken() << endl;
Abort();
}
catch (std::exception &e)
{
*m_stream << e.what() << endl;
Abort();
}
catch (...)
{
*m_stream << _T("Internal error");
Abort();
}
if (iStat == 0)
{
*m_stream << _T("Test passed (") << ParserTester::c_iCount << _T(" expressions)") << endl;
}
else
{
*m_stream << _T("Test failed with ") << iStat
<< _T(" errors (") << ParserTester::c_iCount
<< _T(" expressions)") << endl;
}
ParserTester::c_iCount = 0;
#ifdef MUP_LEAKAGE_REPORT
// All tokens must have been destroyed by now, verify this
IToken::LeakageReport();
#endif
}
//---------------------------------------------------------------------------
int ParserTester::ThrowTest(const string_type &a_sExpr, int a_nErrc, int a_nPos, string_type a_sIdent)
{
ParserTester::c_iCount++;
try
{
ParserX p;
// Add variables
Value vVarVal[] = { 1., 2., 3., -2. };
p.DefineVar(_T("a"), Variable(&vVarVal[0]));
p.DefineVar(_T("b"), Variable(&vVarVal[1]));
p.DefineVar(_T("c"), Variable(&vVarVal[2]));
p.DefineVar(_T("d"), Variable(&vVarVal[3]));
// array variables
Value aVal1(3, 0);
aVal1.At(0) = (float_type)1.0;
aVal1.At(1) = (float_type)2.0;
aVal1.At(2) = (float_type)3.0;
Value aVal2(3, 0);
aVal2.At(0) = (float_type)4.0;
aVal2.At(1) = (float_type)3.0;
aVal2.At(2) = (float_type)2.0;
Value aVal3(4, 0);
aVal3.At(0) = (float_type)4.0;
aVal3.At(1) = (float_type)3.0;
aVal3.At(2) = (float_type)2.0;
aVal3.At(3) = (float_type)5.0;
Value aVal4(4, 0);
aVal4.At(0) = (float_type)4.0;
aVal4.At(1) = false;
aVal4.At(2) = _T("hallo");
// Matrix variables
Value m1(3, 3, 0);
m1.At(0, 0) = 1.;
m1.At(1, 1) = 1.;
m1.At(2, 2) = 1.;
Value m2(3, 3, 0);
m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.;
m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.;
m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.;
p.DefineVar(_T("m1"), Variable(&m1));
p.DefineVar(_T("m2"), Variable(&m2));
p.DefineVar(_T("va"), Variable(&aVal1));
p.DefineVar(_T("vb"), Variable(&aVal2));
p.DefineVar(_T("vc"), Variable(&aVal3));
p.DefineVar(_T("vd"), Variable(&aVal4));
p.SetExpr(a_sExpr);
Value fRes = p.Eval();
}
catch (ParserError &e)
{
// output the formula in case of an failed test
if (a_nErrc != e.GetCode())
{
*m_stream << _T("\n ")
<< _T("Expression: \"") << a_sExpr
<< _T("\" Code:") << e.GetCode()
<< _T(" Expected:") << a_nErrc;
}
// Check whether the error is reported at the correct expression position
if (a_nPos != -1 && a_nPos != e.GetPos())
{
*m_stream << _T("\n ")
<< _T("Invalid error position: \"") << a_sExpr
<< _T("\" Pos:") << e.GetPos()
<< _T(" Expected:") << a_nPos;
}
if (a_sIdent.length() && a_sIdent != e.GetContext().Ident)
{
*m_stream << _T("\n ")
<< _T("Invalid identifier: \"") << a_sExpr
<< _T("\" Ident:") << e.GetContext().Ident
<< _T(" Expected:") << a_sIdent;
}
return (a_nErrc == e.GetCode() && (a_nPos == -1 || a_nPos == e.GetPos())) ? 0 : 1;
}
*m_stream << _T("\n ")
<< _T("Expression failed: \"")
<< a_sExpr
<< _T("\" (no exception raised).");
return 1;
}
//---------------------------------------------------------------------------
int ParserTester::EqnTest(const string_type &a_str, Value a_val, bool a_fPass, int nExprVar)
{
ParserTester::c_iCount++;
int iRet(1);
Value fVal[5];
try
{
// p1 is a pointer since I'm going to delete it in order to test if
// parsers after copy construction still refer to members of the deleted object.
// !! If this is the case this function will crash !!
std::unique_ptr<ParserX> p1(new ParserX());
// Add variables
Value vVarVal[] = { 1., 2., 3., -2., -1. };
// m1 ist die Einheitsmatrix
Value m1(3, 3, 0);
m1.At(0, 0) = 1.;
m1.At(1, 1) = 1.;
m1.At(2, 2) = 1.;
// m2 ist die Einheitsmatrix
Value m2(3, 3, 0);
m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.;
m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.;
m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.;
p1->DefineOprt(new DbgSillyAdd);
p1->DefineFun(new FunTest0);
p1->DefineVar(_T("a"), Variable(&vVarVal[0]));
p1->DefineVar(_T("b"), Variable(&vVarVal[1]));
p1->DefineVar(_T("c"), Variable(&vVarVal[2]));
p1->DefineVar(_T("d"), Variable(&vVarVal[3]));
p1->DefineVar(_T("f"), Variable(&vVarVal[4]));
p1->DefineVar(_T("m1"), Variable(&m1));
p1->DefineVar(_T("m2"), Variable(&m2));
// Add constants
p1->DefineConst(_T("const"), 1.);
p1->DefineConst(_T("const1"), 2.);
p1->DefineConst(_T("const2"), 3.);
// some vector variables
Value aVal1(3, 0);
aVal1.At(0) = (float_type)1.0;
aVal1.At(1) = (float_type)2.0;
aVal1.At(2) = (float_type)3.0;
Value aVal2(3, 0);
aVal2.At(0) = (float_type)4.0;
aVal2.At(1) = (float_type)3.0;
aVal2.At(2) = (float_type)2.0;
p1->DefineVar(_T("va"), Variable(&aVal1));
p1->DefineVar(_T("vb"), Variable(&aVal2));
// complex variables
Value cVal[3];
cVal[0] = mup::cmplx_type(1, 1);
cVal[1] = mup::cmplx_type(2, 3);
cVal[2] = mup::cmplx_type(3, 4);
p1->DefineVar(_T("ca"), Variable(&cVal[0]));
p1->DefineVar(_T("cb"), Variable(&cVal[1]));
p1->DefineVar(_T("cc"), Variable(&cVal[2]));
p1->SetExpr(a_str);
fVal[0] = p1->Eval();
// Test copy and assignement operators
std::vector<ParserX> vParser;
vParser.push_back(*p1); // Push p1 into the vector
ParserX p2 = vParser[0]; // take parser from vector
// destroy the originals from p2
vParser.clear(); // delete the vector
p1.reset(0); // delete the original
fVal[1] = p2.Eval(); // If copy constructions does not work
// we may see a crash here
// Test assignement operator
// additionally disable Optimizer this time
ParserX p3;
p3 = p2;
fVal[2] = p3.Eval(); // If assignment does not work
// we may see a crash here
// Calculating a second time will parse from rpn rather than from
// string. The result must be the same...
fVal[3] = p3.Eval();
// Calculate yet another time. There is the possibility of
// changing variables as a side effect of expression
// evaluation. So there are really bugs that could make this fail...
fVal[4] = p3.Eval();
// Check i number of used variables is correct
if (nExprVar != -1)
{
std::size_t n2 = p2.GetExprVar().size();
std::size_t n3 = p3.GetExprVar().size();
if (n2 + n3 != 2 * n2 || int(n2) != nExprVar)
{
*m_stream << _T(" Number of expression variables is incorrect. (expected: ")
<< nExprVar << _T("; detected: ") << n2 << _T(")");
}
}
// Check the three results
// 1.) computed results must have identic type
char_type cType = fVal[0].GetType();
bool bStat = cType == fVal[1].GetType() &&
cType == fVal[2].GetType() &&
cType == fVal[3].GetType() &&
cType == fVal[4].GetType();
if (!bStat)
{
*m_stream << _T("\n ") << a_str << _T(" : inconsistent result type (")
<< fVal[0].GetType() << _T(", ")
<< fVal[1].GetType() << _T(", ")
<< fVal[2].GetType() << _T(", ")
<< fVal[3].GetType() << _T(", ")
<< fVal[4].GetType() << _T(")");
return 1;
}
if ((cType == 'c' || a_val.GetType() == 'c') && cType != a_val.GetType())
{
*m_stream << _T("\n ") << a_str << _T(" : Complex value sliced!");
return 1;
}
// Compare the results
switch (cType)
{
case 'i':
case 'b':
case 's': bStat = (a_val == fVal[0] &&
a_val == fVal[1] &&
a_val == fVal[2] &&
a_val == fVal[3] &&
a_val == fVal[4]);
break;
// We need more attention for comaring float values due to floating point
// inaccuracies.
case 'f':
{
bStat = true;
int num = sizeof(fVal) / sizeof(Value);
for (int i = 0; i < num; ++i)
bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= fabs(fVal[i].GetFloat()*0.0001));
}
break;
case 'c':
{
bStat = true;
int num = sizeof(fVal) / sizeof(Value);
for (int i = 0; i < num; ++i)
{
bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= std::max((float_type)1e-15, fabs(fVal[i].GetFloat() * (float_type)0.0000001)));
bStat &= (fabs(a_val.GetImag() - fVal[i].GetImag()) <= std::max((float_type)1e-15, fabs(fVal[i].GetImag() * (float_type)0.0000001)));
}
}
break;
case 'm':
{
bStat = true;
int num = sizeof(fVal) / sizeof(Value);
for (int i = 0; i < num; ++i)
{
struct CheckArray
{
CheckArray()
{}
bool Check(IValue &v1, IValue &v2)
{
if (v1.GetType() != v2.GetType())
return false;
if (v1.GetRows() != v2.GetRows())
return false;
if (v1.IsMatrix())
{
for (int i = 0; i < v1.GetRows(); ++i)
{
for (int j = 0; j < v1.GetCols(); ++j)
{
if (!Check(v1.At(i, j), v2.At(i, j)))
return false;
}
}
return true;
}
else
{
return (fabs(v1.GetFloat() - v2.GetFloat()) <= std::max((float_type)1e-15, fabs(v1.GetFloat() * (float_type)0.0000001)));
}
}
} checker;
bStat = checker.Check(a_val, fVal[i]);
if (!bStat)
break;
}
}
break;
default:
throw std::runtime_error("Parser return value has an unexpected typecode.");
}
iRet = (bStat == a_fPass) ? 0 : 1;
}
catch (ParserError &e)
{
*m_stream << _T("\n ") << a_str << _T(" : ") << e.GetMsg();
return 1;
}
catch (std::exception &e)
{
*m_stream << _T("\n ") << a_str << _T(" : ") << e.what() << _T("\n");
return 1;
}
catch (...)
{
*m_stream << _T("\n \"") << a_str << _T("\" : ") << _T("Unexpected Eception");
return 1;
}
if (iRet)
{
*m_stream << _T("\n ") << a_str << _T(" : ") << _T("(at least one incorrect result ")
<< fVal[0] << _T(", ")
<< fVal[1] << _T(", ")
<< fVal[2] << _T(", ")
<< fVal[3] << _T(", ")
<< fVal[4] << _T("; expected=") << a_val << _T(")");
}
return iRet;
}
//---------------------------------------------------------------------------
/** \brief Internal error in test class Test is going to be aborted. */
void ParserTester::Abort() const
{
*m_stream << _T("\nTest failed (internal error in test class)") << endl;
while (!getchar());
exit(-1);
}
//---------------------------------------------------------------------------
void ParserTester::Assessment(int a_iNumErr) const
{
if (a_iNumErr == 0)
*m_stream << _T("passed") << endl;
else
*m_stream << _T("\n failed with ") << a_iNumErr << _T(" errors") << endl;
}
MUP_NAMESPACE_END
Reference in New Issue Copy Permalink