def test_charge_internal_battery_when_with_more_supply(self):
max_operating_power = 12 * 5
received_power = 12 * 10 # Only maximum of 9.8 - 5 [Ah] can be used for charging battery
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 1.0
expected_state_of_charge = 1.0
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
def test_keep_minimum_power_consumption(self):
power_level_max = 1.0
power_level_low = 0.2
max_operating_power = 12 * 5
received_power = 12 * 5 * 0.1 # less than max_operating_power * power_level_low
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
power_level_max=power_level_max,
power_level_low=power_level_low,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 0.2
# Discharge battery to compensate the lack of power:
expected_state_of_charge = 0.8896
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertAlmostEqual(actual_state_of_charge,
expected_state_of_charge,
delta=0.001)
def test_power_consumption_relative_to_received_power(self):
power_level_max = 1.0
power_level_low = 0.2
max_operating_power = 12 * 5
received_power = 12 * 5 * 0.3 # more than max_operating_power * power_level_low
# less than max_operating_power * power_level_max
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
power_level_max=power_level_max,
power_level_low=power_level_low,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 0.3
# Stays the same because received power is less than maximum operating power for computer:
expected_state_of_charge = 0.9
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
def test_discharge(self):
charging_state_of_charge_intercept = 1.0
charging_price_intercept = 0.5
discharging_state_of_charge_intercept = 1.2
discharging_price_intercept = 0.6
nominal_voltage = 12
nominal_current = 2
capacity_in_ah = 41.4 / nominal_voltage
internal_battery = NotebookPersonalComputer.Battery(
charging_state_of_charge_intercept, charging_price_intercept,
discharging_state_of_charge_intercept, discharging_price_intercept,
nominal_voltage, nominal_current, capacity_in_ah)
internal_battery.state_of_charge = 0.9
actual_power_that_cannot_be_supplied = internal_battery.discharge(
12 * 5 * 0.1)
actual_state_of_charge = internal_battery.state_of_charge
expected_state_of_charge = 0.7551
self.assertEqual(actual_power_that_cannot_be_supplied, 0.0)
self.assertAlmostEqual(actual_state_of_charge,
expected_state_of_charge,
delta=0.001)
def test_simple_interation_with_grid_controller(self):
supervisor = Supervisor()
notebook_personal_computer_device_id = "notebook_personal_computer_1"
max_operating_power = 12 * 5
notebook_personal_computer = NotebookPersonalComputer(notebook_personal_computer_device_id, supervisor, max_operating_power = max_operating_power)
battery_id = "battery_1"
battery_price_logic = 'moving_average' # According to the constructor of Battery class, 'hourly_preference' or 'moving_average'
capacity = 1200.0 # in [Wh] though it is defined in [Ah] in related science and data sheet
max_charge_rate = 120 # in [W], assuming it's 12[V] battery with 100 [Ah] capacity, rouchly lasting 10 hours, 10[A] maximum.
# Note: Charge rate varies depending on state of charge.
max_discharge_rate = 120 # in [W], same value as above, simplifying for now.
battery = Battery(battery_id, battery_price_logic, capacity, max_charge_rate, max_discharge_rate)
grid_controller_device_id = "grid_controller_1"
grid_controller_price_logic = 'marginal_price' # According to the constructor of GridController,
# 'weighted_average', 'marginal_price', 'marginal_price_b', or 'static_price'
grid_controller = GridController(grid_controller_device_id, supervisor, battery = battery, price_logic = grid_controller_price_logic,
connected_devices = [notebook_personal_computer])
supervisor.register_device(notebook_personal_computer)
supervisor.register_device(grid_controller)
grid_controller.send_register_message("notebook_personal_computer_1", 1)
# grid_controller.build_device_list()
grid_controller.send_power_message("notebook_personal_computer_1", 10)
def test_charging_boundary_state_of_charge(self):
charging_state_of_charge_intercept = 0.6
charging_price_intercept = 0.2
discharging_state_of_charge_intercept = 1.0
discharging_price_intercept = 0.4
nominal_voltage = 12
nominal_current = 2
capacity_in_ah = 41.4 / nominal_voltage
price = 0.1
internal_battery = NotebookPersonalComputer.Battery(
charging_state_of_charge_intercept, charging_price_intercept,
discharging_state_of_charge_intercept, discharging_price_intercept,
nominal_voltage, nominal_current, capacity_in_ah)
actual_state_of_charge = \
internal_battery._calculate_charging_boundary_state_of_charge(price)
expected_state_of_charge = 0.3
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
def test_charge_internal_battery_with_various_soc_and_price(self):
charging_state_of_charge_intercept = 1.0
charging_price_intercept = 0.5
discharging_state_of_charge_intercept = 1.2
discharging_price_intercept = 0.6
nominal_voltage = 12
nominal_current = 2
capacity_in_ah = 41.4 / nominal_voltage # [Ah]
internal_battery = NotebookPersonalComputer.Battery(
charging_state_of_charge_intercept, charging_price_intercept,
discharging_state_of_charge_intercept, discharging_price_intercept,
nominal_voltage, nominal_current, capacity_in_ah)
internal_battery.state_of_charge = 0.2
price_1 = 0.1
actual_desired_power_level_1 = internal_battery.calculate_desired_power_level(
price_1)
expected_desired_power_level_1 = 24
self.assertEqual(actual_desired_power_level_1,
expected_desired_power_level_1)
price_2 = 0.2
actual_desired_power_level_2 = internal_battery.calculate_desired_power_level(
price_2)
expected_desired_power_level_2 = 24
self.assertEqual(actual_desired_power_level_2,
expected_desired_power_level_2)
price_3 = 0.3
actual_desired_power_level_3 = internal_battery.calculate_desired_power_level(
price_3)
expected_desired_power_level_3 = 24
self.assertEqual(actual_desired_power_level_3,
expected_desired_power_level_3)
price_4 = 0.4
actual_desired_power_level_4 = internal_battery.calculate_desired_power_level(
price_4)
# Due to floating point division, charging_boundary_state_of_charge_for_given_price becomes
# 1.99... instead of 2.0
expected_desired_power_level_4 = 0
self.assertEqual(actual_desired_power_level_4,
expected_desired_power_level_4)
price_5 = 0.5
actual_desired_power_level_5 = internal_battery.calculate_desired_power_level(
price_5)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_5 = -24
self.assertEqual(actual_desired_power_level_5,
expected_desired_power_level_5)
price_6 = 0.6
actual_desired_power_level_6 = internal_battery.calculate_desired_power_level(
price_6)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_6 = -24
self.assertEqual(actual_desired_power_level_6,
expected_desired_power_level_6)
price_6 = 0.7
actual_desired_power_level_6 = internal_battery.calculate_desired_power_level(
price_6)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_6 = -24
self.assertEqual(actual_desired_power_level_6,
expected_desired_power_level_6)
internal_battery.state_of_charge = 0.5
price_7 = 0.1
actual_desired_power_level_7 = internal_battery.calculate_desired_power_level(
price_7)
expected_desired_power_level_7 = 24
self.assertEqual(actual_desired_power_level_7,
expected_desired_power_level_7)
price_8 = 0.2
actual_desired_power_level_8 = internal_battery.calculate_desired_power_level(
price_8)
expected_desired_power_level_8 = 24
self.assertEqual(actual_desired_power_level_8,
expected_desired_power_level_8)
price_9 = 0.3
actual_desired_power_level_9 = internal_battery.calculate_desired_power_level(
price_9)
expected_desired_power_level_9 = 0
self.assertEqual(actual_desired_power_level_9,
expected_desired_power_level_9)
price_10 = 0.4
actual_desired_power_level_10 = internal_battery.calculate_desired_power_level(
price_10)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_10 = -24
self.assertEqual(actual_desired_power_level_10,
expected_desired_power_level_10)
price_11 = 0.5
actual_desired_power_level_11 = internal_battery.calculate_desired_power_level(
price_11)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_11 = -24
self.assertEqual(actual_desired_power_level_11,
expected_desired_power_level_11)
price_12 = 0.6
actual_desired_power_level_12 = internal_battery.calculate_desired_power_level(
price_12)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_12 = -24
self.assertEqual(actual_desired_power_level_12,
expected_desired_power_level_12)
price_13 = 0.7
actual_desired_power_level_13 = internal_battery.calculate_desired_power_level(
price_13)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_13 = -24
self.assertEqual(actual_desired_power_level_13,
expected_desired_power_level_13)
internal_battery.state_of_charge = 0.8
price_14 = 0.1
actual_desired_power_level_14 = internal_battery.calculate_desired_power_level(
price_14)
expected_desired_power_level_14 = 24
self.assertEqual(actual_desired_power_level_14,
expected_desired_power_level_14)
price_15 = 0.2
actual_desired_power_level_15 = internal_battery.calculate_desired_power_level(
price_15)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_15 = -24
self.assertEqual(actual_desired_power_level_15,
expected_desired_power_level_15)
price_16 = 0.3
actual_desired_power_level_16 = internal_battery.calculate_desired_power_level(
price_16)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_16 = -24
self.assertEqual(actual_desired_power_level_16,
expected_desired_power_level_16)
price_17 = 0.4
actual_desired_power_level_17 = internal_battery.calculate_desired_power_level(
price_17)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_17 = -24
self.assertEqual(actual_desired_power_level_17,
expected_desired_power_level_17)
price_18 = 0.5
actual_desired_power_level_18 = internal_battery.calculate_desired_power_level(
price_18)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_18 = -24
self.assertEqual(actual_desired_power_level_18,
expected_desired_power_level_18)
price_19 = 0.6
actual_desired_power_level_19 = internal_battery.calculate_desired_power_level(
price_19)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_19 = -24
self.assertEqual(actual_desired_power_level_19,
expected_desired_power_level_19)
price_20 = 0.7
actual_desired_power_level_20 = internal_battery.calculate_desired_power_level(
price_20)
# Discharge to supply power to the computer instead of making computer get power from
# Grid Controller:
expected_desired_power_level_20 = -24
self.assertEqual(actual_desired_power_level_20,
expected_desired_power_level_20)
class NotebookPersonalComputerTest(unittest.TestCase):
def setUp(self):
self._logger = logging.getLogger("test")
self.device_id = 1 # Note: Assuming it is an integer not UUID.
self.supervisor = Supervisor()
self.notebook_personal_computer = NotebookPersonalComputer(
self.device_id, self.supervisor)
#@unittest.skip
def test_start_up(self):
self.notebook_personal_computer.start_up()
# Note: Since there is not assertNotRaises, if this test doesn't cause any error, it is considered to be success.
#@unittest.skip
def test_shut_down(self):
self.notebook_personal_computer.shut_down()
self.assertEqual(self.notebook_personal_computer._in_operation, False)
#@unittest.skip
def test_charge_internal_battery(self):
max_operating_power = 12 * 5
received_power = 12 * 9.8 # 9.8 - 5 [Ah] is used for charging battery
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.5
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity_in_ah = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 1.0
expected_state_of_charge = 0.6
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
#@unittest.skip
def test_charge_internal_battery_when_with_more_supply(self):
max_operating_power = 12 * 5
received_power = 12 * 10 # Only maximum of 9.8 - 5 [Ah] can be used for charging battery
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 1.0
expected_state_of_charge = 1.0
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
#@unittest.skip
def test_keep_minimum_power_consumption(self):
power_level_max = 1.0
power_level_low = 0.2
max_operating_power = 12 * 5
received_power = 12 * 5 * 0.1 # less than max_operating_power * power_level_low
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
power_level_max=power_level_max,
power_level_low=power_level_low,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 0.2
# Discharge battery to compensate the lack of power:
expected_state_of_charge = 0.8896
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertAlmostEqual(actual_state_of_charge,
expected_state_of_charge,
delta=0.001)
def test_power_consumption_relative_to_received_power(self):
power_level_max = 1.0
power_level_low = 0.2
max_operating_power = 12 * 5
received_power = 12 * 5 * 0.3 # more than max_operating_power * power_level_low
# less than max_operating_power * power_level_max
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.9
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
power_level_max=power_level_max,
power_level_low=power_level_low,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# Note: This acts more like private method but tested in unit test of this class:
notebook_personal_computer.respond_to_power(received_power)
expected_power_consumption_ratio = 0.3
# Stays the same because received power is less than maximum operating power for computer:
expected_state_of_charge = 0.9
actual_power_consumption_ratio = notebook_personal_computer.power_consumption_ratio
actual_state_of_charge = notebook_personal_computer.internal_battery.state_of_charge
self.assertEqual(actual_power_consumption_ratio,
expected_power_consumption_ratio)
self.assertEqual(actual_state_of_charge, expected_state_of_charge)
#@unittest.skip
def test_calculate_desired_power_level_when_medium_soc(self):
max_operating_power = 12 * 5
# Considers the chart where price is in x axis and state of charge in y axis.
charging_state_of_charge_intercept = 1.0
charging_price_intercept = 0.5
discharging_state_of_charge_intercept = 1.2 # Actually, this value is an intercept to y-axis
discharging_price_intercept = 0.6
nominal_voltage = 12
nominal_current = 2
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.5
time = parser.parse("2018-07-01 16:00:00")
sender_id = "gc_1"
message_type = MessageType.PRICE
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
charging_state_of_charge_intercept=
charging_state_of_charge_intercept,
charging_price_intercept=charging_price_intercept,
discharging_state_of_charge_intercept=
discharging_state_of_charge_intercept,
discharging_price_intercept=discharging_price_intercept,
nominal_voltage=nominal_voltage,
nominal_current=nominal_current,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# notebook_personal_computer.start_up()
# notebook_personal_computer.on()
price_1 = 0.1
message_1 = Message(time,
sender_id,
message_type,
price_1,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_1)
actual_desired_power_level_1 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_1 = 84
self.assertEqual(actual_desired_power_level_1,
expected_desired_power_level_1)
price_2 = 0.2
message_2 = Message(time,
sender_id,
message_type,
price_2,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_2)
actual_desired_power_level_2 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_2 = 36
self.assertEqual(actual_desired_power_level_2,
expected_desired_power_level_2)
price_3 = 0.3
message_3 = Message(time,
sender_id,
message_type,
price_3,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_3)
actual_desired_power_level_3 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_3 = 12
self.assertEqual(actual_desired_power_level_3,
expected_desired_power_level_3)
price_4 = 0.4
message_4 = Message(time,
sender_id,
message_type,
price_4,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_4)
actual_desired_power_level_4 = notebook_personal_computer.calculate_desired_power_level(
)
# Since notebook personal computer doesn't send power to Grid Controller,
# if the calculated desired_power_level becomes less than 0, it is set to 0.
expected_desired_power_level_4 = 0
self.assertEqual(actual_desired_power_level_4,
expected_desired_power_level_4)
def test_calculate_desired_power_level_when_medium_soc(self):
max_operating_power = 12 * 5
# Considers the chart where price is in x axis and state of charge in y axis.
charging_state_of_charge_intercept = 1.0
charging_price_intercept = 0.5
discharging_state_of_charge_intercept = 1.2 # Actually, this value is an intercept to y-axis
discharging_price_intercept = 0.6
nominal_voltage = 12
nominal_current = 2
battery_capacity = 48 * 12 # [Wh]
state_of_charge_before = 0.5
time = parser.parse("2018-07-01 16:00:00")
sender_id = "gc_1"
message_type = MessageType.PRICE
notebook_personal_computer = NotebookPersonalComputer(
self.device_id,
self.supervisor,
max_operating_power=max_operating_power,
charging_state_of_charge_intercept=
charging_state_of_charge_intercept,
charging_price_intercept=charging_price_intercept,
discharging_state_of_charge_intercept=
discharging_state_of_charge_intercept,
discharging_price_intercept=discharging_price_intercept,
nominal_voltage=nominal_voltage,
nominal_current=nominal_current,
capacity=battery_capacity)
# notebook_personal_computer.internal_battery.capacity = battery_capacity
notebook_personal_computer.internal_battery.state_of_charge = state_of_charge_before
# notebook_personal_computer.start_up()
# notebook_personal_computer.on()
price_1 = 0.1
message_1 = Message(time,
sender_id,
message_type,
price_1,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_1)
actual_desired_power_level_1 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_1 = 84
self.assertEqual(actual_desired_power_level_1,
expected_desired_power_level_1)
price_2 = 0.2
message_2 = Message(time,
sender_id,
message_type,
price_2,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_2)
actual_desired_power_level_2 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_2 = 36
self.assertEqual(actual_desired_power_level_2,
expected_desired_power_level_2)
price_3 = 0.3
message_3 = Message(time,
sender_id,
message_type,
price_3,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_3)
actual_desired_power_level_3 = notebook_personal_computer.calculate_desired_power_level(
)
expected_desired_power_level_3 = 12
self.assertEqual(actual_desired_power_level_3,
expected_desired_power_level_3)
price_4 = 0.4
message_4 = Message(time,
sender_id,
message_type,
price_4,
extra_info=None,
redirect=None)
# This message contains price and this method assign the price:
notebook_personal_computer.process_price_message(message_4)
actual_desired_power_level_4 = notebook_personal_computer.calculate_desired_power_level(
)
# Since notebook personal computer doesn't send power to Grid Controller,
# if the calculated desired_power_level becomes less than 0, it is set to 0.
expected_desired_power_level_4 = 0
self.assertEqual(actual_desired_power_level_4,
expected_desired_power_level_4)
def setUp(self):
self._logger = logging.getLogger("test")
self.device_id = 1 # Note: Assuming it is an integer not UUID.
self.supervisor = Supervisor()
self.notebook_personal_computer = NotebookPersonalComputer(
self.device_id, self.supervisor)