def test_numeric_range_issue(self): print("\n\n\n" + " Test if Numeric Range Checked ".center(75, "#")) test_str = "1/x" target_str = "1/x**20" response = api.check(test_str, target_str) self.assertTrue("error" in response, 'Expected "error" in response!') self.assertTrue("Too Large Range" in response["error"], 'Expected warning about numeric range "{}"!'.format(response["error"])) print(" PASS ".center(75, "#"))
def test_unsafe_input(self): print("\n\n\n" + " Test if Unsafe Input Detected ".center(75, "#")) test_str = "A @ B" target_str = "A * B" response = api.check(test_str, target_str) # Implicitly we're testing no unhandled exceptions. self.assertTrue("error" in response, 'Expected "error" in response!') print(" PASS ".center(75, "#"))
def test_invalid_test_str(self): print("\n\n\n" + " Test if Invalid Test Str Detected ".center(75, "#")) test_str = "A + B + " target_str = "A + B" response = api.check(test_str, target_str) # Implicitly we're testing no unhandled exceptions. self.assertTrue("error" in response, 'Expected "error" in response!') self.assertTrue("code" not in response, 'Expected "code" in response!') print(" PASS ".center(75, "#"))
def test_invalid_plus_minus_values(self): print("\n\n\n" + " Test Invalid Plus-Minus Sign Result ".center(75, "#")) test_str = "x ± 1" target_str_1 = "x/(1 ± 1)" target_str_2 = "x/(1 ± -1)" response_1 = api.check(test_str, target_str_1) self.assertTrue("error" in response_1, 'Expected "error" in response!') self.assertTrue("case" in response_1, 'Key "case" not in response!') self.assertTrue(response_1["case"] == "-", 'Unexpected "case": "{}"!'.format(response_1["case"])) print("Negative case error correctly detected.") response_2 = api.check(test_str, target_str_2) self.assertTrue("error" in response_2, 'Expected "error" in response!') self.assertTrue("case" in response_2, 'Key "case" not in response!') self.assertTrue(response_2["case"] == "+", 'Unexpected "case": "{}"!'.format(response_2["case"])) print("Positive case error correctly detected.") print(" PASS ".center(75, "#"))
def test_custom_symbols_accepted(self): print("\n\n\n" + " Test if Custom Symbols Work ".center(75, "#")) test_str = "test == abcd / d" target_str = "test == abc" symbols = "test, abcd, abc" response = api.check(test_str, target_str, symbols=symbols, check_symbols=False) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) print(" PASS ".center(75, "#"))
def test_syntax_error(self): print("\n\n\n" + " Test if Syntax Errors are Reported ".center(75, "#")) test_str = "(a + b +" target_str = "a + b" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" in response, 'Expected "error" in response!') self.assertTrue("syntax_error" in response, 'Key "syntax_error" not in response!') self.assertTrue(response["syntax_error"] == "true", 'Expected "syntax_error" to be "true", got "{}"!'.format(response["syntax_error"])) print(" PASS ".center(75, "#"))
def test_invalid_target(self): print("\n\n\n" + " Test if Invalid Target Detected ".center(75, "#")) test_str = "A + B" target_str = "A + B + " response = api.check(test_str, target_str) # Implicitly we're testing no unhandled exceptions. self.assertTrue("error" in response, 'Expected "error" in response!') self.assertTrue("code" in response, 'Expected "code" in response!') self.assertTrue(response["code"] == 400, 'Expected error "code" 400 in response, got "{}"!'.format(response["code"])) print(" PASS ".center(75, "#"))
def test_missing_plus_minus(self): print("\n\n\n" + " Test Missing Plus-Minus Sign ".center(75, "#")) test_str = "A ± B" target_str = "A + B" response = api.check(test_str, target_str) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_single_variables_unequal(self): print("\n\n\n" + " Test if Two Single Variables can be found Unequal ".center(75, "#")) test_str = "x" target_str = "y" symbols = None response = api.check(test_str, target_str, symbols=symbols, check_symbols=False) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_simplify_fractions_symbolic(self): print("\n\n\n" + " Test Fractions can be Simplified for Symbolic not Exact Match ".center(75, "#")) test_str = "(2*x*y*x)/(2*x*y*y)" target_str = "x/y" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_lone_unary_minus(self): print("\n\n\n" + " Test Lone Unary Minus is Consistent ".center(75, "#")) test_str = "-xyz" target_str = "-(xyz)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_main_trig_functions_symbolic(self): print("\n\n\n" + " Test if sin, cos and tan and inverses Work Symbolically ".center(75, "#")) test_str = "arcsin(x) + arccos(x) + arctan(x) + sin(x)**2 + cos(x)**2 + tan(x)" target_str = "1 + tan(x) + arcsin(x) + arccos(x) + arctan(x)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_brackets_expand_symbolic(self): print("\n\n\n" + " Test Brackets can be Expanded for Symbolic Match ".center(75, "#")) test_str = "(x + 1)(x + 1)" target_str = "x**2 + 2*x + 1" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_plus_or_minus(self): print("\n\n\n" + " Test if The ± Symbol Works ".center(75, "#")) test_str = "a ± b" target_str = "a ± b" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_single_variables_equal(self): print("\n\n\n" + " Test if Single Variables can be Equal ".center(75, "#")) test_str = "x" target_str = "x" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_compound_symbols_accepted(self): print("\n\n\n" + " Test if Compound Symbols Work ".center(75, "#")) test_str = "v_zmf**(2) == v_x**2 + v_y**2" target_str = "v_zmf * v_zmf == v_x * v_x + v_y * v_y" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_main_trig_functions_capitalised_symbolic(self): print("\n\n\n" + " Test if Trig Functions Work with Title Case Names ".center(75, "#")) test_str = "ArcSin(x) + ArcCos(x) + ArcTan(x) + Sin(x)**2 + Cos(x)**2 + Tan(x)" target_str = "1 + tan(x) + arcsin(x) + arccos(x) + arctan(x)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_addition_order_exact_match(self): print("\n\n\n" + " Test if Addition Order matters for Exact Match ".center(75, "#")) test_str = "1 + x" target_str = "x + 1" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_large_bracket_expression(self): print("\n\n\n" + " Test Lots of Brackets and ^ in Expression ".center(75, "#")) test_str = "720 + 1764 x + 1624 x^2 + 735 x^3 + 175 x^4 + 21 x^5 + x^6" target_str = "(x+1)(x+2)(x+3)(x+4)(x+5)(x+6)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_logarithms(self): print("\n\n\n" + " Test if Logarithms Work ".center(75, "#")) test_str = "x*log(x)/log(10) + ln(3) + ln(2)" target_str = "log(x,10)*x + ln(6)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_equations(self): print("\n\n\n" + " Test if Equations Can be Parsed and Checked ".center(75, "#")) test_str = "x**2 + x + 1 == 0" target_str = "x + 1 + x**2 == 0" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_disallowed_extra_variables(self): print("\n\n\n" + " Enforce Only Allowed Symbols ".center(75, "#")) test_str = "sin(exp(sqrt(2*x)))**2 + cos(exp(sqrt(x))**sqrt(2))**2" target_str = "1" symbols = None response = api.check(test_str, target_str, symbols=symbols, check_symbols=True) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For enforced symbols, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_extra_test_variables(self): print("\n\n\n" + " Test N+1 Variable Test Expression ".center(75, "#")) test_str = "sin(exp(sqrt(2*x)))**2 + cos(exp(sqrt(x))**sqrt(2))**2" target_str = "1" symbols = None response = api.check(test_str, target_str, symbols=symbols, check_symbols=False) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_unary_minus_fraction(self): print("\n\n\n" + " Test Unary Minus in Fractions ".center(75, "#")) test_str = "-x/-y" target_str = "x/y" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_strict_inequalities(self): print("\n\n\n" + " Test if Strict Inequalities Can be Distinguished ".center(75, "#")) test_str = "x**2 + x + 1 > 0" target_str = "x + 1 + x**2 >= 0" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_sqrt_x_squared(self): print("\n\n\n" + " Test Square Root of x Squared ".center(75, "#")) test_str = "sqrt(x**2)" target_str = "x" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "symbolic", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_derivatives_not_simplifed(self): print("\n\n\n" + " Test Derivatives Are Not Simplified ".center(75, "#")) test_str = "Derivative(cos(x)**2, x)" target_str = "-2 sin(x)cos(x)" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "false", 'Expected "equal" to be "false", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "numeric", 'For these expressions, expected "equality_type" to be "symbolic", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def test_keywords_not_special(self): print("\n\n\n" + " Test if Python Keywords are Ignored ".center(75, "#")) test_str = "2as + 4for + is + print" target_str = "2*a*s + 4*f*o*r + i*s + p*r*i*n*t" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))
def check_maths(): """Check the equivalence of two mathematical expressions.""" body = request.get_json(force=True) if not (("test" in body) and ("target" in body)): print("=" * 50) print("ERROR: Ill-formed request!") print(body) print("=" * 50) abort(400) # Probably want to just abort with a '400 BAD REQUEST' target_str = body.get("target") test_str = body.get("test") description = body.get("description") if (target_str == "") or (test_str == ""): print("=" * 50) if description is not None: print(description) print("=" * 50) print("ERROR: Empty string in request!") print("Target: '{0}'\nTest: '{1}'".format(target_str, test_str)) print("=" * 50) abort(400) # Probably want to just abort with a '400 BAD REQUEST' symbols = body.get("symbols") check_symbols = str(body.get("check_symbols", "true")).lower() == "true" # To reduce computation issues on single-threaded server, institute a timeout # for requests. If it takes longer than this to process, return an error. # This cannot interrupt numpy's computation, so care must be taken in selecting # a value for MAX_REQUEST_COMPUTATION_TIME. try: with TimeoutProtection(MAX_REQUEST_COMPUTATION_TIME): response_dict = maths.check(test_str, target_str, symbols=symbols, check_symbols=check_symbols, description=description) return jsonify(**response_dict) except TimeoutException as e: print("ERROR: {} - Request took too long to process, aborting!".format( type(e).__name__)) print("=" * 50) error_dict = dict( target=target_str, test=test_str, error="Request took too long to process!", ) return jsonify(**error_dict)
def test_implicit_multiplication(self): print("\n\n\n" + " Test that Implicit Multiplication Works ".center(75, "#")) test_str = "xyz" target_str = "x * y * z" symbols = None response = api.check(test_str, target_str, symbols=symbols) self.assertTrue("error" not in response, 'Unexpected "error" in response!') self.assertTrue("equal" in response, 'Key "equal" not in response!') self.assertTrue(response["equal"] == "true", 'Expected "equal" to be "true", got "{}"!'.format(response["equal"])) self.assertTrue("equality_type" in response, 'Key "equality_type" not in response!') self.assertTrue(response["equality_type"] in EQUALITY_TYPES, 'Unexpected "equality_type": "{}"!'.format(response["equality_type"])) self.assertTrue(response["equality_type"] == "exact", 'For these expressions, expected "equality_type" to be "exact", got "{}"!'.format(response["equality_type"])) print(" PASS ".center(75, "#"))