def test_complex_operation(self): two = Operation(OperationType.POSITIVE(), [Variable(2)]) negative_x = Operation(OperationType.NEGATIVE(), [Variable('x')]) op = Operation(OperationType.TIMES(), [two, negative_x]) verify(str(op), self.reporter)
def test_evaluate_where_possible_simple(self): two_plus_two = Operation(OperationType.PLUS(), [Variable(2.0), Variable(2.0)]) expression = Operation(OperationType.DIVIDE(), [Variable('x'), two_plus_two]) verify(str(expression.evaluate_where_possible()), self.reporter)
def test_remove_reporter(self): self.factory.remove("meld") verify( json.dumps(self.factory.list(), sort_keys=True, indent=4, separators=(',', ': ')), self.reporter)
def test_verify_fail(self): reporter = TestingReporter() try: verify("Hello World.", reporter) self.assertFalse(True, "expected exception") except ApprovalException as e: self.assertTrue("Approval Mismatch", e.value)
def test_single_variable_solver_handles_distribution(self): equation = Parser.parse_equation('p * -25 + (1 - p) * 5 = 0') result = Solver.single_variable(equation, 'p', print_out=True, max_iterations=20) verify(str(result), self.reporter)
def test_single_variable_solver_evaluates(self): equation = Parser.parse_equation('0 = 0.5*a + 3*4') result = Solver.single_variable(equation, 'a', print_out=True, max_iterations=5) verify(str(result), self.reporter)
def test_collected_terms_subtract(self): x = Term(Operation(Variable('x'))) y = Term(Operation(Variable('y')), 2) z = Term(Operation(Variable('z'))) expression1 = CollectedTerms([x, y], [1, 3]) expression2 = CollectedTerms([y, z], [-3, -2]) result = CollectedTerms.subtract(expression1, expression2) verify(str(result), self.reporter)
def test_deserialization(self): namer = Namer() full_name = os.path.join(namer.get_directory(), 'custom-reporters.json') reporters = self.factory.load(full_name) verify( json.dumps(reporters, sort_keys=True, indent=4, separators=(',', ': ')), self.reporter)
def test_equation(self): two = Operation(OperationType.POSITIVE(), [Variable(2)]) negative_x = Operation(OperationType.NEGATIVE(), [Variable('x')]) lhs = Operation(OperationType.TIMES(), [two, negative_x]) rhs = Variable(3.1415) eq = Equation(lhs, rhs) verify(str(eq), self.reporter)
def test_equation_cancellation_with_negative(self): lhs = Parser(Tokenizer.tokenize('x + -4')).parse() rhs = Parser(Tokenizer.tokenize('y')).parse() equation = Equation(lhs, rhs) addition_cancellation = EquationCancellation(OperationType.PLUS(), OperationType.MINUS()) self.assertTrue(addition_cancellation.is_applicable_to(equation)) result = addition_cancellation.apply(equation) verify(str(result), self.reporter)
def test_equation_cancellation(self): lhs = Parser(Tokenizer.tokenize('x * 4')).parse() rhs = Parser(Tokenizer.tokenize('y')).parse() equation = Equation(lhs, rhs) multiplication_cancellation = EquationCancellation( OperationType.TIMES(), OperationType.DIVIDE()) self.assertTrue(multiplication_cancellation.is_applicable_to(equation)) result = multiplication_cancellation.apply(equation) verify(str(result), self.reporter)
def test_all_equation_substitutions_addition_by_same(self): equation = Parser.parse_equation('3.0 = (x)+(x)') substitution = ExpressionSubstitution(Parser.parse_expression('a + a'), Parser.parse_expression('2*a')) transformation = Transformation.apply_all_substitution_transformations( substitution) result = transformation.apply(equation) verify(str(result), self.reporter)
def test_all_equation_substitutions_simple(self): equation = Parser.parse_equation('y = (x)-(x)') substitution = ExpressionSubstitution(Parser.parse_expression('a - a'), Parser.parse_expression('0')) transformation = Transformation.apply_all_substitution_transformations( substitution) result = transformation.apply(equation) verify(str(result), self.reporter)
def test_identity_transformation(self): start = Parser(Tokenizer.tokenize('x')).parse() end = start transformation = ExpressionSubstitution(start, end) instantiated_start = Parser(Tokenizer.tokenize('abc')).parse() pattern = SubstitutionPattern({'x': 'abc'}) verify( '{} -> {}'.format( 'abc', transformation.transform(instantiated_start, pattern)), self.reporter)
def test_evaluate_where_possible_complex(self): two_plus_two = Operation(OperationType.PLUS(), [Variable(2.0), Variable(2.0)]) two_plus_two_divided_by_four = Operation( OperationType.DIVIDE(), [two_plus_two, Variable(4)]) three_minus_x = Operation(OperationType.MINUS(), [Variable(3.0), Variable('x')]) seven_plus_five = Operation(OperationType.PLUS(), [Variable(7), Variable(5)]) three_minus_x_over_seven_plus_five = Operation( OperationType.DIVIDE(), [three_minus_x, seven_plus_five]) expression = Operation( OperationType.TIMES(), [two_plus_two_divided_by_four, three_minus_x_over_seven_plus_five]) verify(str(expression.evaluate_where_possible()), self.reporter)
def test(self): txtFile = open('./testFiles/test.txt', 'w') m.write_strings(2, txtFile) txtFile.close() testFile = open('./testFiles/test.txt', 'r') testArray = [] for line in testFile: testArray.append(line) testFile.close() verify(''.join(testArray), self.reporter)
def test(self): txtFile = open('./testFiles/test.txt', 'w'); m.write_strings(2, txtFile); txtFile.close(); testFile = open('./testFiles/test.txt', 'r'); testArray = []; for line in testFile: testArray.append(line); testFile.close(); verify(''.join(testArray), self.reporter);
def test_all_substitutions_same_variable(self): expression = Parser(Tokenizer.tokenize('x + x + x')).parse() start = Parser(Tokenizer.tokenize('a + a')).parse() end = Parser(Tokenizer.tokenize('2 * a')).parse() transformation = ExpressionSubstitution(start, end) transformations = transformation.get_all_substitutions(expression) to_return = list() for pattern, result in transformations: row = list() for key in sorted(pattern.keys()): row.append('{} : {}'.format(key, pattern[key])) to_return.append('{' + ', '.join(row) + '} => ' + str(result)) verify('\n'.join(to_return), self.reporter)
def test_transformation_with_expression(self): start = Parser(Tokenizer.tokenize('x + y')).parse() end = Parser(Tokenizer.tokenize('y + x')).parse() transformation = ExpressionSubstitution(start, end) instantiated_start = Parser(Tokenizer.tokenize('1+(2+3+4)')).parse() pattern = SubstitutionPattern({ 'x': '1', 'y': Parser(Tokenizer.tokenize('2+3+4')).parse() }) verify( '{} -> {}'.format( str(instantiated_start), transformation.transform(instantiated_start, pattern)), self.reporter)
def test_complex_single_solution_solve(self): lhs = Parser(Tokenizer.tokenize('x * 4 - 18')).parse() rhs = Parser(Tokenizer.tokenize('2')).parse() equation = Equation(lhs, rhs) cancellations = [ EquationCancellation(OperationType.PLUS(), OperationType.MINUS()), EquationCancellation(OperationType.MINUS(), OperationType.PLUS()), EquationCancellation(OperationType.TIMES(), OperationType.DIVIDE()), EquationCancellation(OperationType.DIVIDE(), OperationType.TIMES()) ] transformations = list( map(lambda x: x.as_transformation(), cancellations)) step = SolverStep(transformations) step.next_step = step condition = lambda x: str(x.lhs) == 'x' result = step.execute_until(equation, condition) verify(str(result), self.reporter)
def test_simple(self): verify('Hello', self.reporter)
def test_parens_in_the_middle(self): result = Parser.parse_expression('1+(2+3+4)') verify(str(result), self.reporter)
def test_get_araxis_mac(self): verify(str(self.factory.get("AraxisMergeMac")), self.factory.get("AraxisMergeMac"))
def test_get_winmerge(self): verify(str(self.factory.get("WinMerge")), self.factory.get("WinMerge"))
def test_list_configured_reporters(self): verify(json.dumps(self.factory.list(), sort_keys=True, indent=4, separators=(',', ': ')), self.reporter)
def test_basic_approval(): verify("foo")
def test_redundent_parens(self): result = Tokenizer.tokenize('((x))') result = Parser(result).parse() verify(str(result), self.reporter)
def test_simple_parsing(self): result = Tokenizer.tokenize('-2') result = Parser(result).parse() verify(str(result), self.reporter)
def test_tokenizing(self): result = Tokenizer.tokenize('(34+2*x)/14+17-x^2') verify(str(result), self.reporter)
def test_serialization(self): n = Namer() path = os.path.join(n.get_directory(), 'saved-reporters.json') self.factory.save(path) with open(path, 'r') as f: verify(f.read(), self.reporter)
def test_verify(): verify("Hello World.")
def test_verify(self): verify("Hello World.", self.reporter)
def test_complex_parens(self): result = Tokenizer.tokenize('(+(2))+(2)') result = Parser(result).parse() verify(str(result), self.reporter)
def test_remove_reporter(self): self.factory.remove("meld") verify(json.dumps(self.factory.list(), sort_keys=True, indent=4, separators=(',', ': ')), self.reporter)
def test_binary_parsing(self): result = Tokenizer.tokenize('+2+2') result = Parser(result).parse() verify(str(result), self.reporter)
def test_get_reporter(self): verify(str(self.factory.get("BeyondCompare4")), self.reporter)
def test_order_of_operations(self): result = Tokenizer.tokenize('+2+-2*4') result = Parser(result).parse() verify(str(result), self.reporter)
def test_get_araxis(self): verify(str(self.factory.get("AraxisMergeWin")), self.factory.get("AraxisMergeWin"))
def test_order_of_operations_complex(self): result = Parser.parse_expression('y*0.5 - 2*x') verify(str(result), self.reporter)
def test_get_beyondcompare4_mac(self): verify(str(self.factory.get("BeyondCompare4Mac")), self.factory.get("BeyondCompare4Mac"))
def test_order_of_operations_prefix(self): result = Parser.parse_expression('---x++y-+y') verify(str(result), self.reporter)
def test_deserialization(self): namer = Namer() full_name = os.path.join(namer.get_directory(), 'custom-reporters.json') reporters = self.factory.load(full_name) verify(json.dumps(reporters, sort_keys=True, indent=4, separators=(',', ': ')), self.reporter)