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_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_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)
def test_simple(self):
verify('Hello', self.reporter)
