def test_Create_2_Minus_1_Evaluates_1(self): # Arrange leftNum = SingleNumberExpression(2) operatorSign = "-" rightNum = SingleNumberExpression(1) binaryExpression = ExpressionFactory().CreateExpression(leftNum, operatorSign, rightNum) # Act actual = binaryExpression.evaluate() expected = 1 # Assert self.assertEqual(actual, expected)
def test_Create_6_Times_2_Evaluates_12(self): # Arrange leftNum = SingleNumberExpression(6) operatorSign = "*" rightNum = SingleNumberExpression(2) binaryExpression = ExpressionFactory().CreateExpression(leftNum, operatorSign, rightNum) # Act actual = binaryExpression.evaluate() expected = 12 # Assert self.assertEqual(actual, expected)
def test_Create_Float1_Is_SingleNumberExpression(self): # Arrange inputNum = 1.0 expression = ExpressionFactory().CreateExpression(inputNum) # Act actual = isinstance(expression, SingleNumberExpression) expected = True # Assert self.assertEqual(actual, expected)
def test_Create_1_Plus_1_Is_AdditionExpression(self): # Arrange leftNum = SingleNumberExpression(1) operatorSign = "+" rightNum = SingleNumberExpression(1) binaryExpression = ExpressionFactory().CreateExpression(leftNum, operatorSign, rightNum) # Act actual = isinstance(binaryExpression, AdditionExpression) expected = True # Assert self.assertEqual(actual, expected)
def __init__(self, memory, operations, lines):
self.exp_maker = ExpressionFactory()
self.memory = memory
self.operations = operations
self.lines = lines
class OperationFactory(object):
"""description of class"""
def __init__(self, memory, operations, lines):
self.exp_maker = ExpressionFactory()
self.memory = memory
self.operations = operations
self.lines = lines
"""
Checks the type of operation and returns an instance of the relevant command
"""
def create_operation(self, line):
op = line[0]
if op == 'LET':
# create LET operation
var_name = line[1]
value = line[3:]
if value[1] == '':
# if no exprssion to be computed. eg. LET X = 10
value = value[0]
if isinstance(value, str) and self.memory.is_variable(value):
value = self.memory.get_value(value)
return Let(var_name, value)
else:
# if there is an expression that needs to be computed eg. LET X = X + 10
exp = self.exp_maker.create_expression(value[0], value[1],
value[2])
value = exp.compute(self.memory)
if isinstance(value, str):
return value
return Let(var_name, value)
elif op == 'PRINT':
# create PRINT operation
return Print(line[1])
#elif op =='GOTO':
# # create GOTO operation
# if line[1].isdigit() == False:
# self.memory.is_variable(line[1])
# goto_number = int(self.memory.get_value(line[1]))
# else:
# goto_number = int(line[1])
# if goto_number in self.lines.keys():
# goto_op = self.create_operation(self.lines[goto_number])
# return Goto(goto_op)
# else:
# return "Line number " + str(goto_number) + " doesnt exist"
# #if goto_number in self.operations.keys():
# # return Goto(self.operations[goto_number])
# #else:
# # return "Line number " + str(goto_number) + " doesnt exist"
#elif op == 'IF':
# # create if goto operation
# if line[5].isdigit() == False:
# self.memory.is_variable(line[5])
# goto_number = int(self.memory.get_value(line[5]))
# else:
# goto_number = int(line[5])
# exp = self.exp_maker.create_expression(line[1], line[2], line[3])
# if goto_number in self.lines.keys():
# goto_op = self.create_operation(self.lines[goto_number])
# return IfGoto(exp, goto(goto_op))
# else:
# return "line number " + str(goto_number) + " doesnt exist"
elif op == 'IF':
# create if goto operation
if line[5].isdigit() == False:
self.memory.is_variable(line[5])
goto_number = int(self.memory.get_value(line[5]))
else:
goto_number = int(line[5])
exp = self.exp_maker.create_expression(line[1], line[2], line[3])
return If(exp)
def __init__(self, memory, operations, lines):
self.exp_maker = ExpressionFactory()
self.memory = memory
self.operations = operations
self.lines = lines
class OperationFactory(object):
"""description of class"""
def __init__(self, memory, operations, lines):
self.exp_maker = ExpressionFactory()
self.memory = memory
self.operations = operations
self.lines = lines
"""
Checks the type of operation and returns an instance of the relevant command
"""
def create_operation(self, line):
op =line[0]
if op == 'LET':
# create LET operation
var_name = line[1]
value = line[3:]
if value[1]=='':
# if no exprssion to be computed. eg. LET X = 10
value = value[0]
if isinstance(value, str) and self.memory.is_variable(value):
value = self.memory.get_value(value)
return Let(var_name, value)
else:
# if there is an expression that needs to be computed eg. LET X = X + 10
exp = self.exp_maker.create_expression(value[0], value[1], value[2])
value = exp.compute(self.memory)
if isinstance(value, str):
return value
return Let(var_name, value)
elif op == 'PRINT':
# create PRINT operation
return Print(line[1])
#elif op =='GOTO':
# # create GOTO operation
# if line[1].isdigit() == False:
# self.memory.is_variable(line[1])
# goto_number = int(self.memory.get_value(line[1]))
# else:
# goto_number = int(line[1])
# if goto_number in self.lines.keys():
# goto_op = self.create_operation(self.lines[goto_number])
# return Goto(goto_op)
# else:
# return "Line number " + str(goto_number) + " doesnt exist"
# #if goto_number in self.operations.keys():
# # return Goto(self.operations[goto_number])
# #else:
# # return "Line number " + str(goto_number) + " doesnt exist"
#elif op == 'IF':
# # create if goto operation
# if line[5].isdigit() == False:
# self.memory.is_variable(line[5])
# goto_number = int(self.memory.get_value(line[5]))
# else:
# goto_number = int(line[5])
# exp = self.exp_maker.create_expression(line[1], line[2], line[3])
# if goto_number in self.lines.keys():
# goto_op = self.create_operation(self.lines[goto_number])
# return IfGoto(exp, goto(goto_op))
# else:
# return "line number " + str(goto_number) + " doesnt exist"
elif op == 'IF':
# create if goto operation
if line[5].isdigit() == False:
self.memory.is_variable(line[5])
goto_number = int(self.memory.get_value(line[5]))
else:
goto_number = int(line[5])
exp = self.exp_maker.create_expression(line[1], line[2], line[3])
return If(exp)
class RawExpression:
fullExpression = ""
validator = Validator()
factory = ExpressionFactory()
expressionHead = None
def isValid(self):
return self.validator.isValidExpression(self.fullExpression)
def evaluate(self):
if self.isValid() and (self.expressionHead is None):
self.buildExpressionTree()
return self.expressionHead.evaluate()
def buildExpressionTree(self):
# print("****************************")
# print("****************************")
self.expressionHead = self.__buildExpressionTree(self.fullExpression)
def __buildExpressionTree(self, expressionInput):
# if len(expressionInput) == 0:
# print("Epmty Exp")
# return
if len(expressionInput) == 1:
return self.factory.CreateExpression(expressionInput)
else:
breakPoint = self.__findValidBreakpoint(expressionInput)
# print(breakPoint)
# print(expressionInput)
if ((breakPoint + 1 < len(expressionInput) and
(self.__rightExpressionIsParentheticalExcludeBreakPoint(
expressionInput, breakPoint)
or self.__rightExpressionIsParentheticalIncludeBreakPoint(
expressionInput, breakPoint)) and
(breakPoint - 1 >= 0 and self.__leftExpressionIsParenthetical(
expressionInput, breakPoint)))):
if (not self.__isOperator(expressionInput[breakPoint])):
# print("Right Left No Op")
return self.__splitExpressionParenRightLeftNoOperator(
expressionInput, breakPoint)
else:
# print("Right Left Op")
return self.__splitExpressionParenRightLeft(
expressionInput, breakPoint)
if (breakPoint + 1 < len(expressionInput) and
(self.__rightExpressionIsParentheticalExcludeBreakPoint(
expressionInput, breakPoint)
or self.__rightExpressionIsParentheticalIncludeBreakPoint(
expressionInput, breakPoint))):
if expressionInput[breakPoint] == "(":
# print("Right No Op")
return self.__splitExpressionParenRightNoOperator(
expressionInput, breakPoint)
else:
# print("Right Op")
return self.__splitExpressionParenRight(
expressionInput, breakPoint)
elif (breakPoint - 1 >= 0 and self.__leftExpressionIsParenthetical(
expressionInput, breakPoint)):
if expressionInput[breakPoint].isnumeric():
# print("Left No Op")
return self.__splitExpressionParenLeftNoOperator(
expressionInput, breakPoint)
else:
# print("Left Op")
return self.__splitExpressionParenLeft(
expressionInput, breakPoint)
# print("No Paren")
return self.__splitExpressionNoParen(expressionInput, breakPoint)
def __findValidBreakpoint(self, expressionInput):
multiplyBreakpoint = 1
leftExpressionInsideParen = False
parenCount = 0
for i in range(len(expressionInput)):
if expressionInput[i] == "(":
parenCount += 1
if i == 0:
leftExpressionInsideParen = True
if expressionInput[i] == ")":
parenCount -= 1
if leftExpressionInsideParen and parenCount == 0 and multiplyBreakpoint == 1:
multiplyBreakpoint = i + 1
if parenCount == 0 and (expressionInput[i] == "+"
or expressionInput[i] == "-"):
return i
return multiplyBreakpoint
def __splitExpressionParenRightNoOperator(self, expressionInput,
breakPoint):
if expressionInput[-1] == ")":
# print("Here Here")
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[:breakPoint]), "*",
self.__buildExpressionTree(expressionInput[breakPoint + 1:-1]))
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[:breakPoint + 1]), "*",
self.__buildExpressionTree(expressionInput[breakPoint + 1:]))
def __splitExpressionParenRight(self, expressionInput, breakPoint):
if expressionInput[-1] == ")":
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[:breakPoint]),
expressionInput[breakPoint],
self.__buildExpressionTree(expressionInput[breakPoint + 2:-1]))
return self.__splitExpressionNoParen(expressionInput, breakPoint)
def __splitExpressionNoParen(self, expressionInput, breakPoint):
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[:breakPoint]),
expressionInput[breakPoint],
self.__buildExpressionTree(expressionInput[breakPoint + 1:]))
def __splitExpressionParenLeft(self, expressionInput, breakPoint):
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[1:breakPoint - 1]),
expressionInput[breakPoint],
self.__buildExpressionTree(expressionInput[breakPoint + 1:]))
def __splitExpressionParenLeftNoOperator(self, expressionInput,
breakPoint):
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[1:breakPoint - 1]), "*",
self.__buildExpressionTree(expressionInput[breakPoint:]))
def __splitExpressionParenRightLeft(self, expressionInput, breakPoint):
if expressionInput[-1] == ")":
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[1:breakPoint - 1]),
expressionInput[breakPoint],
self.__buildExpressionTree(expressionInput[breakPoint + 2:-1]))
return self.__splitExpressionParenLeft(expressionInput, breakPoint)
def __splitExpressionParenRightLeftNoOperator(self, expressionInput,
breakPoint):
if expressionInput[-1] == ")":
return self.factory.CreateExpression(
self.__buildExpressionTree(expressionInput[1:breakPoint - 1]),
"*",
self.__buildExpressionTree(expressionInput[breakPoint + 1:-1]))
return self.__splitExpressionParenLeftNoOperator(
expressionInput, breakPoint)
def __isOperator(self, char):
return char == "+" or char == "-" or char == "*" or char == "/"
def __leftExpressionIsParenthetical(self, expressionInput, breakPoint):
if expressionInput[0] != "(":
return False
hasOpenedParen = False
parenCount = 0
for i in range(breakPoint - 1):
if expressionInput[i] == "(":
hasOpenedParen = True
parenCount += 1
if expressionInput[i] == ")":
parenCount -= 1
if parenCount == 0:
return False
return hasOpenedParen
def __rightExpressionIsParentheticalIncludeBreakPoint(
self, expressionInput, breakPoint):
if expressionInput[breakPoint] != "(":
return False
hasOpenedParen = False
parenCount = 0
for i in range(breakPoint, len(expressionInput) - 1):
if expressionInput[i] == "(":
hasOpenedParen = True
parenCount += 1
if expressionInput[i] == ")":
parenCount -= 1
if parenCount == 0:
return False
return hasOpenedParen
def __rightExpressionIsParentheticalExcludeBreakPoint(
self, expressionInput, breakPoint):
if expressionInput[breakPoint + 1] != "(":
return False
hasOpenedParen = False
parenCount = 0
for i in range(breakPoint, len(expressionInput) - 1):
if expressionInput[i] == "(":
hasOpenedParen = True
parenCount += 1
if expressionInput[i] == ")":
parenCount -= 1
if parenCount == 0:
return False
return hasOpenedParen
def __init__(self, inputExpression):
self.fullExpression = inputExpression.replace(" ", "")