def test_lambda_symbol(self): lambda_symbol = Symbol('lambda') x = Symbol('x') y = Symbol('y') self.assertEqual(parse_expr("lambda"), lambda_symbol) self.assertEqual(parse_expr("x-lambda+y"), -lambda_symbol+x+y) self.assertEqual(parse_expr("lambda(x)(y)"), lambda_symbol*x*y)
def test_multiple_relational(self): from sympy import Eq, Ne, Lt, Le, Gt, Ge from mitesting.sympy_customized import Or, And from mitesting.customized_commands import Gts, Lts a=Symbol('a') b=Symbol('b') c=Symbol('c') x=Symbol('x') y=Symbol('y') z=Symbol('z') expr=parse_expr("a < b <=c <x") self.assertEqual(expr, And(Lt(a,b), Le(b,c), Lt(c,x))) expr=parse_expr("a < b <=c <x", replace_symmetric_intervals=True) self.assertEqual(expr, And(Lt(a,b), Le(b,c), Lt(c,x))) expr=parse_expr("a>b >= c >=x") self.assertEqual(expr, And(Gt(a,b), Ge(b,c), Ge(c,x))) expr=parse_expr("a < b <=c <x", evaluate=False) self.assertEqual(expr, Lts((a,b,c,x), (True, False, True), evaluate=False)) self.assertEqual(latex(expr), "a < b \leq c < x") expr=parse_expr("a>b >= c >=x", evaluate=False) self.assertEqual(expr, Gts((a,b,c,x), (True, False, False), evaluate=False)) self.assertEqual(latex(expr), "a > b \geq c \geq x")
def test_implicit_convert_xor(self): x = Symbol('x') self.assertEqual(parse_expr("3x^2/5", local_dict={}), x**2*sympify("3/5")) self.assertEqual( normalize_floats(parse_expr("3x^2/5.", local_dict={})), normalize_floats(0.6*x**2))
def test_if_symbol(self): if_symbol = Symbol('if') x = Symbol('x') y = Symbol('y') self.assertEqual(parse_expr("if"), if_symbol) self.assertEqual(parse_expr("x-if+y"), -if_symbol+x+y) self.assertEqual(parse_expr("if(x)(y)"), if_symbol*x*y)
def test_as_symbol(self): as_symbol = Symbol('as') x = Symbol('x') y = Symbol('y') self.assertEqual(parse_expr("as"), as_symbol) self.assertEqual(parse_expr("x-as+y"), -as_symbol+x+y) self.assertEqual(parse_expr("as(x)(y)"), as_symbol*x*y)
def test_implicit_multiplication(self): x = Symbol('x') y = Symbol('y') self.assertEqual(parse_expr("5x"), 5*x) self.assertEqual(parse_expr("5 x"), 5*x) self.assertEqual(parse_expr("5*x"), 5*x) self.assertEqual(parse_expr("5 x y"), 5*x*y)
def test_prevent_auto_j_as_imaginary(self): j=Symbol('j') J=Symbol('J') expr = parse_expr("5j") self.assertEqual(expr, 5*j) expr = parse_expr("7J") self.assertEqual(expr, 7*J)
def test_prevent_auto_l_as_long(self): l=Symbol('l') L=Symbol('L') expr = parse_expr("5l") self.assertEqual(expr, 5*l) expr = parse_expr("7L") self.assertEqual(expr, 7*L)
def test_if_symbol_substitutions(self): x = Symbol('x') y = Symbol('y') if_symbol = Symbol('if') sub_dict = {'if': 2*x*y} self.assertEqual(parse_expr("if^2+x+y"), if_symbol**2+x+y) self.assertEqual(parse_expr("if^2+x+y", global_dict=sub_dict), 4*x**2*y**2+x+y) self.assertEqual(parse_expr("if^2+x+y", local_dict=sub_dict), 4*x**2*y**2+x+y)
def test_as_symbol_substitutions(self): x = Symbol('x') y = Symbol('y') as_symbol = Symbol('as') sub_dict = {'as': 2*x*y} self.assertEqual(parse_expr("as^2+x+y"), as_symbol**2+x+y) self.assertEqual(parse_expr("as^2+x+y", global_dict=sub_dict), 4*x**2*y**2+x+y) self.assertEqual(parse_expr("as^2+x+y", local_dict=sub_dict), 4*x**2*y**2+x+y)
def test_e_with_split_symbols(self): from sympy import E, exp x = Symbol('x') self.assertEqual(parse_expr("3*x*e^x", local_dict={'e': E}), 3*x*exp(x)) self.assertEqual(parse_expr("3x*e^x", local_dict={'e': E}), 3*x*exp(x)) self.assertEqual(parse_expr("3xe^x", split_symbols=True, local_dict={'e': E}), 3*x*exp(x))
def test_prevent_octal(self): expr = parse_expr("0123") self.assertEqual(expr, 123) expr = parse_expr("0193") self.assertEqual(expr, 193) expr = parse_expr("0.123") self.assertEqual(expr, 0.123) expr = parse_expr("0.000791") self.assertEqual(expr, 0.000791) expr = parse_expr("4.04") self.assertEqual(expr, 4.04) expr = parse_expr("1230") self.assertEqual(expr, 1230) expr = parse_expr("0009505") self.assertEqual(expr, 9505) expr = parse_expr("89-088") self.assertEqual(expr,1) expr = parse_expr("72x/072 - x + 081") self.assertEqual(expr, 81)
def test_assume_real(self): x = Symbol('x') y = Symbol('y') x_real = Symbol('x', real=True) y_real = Symbol('y', real=True) self.assertEqual(parse_expr("5 x y-y^3/x"), 5*x*y-y**3/x) self.assertEqual(parse_expr("5 x y-y^3/x", assume_real_variables=False), 5*x*y-y**3/x) self.assertEqual(parse_expr("5 x y-y^3/x", assume_real_variables=True), 5*x_real*y_real-y_real**3/x_real)
def test_if_as_iif(self): from mitesting.user_commands import iif x = Symbol('x') sub_dict = {'if': iif} self.assertEqual(parse_expr('if(4>3,x,y)', local_dict=sub_dict),x) self.assertEqual(parse_expr('if(-4>3,y,x^2)', local_dict=sub_dict),x**2) f = parse_expr('if(x=1,2,if(x>1,3,0))',local_dict=sub_dict) self.assertEqual(f.subs(x,1),2) self.assertEqual(f.subs(x,-1),0) self.assertEqual(f.subs(x,2),3)
def test_basics_with_empty_local_dict(self): x = Symbol('x') y = Symbol('y') self.assertEqual(parse_expr("5x", local_dict={}), 5*x) local_dict = {} self.assertEqual(parse_expr("3y^2", local_dict=local_dict), 3*y**2) # verify local_dict is still empty self.assertEqual(local_dict, {}) self.assertEqual(parse_expr("log(x)", local_dict={}), Symbol('log')*x)
def test_greek_unicode(self): s1 = "alpha^2*beta/(gamma-epsilon^2)+ delta^2(zeta)eta^3/theta -(iota^2-kappa^2)^2/(lambda/mu-nu+xi)+ pi^2rho^3/(sigma+tau^2) + phi*psi^3/omega" s2 = "α^2*β/(γ-ε^2)+δ^2(ζ)η^3/θ-(ι^2-κ^2)^2/(λ/μ-ν+ξ)+π^2ρ^3/(σ+τ^2) + φ*ψ^3/ω" expr1 = parse_expr(s1, split_symbols=True) expr2 = parse_expr(s2, split_symbols=True) self.assertEqual(expr1,expr2) s1="ϵϕ" s2='εφ' expr1 = parse_expr(s1, split_symbols=True) expr2 = parse_expr(s2, split_symbols=True) self.assertEqual(expr1,expr2)
def test_lambda_symbol_substitutions(self): x = Symbol('x') y = Symbol('y') lambda_symbol = Symbol('lambda') sub_dict = {'lambda': 2*x*y} self.assertEqual(parse_expr("lambda^2+x+y"), lambda_symbol**2+x+y) self.assertEqual(parse_expr("lambda^2+x+y", global_dict=sub_dict), 4*x**2*y**2+x+y) self.assertEqual(parse_expr("lambda^2+x+y", local_dict=sub_dict), 4*x**2*y**2+x+y) self.assertEqual(parse_expr("lambda^2+x+y", local_dict=sub_dict, global_dict=sub_dict), 4*x**2*y**2+x+y)
def test_derivative_prime_notation(self): from sympy import Function, Derivative from mitesting.sympy_customized import SymbolCallable, \ DerivativePrimeNotation, DerivativePrimeSimple f=Function(str('f')) g=SymbolCallable(str('g')) x=Symbol('x') y=Symbol('y') fn=Function(str('fn')) local_dict={'f': f, 'g': g, 'fn': fn} expr=parse_expr("f'(x)+g'(y)", local_dict=local_dict) self.assertEqual(expr, DerivativePrimeSimple(f(x),x) +DerivativePrimeSimple(g(y),y)) self.assertEqual(latex(expr), "f'(x) + g'(y)") expr=parse_expr("yf'(x)", local_dict=local_dict, split_symbols=True) self.assertEqual(expr, y*DerivativePrimeSimple(f(x),x)) expr=parse_expr("yf'(x)", local_dict=local_dict) self.assertEqual(expr, DerivativePrimeSimple(Function('yf')(x),x)) expr=parse_expr("2f'(x)", local_dict=local_dict) self.assertEqual(expr, 2*DerivativePrimeSimple(f(x),x)) expr=parse_expr("fn'(x)", local_dict=local_dict) self.assertEqual(expr, DerivativePrimeSimple(fn(x),x)) expr=parse_expr("fn'(x)", local_dict=local_dict, split_symbols=True) self.assertEqual(expr, DerivativePrimeSimple(fn(x),x)) expr=parse_expr("f0'(x)", local_dict=local_dict) self.assertEqual(expr, DerivativePrimeSimple(Function('f0')(x),x)) self.assertRaises(SyntaxError, parse_expr,"f0'(x)", local_dict=local_dict, split_symbols=True) expr=parse_expr("2f'(x*y)", local_dict=local_dict) self.assertEqual(expr, 2*DerivativePrimeNotation(f,x*y)) from sympy import Subs self.assertEqual(expr.doit(), 2*Subs(Derivative(f(x),x),x,x*y)) expr2=parse_expr("2f'(x*y, dummy_variable==='t')", local_dict=local_dict) self.assertEqual(expr,expr2) self.assertEqual(expr.doit(),expr2.doit()) expr3=parse_expr("2f'(x*y, dummy_variable==='s')", local_dict=local_dict) self.assertEqual(expr3,expr2) self.assertEqual(expr3.doit(),expr2.doit())
def test_callable_symbol_commutative(self): # symbol callable is commutative even with argument such an equality from mitesting.sympy_customized import SymbolCallable P=SymbolCallable('P') local_dict = {'P': P} expr = parse_expr("P(R=1)", local_dict=local_dict) self.assertTrue(expr.is_commutative) expr = parse_expr("P(A)/P(R=1)", local_dict=local_dict) self.assertEqual(latex(expr), '\\frac{P{\\left (A \\right )}}{P{\\left (R = 1 \\right )}}')
def test_split_with_function(self): from sympy import Function x=Symbol('x') a=Symbol('a') f=Function(str('f')) fsym=Symbol('f') expr = parse_expr('af(x)', split_symbols=True) self.assertEqual(expr, a*fsym*x) expr = parse_expr('af(x)', split_symbols=True, local_dict={'f': f}) self.assertEqual(expr, a*f(x))
def test_conditional_probability_expression(self): from mitesting.customized_commands import conditional_probability_expression from mitesting.sympy_customized import SymbolCallable A=Symbol("A") B=Symbol("B") P=SymbolCallable("P") expr=parse_expr("A|B") self.assertEqual(expr, conditional_probability_expression(A,B)) self.assertEqual(latex(expr), "A ~|~ B") expr=parse_expr("P(A|B)", local_dict={'P': P}) self.assertEqual(expr, P(conditional_probability_expression(A,B))) self.assertEqual(latex(expr), "P{\\left (A ~|~ B \\right )}")
def test_no_evaluate_strange_Eq_behavior(self): # This fails if parse_expr doesn't add evaluate=False to Eq. # For some reason, it compares the Matrix to zero from mitesting.user_commands import scalar_multiple_deviation from sympy import ImmutableMatrix, Eq A=ImmutableMatrix([1,2]) x=Symbol('x') expr = parse_expr('smd(A,x)=0', evaluate=False, local_dict={'smd': scalar_multiple_deviation, 'A': A}) self.assertEqual(expr, Eq(scalar_multiple_deviation(A,x,evaluate=False),0,evaluate=False))
def test_absolute_values(self): from sympy import Abs x=Symbol('x') y=Symbol('y') z=Symbol('z') self.assertEqual(parse_expr("|x+y|"), Abs(x+y)) self.assertEqual(parse_expr("x|y|x|z|x"), x**3*Abs(y)*Abs(z)) self.assertEqual(parse_expr("|x+y|"), Abs(x+y)) self.assertRaises(SyntaxError, parse_expr,"|x+|y||") self.assertEqual(parse_expr("|x+(|y|)|"), Abs(x+Abs(y))) from mitesting.customized_commands import conditional_probability_expression from mitesting.sympy_customized import SymbolCallable A=Symbol("A") B=Symbol("B") P=SymbolCallable("P") expr=parse_expr("|P(A|B)|", local_dict={'P': P}) self.assertEqual(expr, Abs(P(conditional_probability_expression(A,B))))
def test_no_evaluate_functions(self): from mitesting.user_commands import roots_tuple, index from mitesting.sympy_customized import TupleNoParen from sympy import Abs x=Symbol('x') expr=parse_expr("roots_tuple((x-3)*(x-1),x)", local_dict={'roots_tuple': roots_tuple}, evaluate=False) self.assertEqual(expr, roots_tuple((x-3)*(x-1),x, evaluate=False)) self.assertEqual(expr.doit(), TupleNoParen(1,3)) expr=parse_expr("index([3,-2,6],-2)", local_dict={'index': index }, evaluate=False) self.assertEqual(expr, index([3,-2,6],-2, evaluate=False)) self.assertEqual(expr.doit(), 1) expr=parse_expr("Abs(-1)/Abs(x*Abs(-5))", local_dict={"Abs": Abs}, evaluate=False) self.assertEqual(expr, Abs(-1,evaluate=False)/Abs(x*Abs(-5, evaluate=False),evaluate=False)) self.assertEqual(expr.doit(), 1/Abs(5*x))
def test_boolean(self): self.assertEqual(parse_expr("True and True"), True) self.assertEqual(parse_expr("True and not True"), False) self.assertEqual(parse_expr("False or not True"), False) self.assertEqual(parse_expr("not False or not True"), True) local_dict = {'a': sympify(1), 'b': sympify(2), 'c': sympify(3), 'd': sympify(4)} expr = parse_expr("a and b and c and d", local_dict=local_dict) self.assertEqual(expr, True) local_dict['b'] = sympify(0) expr = parse_expr("a and b and c and d", local_dict=local_dict) self.assertEqual(expr, False) self.assertEqual(latex(parse_expr("a and b")), r'a ~\text{and}~ b') self.assertEqual(latex(parse_expr("a or b")), r'a ~\text{or}~ b')
def test_callable_symbol(self): from mitesting.sympy_customized import SymbolCallable x=Symbol('x') a=Symbol('a') f=SymbolCallable(str('f')) fsym=Symbol(str('f')) self.assertEqual(f,fsym) expr = parse_expr('af(x)', split_symbols=True) self.assertEqual(expr, a*fsym*x) expr = parse_expr('af(x)', split_symbols=True, local_dict={'f': f}) self.assertEqual(expr, a*f(x)) self.assertEqual(expr, a*fsym(x)) expr = parse_expr('afx', split_symbols=True, local_dict={'f': f}) self.assertEqual(expr, a*f*x) expr = parse_expr('f in {fsym,y,z}', local_dict={'f': f, 'fsym': fsym}) self.assertEqual(expr, True)
def test_intervals(self): from mitesting.sympy_customized import Interval a=Symbol('a') b=Symbol('b') self.assertEqual(parse_expr("(a,b)"), Tuple(a,b)) self.assertEqual(parse_expr("[a,b]"), [a,b]) self.assertRaisesRegex(ValueError, "Only real intervals", parse_expr, "(a,b)", replace_symmetric_intervals=True) self.assertRaisesRegex(ValueError, "Only real intervals", parse_expr, "[a,b]", replace_symmetric_intervals=True) self.assertRaisesRegex(ValueError, "Only real intervals", parse_expr, "(a,b]") self.assertRaisesRegex(ValueError, "Only real intervals", parse_expr, "[a,b)") a=Symbol('a', real=True) b=Symbol('b', real=True) expr=parse_expr("(a,b)", replace_symmetric_intervals=True, assume_real_variables=True) self.assertEqual(expr, Interval(a,b,left_open=True, right_open=True)) expr=parse_expr("[a,b]", replace_symmetric_intervals=True, assume_real_variables=True) self.assertEqual(expr, Interval(a,b)) expr=parse_expr("(a,b]", assume_real_variables=True) self.assertEqual(expr, Interval(a,b, left_open=True)) expr=parse_expr("(a,b]", replace_symmetric_intervals=True, assume_real_variables=True) self.assertEqual(expr, Interval(a,b, left_open=True)) expr=parse_expr("[a,b)", assume_real_variables=True) self.assertEqual(expr, Interval(a,b, right_open=True)) expr=parse_expr("[a,b)", replace_symmetric_intervals=True, assume_real_variables=True) self.assertEqual(expr, Interval(a,b, right_open=True))
def test_contains(self): from mitesting.sympy_customized import Interval, FiniteSet, Or x=Symbol('x') expr=parse_expr("x in (1,2)") self.assertEqual(expr, Interval(1,2, left_open=True, right_open=True).contains(x)) self.assertEqual(latex(expr), r'x > 1 ~\text{and}~ x < 2') expr=parse_expr("x in (1,2)", evaluate=False) self.assertEqual(expr, Interval(1,2, left_open=True, right_open=True).contains(x, evaluate=False)) self.assertEqual(latex(expr), r'x \in \left(1, 2\right)') expr=parse_expr("1 in [1,2]") self.assertEqual(expr, True) expr=parse_expr("1 in [1,2]", evaluate=False) self.assertEqual(expr, Interval(1,2).contains(1, evaluate=False)) self.assertEqual(latex(expr), r'1 \in \left[1, 2\right]') expr=parse_expr("x in {1,2,3}") self.assertEqual(expr, FiniteSet(1,2,3).contains(x)) expr=parse_expr("x in {1,2,x}") self.assertEqual(expr, True) expr=parse_expr("x in {1,2,x}", evaluate=False) self.assertEqual(expr, FiniteSet(1,2,x).contains(x, evaluate=False)) self.assertEqual(latex(expr), r'x \in \left\{1, 2, x\right\}') a=Symbol('a') b=Symbol('b') expr=parse_expr("x in {a,b} or x in (1,2]") self.assertEqual(expr, Or(FiniteSet(a,b).contains(x),Interval(1,2, left_open=True).contains(x))) from mitesting.user_commands import iif expr=parse_expr("if(x in {a,b}, 1, 0)", local_dict={'x': a, 'if': iif}) self.assertEqual(expr,1)
def test_split_symbols(self): x = Symbol('x') y = Symbol('y') xy = Symbol('xy') self.assertEqual(parse_expr("5xy"), 5*xy) self.assertEqual(parse_expr("5xy", split_symbols=False), 5*xy) self.assertEqual(parse_expr("5xy", split_symbols=True), 5*x*y) expr=parse_expr("x61y", split_symbols=True) self.assertEqual(expr, 61*x*y) x = Symbol('x', real=True) y = Symbol('y', real=True) xy = Symbol('xy', real=True) expr=parse_expr("5xy", assume_real_variables=True) self.assertEqual(expr, 5*xy) expr=parse_expr("5xy", split_symbols=False, assume_real_variables=True) self.assertEqual(expr, 5*xy) expr=parse_expr("5xy", split_symbols=True, assume_real_variables=True) self.assertEqual(expr, 5*x*y)
def test_parse_subscripts(self): x=Symbol('x') y=Symbol('y') n=Symbol('n') m=Symbol('m') expr1=parse_expr("x_n") expr2=parse_expr("x_n", parse_subscripts=True) expr3=parse_expr("x_n", parse_subscripts=True, assume_real_variables=True) expr4=parse_expr("x_n", parse_subscripts=True, evaluate=False) self.assertEqual(expr1,Symbol("x_n")) self.assertEqual(expr2,Symbol("x_n")) self.assertEqual(expr1,expr2) self.assertEqual(expr3,Symbol("x_n", real=True)) self.assertEqual(expr4,Symbol("x_n")) expr1=parse_expr("x_(n+1)") expr2=parse_expr("x_(n+1)", parse_subscripts=True) self.assertEqual(expr1,Symbol("x_")*(n+1)) self.assertEqual(expr2,Symbol("x_n + 1")) self.assertEqual(latex(expr2), "x_{n + 1}") expr=parse_expr("xx_nn", parse_subscripts=True, local_dict={'xx': y, 'nn': m }) self.assertEqual(expr, Symbol('y_m')) expr=parse_expr("xx_nn", parse_subscripts=True, split_symbols=True, local_dict={'xx': y, 'nn': m }) self.assertEqual(expr, Symbol('y_m')) expr=parse_expr("xx_nn", parse_subscripts=True, local_dict={'xx': y, 'nn': m, 'xx_nn': Symbol('a')}) self.assertEqual(expr, Symbol('a')) expr=parse_expr("xx_nn", parse_subscripts=True, split_symbols=True, local_dict={'xx': y, 'nn': m, 'xx_nn': Symbol('a')}) self.assertEqual(expr, Symbol('a')) expr=parse_expr("y+xx_nn/2", parse_subscripts=True) self.assertEqual(expr, y+Symbol('xx_nn')/2) expr=parse_expr("y+xx_nn/2", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, y+x*n*Symbol('x_n')/2) expr=parse_expr("y+xx_nn/2", parse_subscripts=True, split_symbols=True, local_dict={'nn': Symbol('nn')}) self.assertEqual(expr, y+x*Symbol('x_nn')/2) expr=parse_expr("y+xx_nn/2", parse_subscripts=True, split_symbols=True, local_dict={'xx': Symbol('xx')}) self.assertEqual(expr, y+n*Symbol('xx_n')/2) expr=parse_expr("y+xx_nn/2", parse_subscripts=True, split_symbols=True, local_dict={'xx': Symbol('xx'), 'nn': Symbol('nn')}) self.assertEqual(expr, y+Symbol('xx_nn')/2) expr=parse_expr("y+xx_(nm)/2", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, y+x*Symbol('x_m n')/2) expr=parse_expr("y+xx_(nm)/2", parse_subscripts=True, split_symbols=True, local_dict={'nm': Symbol('nm')}) self.assertEqual(expr, y+x*Symbol('x_nm')/2) expr=parse_expr("y+6xx_nn/2", parse_subscripts=True) self.assertEqual(expr, y+3*Symbol('xx_nn')) expr=parse_expr("y+xx_28/2", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, y+x*Symbol('x_28')/2) expr=parse_expr("y+xx_28n/2", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, y+x*n*Symbol('x_28')/2) expr=parse_expr("y+xx_28n/2", parse_subscripts=True) self.assertEqual(expr, y+Symbol('xx_28 n')/2) expr=parse_expr("a1_b", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, Symbol('a1_b')) expr=parse_expr("1a_b", parse_subscripts=True, split_symbols=True) self.assertEqual(expr, Symbol('a_b')) S1= Symbol('SS_1') expr=parse_expr("xS_1y", parse_subscripts=True, split_symbols=True, local_dict={'S_1': S1}) self.assertEqual(expr, x*S1*y) expr1=parse_expr("lambda_delta", parse_subscripts=True, split_symbols=True) expr2=parse_expr("lambda_delta", parse_subscripts=False, split_symbols=True) expr3=parse_expr("lambda_delta", parse_subscripts=True, split_symbols=False) expr4=parse_expr("lambda_delta", parse_subscripts=False, split_symbols=False) expr5=parse_expr("λ_δ", parse_subscripts=True, split_symbols=True) expr6=parse_expr("λ_δ", parse_subscripts=False, split_symbols=True) expr7=parse_expr("λ_δ", parse_subscripts=True, split_symbols=False) expr8=parse_expr("λ_δ", parse_subscripts=False, split_symbols=False) self.assertEqual(expr1,expr2) self.assertEqual(expr1,expr3) self.assertEqual(expr1,expr4) self.assertEqual(expr1,expr5) self.assertEqual(expr1,expr6) self.assertEqual(expr1,expr7) self.assertEqual(expr1,expr8)