def test_jumping(self):
# Here are some jump tests that take an input, then output 0 if the input was zero or 1 if the input was
# non-zero:
test_comp1 = comp.Computer(interactive_mode=False)
test_comp1.memory = [
3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9
]
test_comp1.input = 0
test_comp1.run()
self.assertEqual(test_comp1.output, 0)
test_comp2 = comp.Computer(interactive_mode=False)
test_comp2.memory = [
3, 12, 6, 12, 15, 1, 13, 14, 13, 4, 13, 99, -1, 0, 1, 9
]
test_comp2.input = 4 # Non-zero.
test_comp2.run()
self.assertEqual(test_comp2.output, 1)
test_comp3 = comp.Computer(interactive_mode=False)
test_comp3.memory = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1]
test_comp3.input = 0
test_comp3.run()
self.assertEqual(test_comp3.output, 0)
test_comp4 = comp.Computer(interactive_mode=False)
test_comp4.memory = [3, 3, 1105, -1, 9, 1101, 0, 0, 12, 4, 12, 99, 1]
test_comp4.input = 4 # Non-zero.
test_comp4.run()
self.assertEqual(test_comp4.output, 1)
def test_mul(self):
program = computer.Computer([1102, 2, 3, 7, 4, 7, 99, 0])
self.assertEqual(program.execute([]), [6])
program = computer.Computer([1002, 7, 3, 7, 4, 7, 99, 2])
self.assertEqual(program.execute([]), [6])
program = computer.Computer([2, 7, 6, 7, 4, 7, 99, 2])
self.assertEqual(program.execute([]), [198])
def test_add(self):
program = computer.Computer([1101, 2, 3, 7, 4, 7, 99, 0])
self.assertEqual(program.execute([]), [5])
program = computer.Computer([1001, 7, 3, 7, 4, 7, 99, 2])
self.assertEqual(program.execute([]), [5])
program = computer.Computer([1, 7, 6, 7, 4, 7, 99, 2])
self.assertEqual(program.execute([]), [101])
def test_is_equal(self):
program = computer.Computer([8, 8, 9, 7, 4, 7, 99, 0, 150, 150])
self.assertEqual(program.execute([]), [1])
program = computer.Computer([8, 8, 9, 7, 4, 7, 99, 0, 150, 100])
self.assertEqual(program.execute([]), [0])
program = computer.Computer([1108, 8, 8, 7, 4, 7, 99, 0])
self.assertEqual(program.execute([]), [1])
program = computer.Computer([1108, 9, 5, 7, 4, 7, 99, 0])
self.assertEqual(program.execute([]), [0])
def test_complex_programs(self):
test_comp1 = comp.Computer(interactive_mode=False)
test_comp1.memory = [1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50]
self.assertEqual(test_comp1.memory[0], 1)
test_comp1.run()
self.assertEqual(test_comp1.memory[0], 3500)
test_comp2 = comp.Computer(interactive_mode=False)
test_comp2.memory = [1, 1, 1, 4, 99, 5, 6, 0, 99]
self.assertEqual(test_comp2.memory[0], 1)
test_comp2.run()
self.assertEqual(test_comp2.memory[0], 30)
def test_multiply(self):
test_comp1 = comp.Computer(interactive_mode=False)
test_comp1.memory = [2, 3, 0, 3, 99] # (3 * 2 = 6)
self.assertEqual(test_comp1.memory[3],
3) # Before program is run, memory[3] should be 3.
test_comp1.run()
self.assertEqual(test_comp1.memory[3], 6)
test_comp2 = comp.Computer(interactive_mode=False)
test_comp2.memory = [2, 4, 4, 5, 99, 0] # (99 * 99 = 9801)
self.assertEqual(test_comp2.memory[5],
0) # Before program is run, memory[5] should be 0.
test_comp2.run()
self.assertEqual(test_comp2.memory[5], 9801)
def test_input_output(self):
program = computer.Computer([3, 9, 1002, 9, 3, 9, 4, 9, 99, 0])
self.assertEqual(program.execute([2]), [6])
program = computer.Computer(
[3, 11, 3, 12, 2, 11, 12, 11, 4, 11, 99, 0, 0])
self.assertEqual(program.get_state(), computer.State.INIT)
self.assertEqual(program.execute([2]), None)
self.assertEqual(program.get_state(), computer.State.WAIT)
self.assertEqual(program.execute([3]), [6])
self.assertEqual(program.get_state(), computer.State.HALT)
for i in range(1000):
program = computer.Computer([3, 0, 4, 0, 99])
self.assertEqual(program.execute([i]), [i])
def __init__(self):
"""Initiate the game."""
self.die = dice.Dice()
self.dice_score = 0
self.curplayer = None
self.otherplayer = None
self.computer = computer.Computer(1)
def test_inc_rolls(self):
"""Test if computer increase rolls works correctly."""
computer1 = computer.Computer(1)
computer1.inc_rolls()
res = computer1.rolls
exp = 1
self.assertEqual(res, exp)
def create_new_device(self, name, ip_address, is_node):
if self.tor_network.allow_name(name) and torNetwork.check_address_octals(ip_address) and self.tor_network.allow_address(ip_address):
new_label = MyLabel(self.centralwidget)
new_label.setText(ip_address)
new_label.selectedText()
if is_node:
new_node = node.Node(name, ip_address, self.tor_network)
self.listComboBox.addItem(str(new_node))
position = choice(self.node_drop_list)
self.node_drop_list.remove(position)
new_label.setGeometry(QtCore.QRect(position[0], position[1], 70, 70))
new_label.setPixmap(QtGui.QPixmap("node.png"))
new_label.show()
self.label_dict[new_label] = new_node
self.label_dict[new_node] = new_label
new_node.run_event.set()
new_node.start()
else:
new_computer = computer.Computer(name, ip_address, self.tor_network)
self.listComboBox.addItem(str(new_computer))
position = choice(self.computer_drop_list)
self.computer_drop_list.remove(position)
new_label.setGeometry(QtCore.QRect(position[0], position[1], 82, 74))
new_label.setPixmap(QtGui.QPixmap("pc.png"))
new_label.show()
self.label_dict[new_label] = new_computer
self.label_dict[new_computer] = new_label
new_computer.run_event.set()
new_computer.start()
def test_addscore(self):
"""Test if adding score works."""
computer1 = computer.Computer(1)
computer1.add_score(10)
res = computer1.score
exp = 10
self.assertEqual(res, exp)
def tests_from_02(self):
program = computer.Computer([1, 1, 1, 4, 99, 5, 6, 0, 99])
program.execute([])
self.assertEqual(program.memory[0], 30)
program = computer.Computer([2, 4, 4, 5, 99, 0])
program.execute([])
self.assertEqual(program.memory[5], 9801)
program = computer.Computer([2, 3, 0, 3, 99])
program.execute([])
self.assertEqual(program.memory[3], 6)
program = computer.Computer([1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50])
program.execute([])
self.assertEqual(program.memory[0], 3500)
def test_add(self):
test_comp = comp.Computer(interactive_mode=False)
test_comp.memory = [1, 0, 0, 0, 99] # (1 + 1 = 2)
self.assertEqual(test_comp.memory[0],
1) # Before program is run, memory[0] should be 1.
test_comp.run()
self.assertEqual(test_comp.memory[0], 2)
def test_dec_greediness(self):
"""Test if decreasing greediness works correctly."""
computer1 = computer.Computer(1)
computer1.dec_greediness()
res = computer1.greediness
exp = 6
self.assertEqual(res, exp)
def singlePlayerGame(self, choosedLevel):
self.choosedLevel = choosedLevel
computerLevel = "Easy"
if self.choosedLevel == 1:
computerLevel = "IMPOSSIBLE"
if self.choosedLevel == 2:
computerLevel = "Medium"
print(f"You play against a computer in level:{computerLevel}")
self.gameBoard, player = self.initateGame()
computerPlayer = computer.Computer(self)
while True:
self.gameBoard = self.playerTurn(player)
result, winningElements = self.check_winner()
if result is not None:
self.display_game(winningElements)
self.newGame("single")
if self.isDraw():
self.display_game()
self.newGame("single")
player = self.switch_player(player)
self.gameBoard = computerPlayer.computerMove(computerLevel)
result, winningElements = self.check_winner()
if result is not None:
self.display_game(winningElements)
self.newGame("single")
self.display_game()
player = self.switch_player(player)
def runProgram(intcode, sequence):
output = 0
for i in sequence:
cx = computer.Computer(intcode)
cx.input_add([i, output])
output = cx.run().popleft()
return output
def test_set_rolls(self):
"""Test if computers rolls is set correctly."""
computer1 = computer.Computer(1)
computer1.rolls = 5
res = computer1.rolls
exp = 5
self.assertEqual(res, exp)
def test_part_one(self):
"Test part one example of Computer object"
# 1. Create Computer object from text
myobj = computer.Computer(text=aoc_23.from_text(PART_ONE_TEXT))
# 2. Check the part one result
self.assertEqual(myobj.part_one(verbose=False), PART_ONE_RESULT)
def test_part_two(self):
"Test part two example of Computer object"
# 1. Create Computer object from text
myobj = computer.Computer(part2=True, text=aoc_23.from_text(PART_TWO_TEXT))
# 2. Check the part two result
self.assertEqual(myobj.part_two(verbose=False), PART_TWO_RESULT)
def computer_turn():
"""
Get a series of computer moves
"""
board = json.loads(request.data)
sequence = computer.Computer(board).generate_computer_sequence()
json_sequence = jsonify(sequence=sequence)
return json_sequence
def test_input_output(self):
test_comp = comp.Computer(interactive_mode=False)
test_comp.memory = [
3, 0, 4, 0, 99
] # This program puts input into address 0, then outputs it.
test_comp.input = 7
self.assertEqual(test_comp.output,
0) # Before program is run, output should be 0.
test_comp.run()
self.assertEqual(test_comp.output, 7)
def test_conditionals(self):
# 3,9,8,9,10,9,4,9,99,-1,8 - Using position mode, consider whether the input is equal to 8; output 1 (if it is)
# or 0 (if it is not).
test_comp1 = comp.Computer(interactive_mode=False)
test_comp1.memory = [3, 9, 8, 9, 10, 9, 4, 9, 99, -1, 8]
test_comp1.input = 8
test_comp1.run()
self.assertEqual(test_comp1.output, 1)
test_comp2 = comp.Computer(interactive_mode=False)
test_comp2.memory = [3, 9, 8, 9, 10, 9, 4, 9, 99, -1, 8]
test_comp2.input = 9 # This is not 8.
test_comp2.run()
self.assertEqual(test_comp2.output, 0)
# 3,9,7,9,10,9,4,9,99,-1,8 - Using position mode, consider whether the input is less than 8; output 1 (if it
# is) or 0 (if it is not).
test_comp3 = comp.Computer(interactive_mode=False)
test_comp3.memory = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8]
test_comp3.input = 7 # This is less than 8.
test_comp3.run()
self.assertEqual(test_comp3.output, 1)
test_comp4 = comp.Computer(interactive_mode=False)
test_comp4.memory = [3, 9, 7, 9, 10, 9, 4, 9, 99, -1, 8]
test_comp4.input = 9 # This is not less than 8.
test_comp4.run()
self.assertEqual(test_comp4.output, 0)
# 3,3,1108,-1,8,3,4,3,99 - Using immediate mode, consider whether the input is equal to 8; output 1 (if it is)
# or 0 (if it is not).
test_comp5 = comp.Computer(interactive_mode=False)
test_comp5.memory = [3, 3, 1108, -1, 8, 3, 4, 3, 99]
test_comp5.input = 8
test_comp5.run()
self.assertEqual(test_comp5.output, 1)
test_comp6 = comp.Computer(interactive_mode=False)
test_comp6.memory = [3, 3, 1108, -1, 8, 3, 4, 3, 99]
test_comp6.input = 3 # This is not 8.
test_comp6.run()
self.assertEqual(test_comp6.output, 0)
# 3,3,1107,-1,8,3,4,3,99 - Using immediate mode, consider whether the input is less than 8; output 1 (if it is)
# or 0 (if it is not).
test_comp7 = comp.Computer(interactive_mode=False)
test_comp7.memory = [3, 3, 1107, -1, 8, 3, 4, 3, 99]
test_comp7.input = 5 # This is less than 8.
test_comp7.run()
self.assertEqual(test_comp7.output, 1)
test_comp8 = comp.Computer(interactive_mode=False)
test_comp8.memory = [3, 3, 1107, -1, 8, 3, 4, 3, 99]
test_comp8.input = 20 # This is greater than 8.
test_comp8.run()
self.assertEqual(test_comp8.output, 0)
def __init__(self, ship, name="computer"):
ship_component.ShipComponent.__init__(self, name)
self.ship = ship
self.computer = computer.Computer()
self.computer.register_peripheral(ManeuverPeripheral(self.ship))
self.computer.register_peripheral(
InertiaPeripheral(self.ship.accelerometer, self.ship.gyroscope))
self.computer.on_error = self.on_computer_error
self.computer.load(default_ship_computer_source)
def test_day_2_program(self):
test_comp = comp.Computer(interactive_mode=False)
test_comp.load('day_2_program.txt')
# "Replace position 1 with the value 12 and replace position 2 with the value 2"
test_comp.memory[1] = 12
test_comp.memory[2] = 2
test_comp.run()
self.assertEqual(test_comp.memory[0],
5482655) # This was the solution to Part 1 of Day 2.
def runProgram(program):
cx = computer.Computer(program)
try:
cx.run()
return cx.memory_dump()
except ValueError as e:
print(f"Exception: {e}")
#mem0 = cx.memory_read(0)
#print(f"CRASH [{mem0}]")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
def test_large_example(self):
# Uses an input instruction to ask for a single number. The program will then output 999 if the input value is
# below 8, output 1000 if the input value is equal to 8, or output 1001 if the input value is greater than 8.
test_comp1 = comp.Computer(interactive_mode=False)
test_comp1.memory = [
3, 21, 1008, 21, 8, 20, 1005, 20, 22, 107, 8, 21, 20, 1006, 20, 31,
1106, 0, 36, 98, 0, 0, 1002, 21, 125, 20, 4, 20, 1105, 1, 46, 104,
999, 1105, 1, 46, 1101, 1000, 1, 20, 4, 20, 1105, 1, 46, 98, 99
]
test_comp1.input = 7 # Below 8.
test_comp1.run()
self.assertEqual(test_comp1.output, 999)
def test_set_intelligence(self):
"""Test computers intelligence is set correctly."""
computer1 = computer.Computer(1)
computer1.intelligence = 4
exp = 1
res = computer1.intelligence
self.assertEqual(res, exp)
computer1.intelligence = 2
res = computer1.intelligence
exp = 2
self.assertEqual(res, exp)
def test_empty_init(self):
"Test the default Computer creation"
# 1. Create default Computer object
myobj = computer.Computer()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 0)
self.assertEqual(len(myobj.regs), 2)
self.assertEqual(myobj.regs['a'], 0)
self.assertEqual(myobj.regs['b'], 0)
self.assertEqual(myobj.addr, 0)
def add(devices):
name = input('Name: ')
macAddress = input('macAddress: ')
ipAddress = input('ipAddress: ')
cpu = input('Enter cpu type and its speed: ')
ram = input('RAM size: ')
os = input('Operating system: ')
entry = computer.Computer(os, cpu, ram, name, macAddress, ipAddress)
if name not in devices:
devices[name] = entry
print('The entry has been added.')
else:
print('That name already exists.')
return devices
def change(devices):
name = input('Enter a name: ')
if name in devices:
macAddress = input('Enter the new macAddress number: ')
ipAddress = input('Enter the new ipAddress address: ')
cpu = input('Enter cpu type and its speed: ')
ram = input('RAM size: ')
os = input('Operating system: ')
entry = computer.Computer(os, cpu, ram, name, macAddress, ipAddress)
devices[name] = entry
print('Information updated.')
else:
print('That name is not found.')
return devices
