def test_run_does_nothing_when_finished(self, mock_parse_parameter,
mock_add):
mock_parse_parameter.return_value = (1, [])
computer = IntComputer([])
computer.finished = True
computer.run()
assert mock_add.called == False
def test_run_intcode_3(self):
expected = 2
memory = [2, 4, 4, 5, 99, 0]
computer = IntComputer(memory)
computer.run()
result = computer.memory[0]
assert expected == result
def test_with_large_numbers(self):
memory = [
109,
1,
204,
-1,
1001,
100,
1,
100,
1008,
100,
16,
101,
1006,
101,
0,
99,
]
computer = IntComputer(memory, wait_after_output=True)
all_outputs = []
while not computer.finished:
computer.run()
all_outputs.append(computer.output)
assert all_outputs[0:-1] == memory
def test_run_executes_output_handler_on_opcode_4(self,
mock_parse_parameter,
mock_output_handler):
mock_parse_parameter.side_effect = [(4, []), (99, [])]
computer = IntComputer([])
computer.run()
assert mock_output_handler.called
def test_with_1125899906842624(self):
memory = [104, 1125899906842624, 99]
computer = IntComputer(memory)
computer.run()
expected = 1125899906842624
result = computer.output
assert result == expected
def test_with_16_digit_number(self):
memory = [1102, 34915192, 34915192, 7, 4, 7, 99, 0]
computer = IntComputer(memory)
computer.run()
expected = 1219070632396864
result = computer.output
assert result == expected
def test_run_intcode_1(self):
expected = 2
memory = [1, 0, 0, 0, 99]
computer = IntComputer(memory)
computer.run()
result = computer.memory[0]
assert expected == result
def test_run_intcode_4(self):
expected = 30
memory = [1, 1, 1, 4, 99, 5, 6, 0, 99]
computer = IntComputer(memory)
computer.run()
result = computer.memory[0]
assert expected == result
def test_jump_if_false_with_true(self, mock_get_param):
expected = 3
mock_get_param.side_effect = [1, 99]
memory = []
modes = []
computer = IntComputer(memory)
computer.jump_if_false(modes)
assert computer.pointer == expected
def test_save(self, mock_get_position_for_mode):
mock_get_position_for_mode.return_value = 0
expected = 5
memory = [0]
computer = IntComputer(memory=memory, inputs=[expected])
computer.save([])
assert computer.memory[0] == expected
assert 2 == computer.pointer
def test_get_position_for_mode_supports_immediate_mode(self):
memory = [1, 2, 3, 4]
idx = 1
modes = [Mode.IMMEDIATE, Mode.POSITION, Mode.POSITION, Mode.POSITION]
expected = 1
computer = IntComputer(memory)
result = computer.get_position_for_mode(idx, modes)
assert result == expected
def test_save_with_no_inputs(self, mock_get_position_for_mode, fake_input):
expected = 5
fake_input.return_value = expected
mock_get_position_for_mode.return_value = 0
memory = [0]
computer = IntComputer(memory=memory)
computer.save([])
assert computer.memory[0] == expected
assert 2 == computer.pointer
def test_parse_parameter_with_14(self):
memory = [14]
expected_opcode = 14
expected_modes = [
Mode.POSITION, Mode.POSITION, Mode.POSITION, Mode.POSITION
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def test_equals_negative(self, mock_get_param, mock_get_position_for_mode):
expected = 0
mock_get_param.side_effect = [5, 2]
mock_get_position_for_mode.return_value = 0
memory = [-1]
modes = []
computer = IntComputer(memory)
computer.equals(modes)
assert computer.memory[0] == expected
assert computer.pointer == 4
def find_gravity_assist_inputs(memory, desired_output):
"""Find noun and verb that gives desired_output when intcode is run."""
for noun in range(0, 100):
for verb in range(0, 100):
computer = IntComputer(memory=memory[:], pointer=0)
computer.run(noun=noun, verb=verb)
output = computer.memory[0]
if output == desired_output:
return 100 * noun + verb
return False
def test_parse_parameter_with_three_modes(self):
memory = [11104]
expected_opcode = 4
expected_modes = [
Mode.IMMEDIATE, Mode.IMMEDIATE, Mode.IMMEDIATE, Mode.POSITION
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def test_parse_parameter_with_just_one_mode(self):
memory = [102]
expected_opcode = 2
expected_modes = [
Mode.IMMEDIATE, Mode.POSITION, Mode.POSITION, Mode.POSITION
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def test_adjust_relative_base(self, mock_get_param):
expected_relative_base = 99
expected_pointer = 2
mock_get_param.return_value = expected_relative_base
memory = []
modes = []
computer = IntComputer(memory)
computer.adjust_relative_base(modes)
assert computer.pointer == expected_pointer
assert computer.relative_base == expected_relative_base
def test_get_param_returns_value_from_position_provided_by_get_position_for_mode(
self, mock_get_position_for_mode):
mock_get_position_for_mode.return_value = 3
memory = [1, 2, 3, 4]
idx = 1
modes = [] # no modes needed because of mock
expected = 4
computer = IntComputer(memory)
result = computer.get_param(idx, modes)
assert result == expected
assert mock_get_position_for_mode.called_with(1, [])
def test_add(self, mock_get_param, mock_get_position):
mock_get_param.side_effect = [1, 2]
mock_get_position.return_value = 0
memory = [1, 1, 1, 1]
modes = [] # no modes needed because of mock
expected = 3
computer = IntComputer(memory)
computer.add(modes)
result = computer.memory[0] # position form mock
assert result == expected
assert 4 == computer.pointer
def test_multiply(self, mock_get_param, mock_get_position):
mock_get_param.side_effect = [3, 2]
mock_get_position.return_value = 0
memory = [1, 1, 1, 1]
modes = []
expected = 6
computer = IntComputer(memory)
computer.multiply(modes)
result = computer.memory[0]
assert result == expected
assert 4 == computer.pointer
def test_output_handler_stores_value_from_get_param_in_output(
self, mock_get_param):
expected = 12345
mock_get_param.return_value = expected
memory = []
modes = []
computer = IntComputer(memory)
computer.output_handler(modes)
result = computer.output
assert result == expected
assert 2 == computer.pointer
def test_less_than_positive(self, mock_get_param,
mock_get_position_for_mode):
expected = 1
mock_get_param.side_effect = [1, 2]
mock_get_position_for_mode.return_value = 0
memory = [-1]
modes = []
computer = IntComputer(memory)
computer.less_than(modes)
assert computer.memory[0] == expected
assert computer.pointer == 4
def test_parse_parameter_supports_relative_mode(self):
memory = [211104]
expected_opcode = 4
expected_modes = [
Mode.IMMEDIATE,
Mode.IMMEDIATE,
Mode.IMMEDIATE,
Mode.RELATIVE,
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def test_parse_parameter_with_example_from_description(self):
"""
a single opcode should result in the matching number as opcode and all modes should be 0
"""
memory = [1001]
expected_opcode = 1
expected_modes = [
Mode.POSITION, Mode.IMMEDIATE, Mode.POSITION, Mode.POSITION
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def test_parse_parameter_supports_standalone_opcode(self):
"""
a single opcode should result in the matching number as opcode and all modes should be 0
"""
memory = [3]
expected_opcode = 3
expected_modes = [
Mode.POSITION, Mode.POSITION, Mode.POSITION, Mode.POSITION
]
computer = IntComputer(memory)
result_opcode, result_modes = computer.parse_parameter()
assert result_opcode == expected_opcode
assert result_modes == expected_modes
def calculate_max_thruster(original_memory):
res = 0
all_phases = get_all_phases(0, 5)
for phases in all_phases:
second_input = 0
for phase in phases:
first_input = phase
memory = original_memory.copy()
computer = IntComputer(memory[:],
inputs=[first_input, second_input],
wait_after_output=True)
computer.run()
second_input = computer.output
if second_input > res:
res = second_input
return res
def day11_01():
program = filehelper.get_number_list_from_file("./puzzles/11/puzzle.txt")
robot = ((0, 0), Direction.UP)
computer = IntComputer(program, inputs=[0], wait_after_output=True)
hull = Hull()
hull = paint_hull(robot, computer, hull)
print(f"number of painted tiles: {hull.get_size()}")
def day11_02():
program = filehelper.get_number_list_from_file("./puzzles/11/puzzle.txt")
robot = ((0, 0), Direction.UP)
computer = IntComputer(program, wait_after_output=True)
hull = Hull()
hull.paint((0, 0), 1)
hull = paint_hull(robot, computer, hull)
hull.render()
def init_amplifiers(memory, phases):
states = [
IntComputer(memory, inputs=[phase], wait_after_output=True)
for phase in phases
]
# second input for first amplifier is 0
states[0].inputs.append(0)
return states
