def test03_adjust_volume__3_17(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(3, 17, 0)
self.assertEqual(core.playback.volume, 1)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.87) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.playback.volume, 2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(20) # More than 3x increase step time
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__3_17(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(3, 17, 0)
core.mixer.set_volume.assert_called_once_with(1)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.87) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.mixer.set_volume.call_count, 2)
core.mixer.set_volume.assert_called_with(2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.mixer.set_volume.call_count, 3)
core.mixer.set_volume.assert_called_with(2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.mixer.set_volume.call_count, 4)
core.mixer.set_volume.assert_called_with(3)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(20) # More than 3x increase step time
self.assertEqual(core.mixer.set_volume.call_count, 4)
core.mixer.set_volume.assert_called_with(3)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__3_17(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(3, 17, 0)
self.assertEqual(core.playback.volume, 1)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(
5.87
) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.playback.volume, 2)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(5.67)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(20) # More than 3x increase step time
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30_intervened(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
core.mixer.set_volume.assert_called_once_with(3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.mixer.set_volume.call_count, 2)
core.mixer.set_volume.assert_called_with(6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 3)
core.mixer.set_volume.assert_called_with(10)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 4)
core.mixer.set_volume.assert_called_with(13)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 5)
core.mixer.set_volume.assert_called_with(16)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 6)
core.mixer.set_volume.assert_called_with(19)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 7)
core.mixer.set_volume.assert_called_with(23)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 8)
core.mixer.set_volume.assert_called_with(26)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 9)
core.mixer.set_volume.assert_called_with(29)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 10)
core.mixer.set_volume.assert_called_with(32)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 11)
core.mixer.set_volume.assert_called_with(35)
self.assertEqual(threading.active_count(), threadcount + 1)
core.mixer.set_volume(14)
core.mixer.get_volume().get.side_effect = lambda: 14 # Intervention: set volume to 14
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 12)
core.mixer.set_volume.assert_called_with(14)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.mixer.set_volume.call_count, 12)
core.mixer.set_volume.assert_called_with(14)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30_intervened(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(
1.2
) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 10)
time.sleep(1)
self.assertEqual(core.playback.volume, 13)
time.sleep(1)
self.assertEqual(core.playback.volume, 16)
time.sleep(1)
self.assertEqual(core.playback.volume, 19)
time.sleep(1)
self.assertEqual(core.playback.volume, 23)
time.sleep(1)
self.assertEqual(core.playback.volume, 26)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 32)
time.sleep(1)
self.assertEqual(core.playback.volume, 35)
self.assertEqual(threading.active_count(), threadcount + 1)
core.playback.volume = mock.Mock()
core.playback.volume.get.side_effect = lambda: 14 # Intervention: set volume to 14
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertIsInstance(core.playback.volume, mock.Mock)
self.assertEqual(core.playback.volume.get(), 14)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertIsInstance(core.playback.volume, mock.Mock)
self.assertEqual(core.playback.volume.get(), 14)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__80_10(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(80, 10, 0)
core.mixer.set_volume.assert_called_once_with(7)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.mixer.set_volume.call_count, 2)
core.mixer.set_volume.assert_called_with(15)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 3)
core.mixer.set_volume.assert_called_with(22)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 4)
core.mixer.set_volume.assert_called_with(29)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 5)
core.mixer.set_volume.assert_called_with(36)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 6)
core.mixer.set_volume.assert_called_with(44)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 7)
core.mixer.set_volume.assert_called_with(51)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 8)
core.mixer.set_volume.assert_called_with(58)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 9)
core.mixer.set_volume.assert_called_with(65)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 10)
core.mixer.set_volume.assert_called_with(73)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 11)
core.mixer.set_volume.assert_called_with(80)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.mixer.set_volume.call_count, 11)
core.mixer.set_volume.assert_called_with(80)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30_intervened(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 10)
time.sleep(1)
self.assertEqual(core.playback.volume, 13)
time.sleep(1)
self.assertEqual(core.playback.volume, 16)
time.sleep(1)
self.assertEqual(core.playback.volume, 19)
time.sleep(1)
self.assertEqual(core.playback.volume, 23)
time.sleep(1)
self.assertEqual(core.playback.volume, 26)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 32)
time.sleep(1)
self.assertEqual(core.playback.volume, 35)
self.assertEqual(threading.active_count(), threadcount + 1)
core.playback.volume = mock.Mock()
core.playback.volume.get.side_effect = lambda: 14 # Intervention: set volume to 14
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertIsInstance(core.playback.volume, mock.Mock)
self.assertEqual(core.playback.volume.get(), 14)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertIsInstance(core.playback.volume, mock.Mock)
self.assertEqual(core.playback.volume.get(), 14)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_0(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 0, 0)
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_0(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 0, 0)
core.mixer.set_volume.assert_called_once_with(100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
core.mixer.set_volume.assert_called_once_with(100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_0(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 0, 0)
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__80_10(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
core.playback.volume = mock.Mock()
core.playback.volume.get.side_effect = lambda: 14 # Set volume before test to 14
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(80, 10, 0)
self.assertEqual(core.playback.volume, 7)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(
1.2
) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 15)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 22)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 36)
time.sleep(1)
self.assertEqual(core.playback.volume, 44)
time.sleep(1)
self.assertEqual(core.playback.volume, 51)
time.sleep(1)
self.assertEqual(core.playback.volume, 58)
time.sleep(1)
self.assertEqual(core.playback.volume, 65)
time.sleep(1)
self.assertEqual(core.playback.volume, 73)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 80)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 80)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__80_10(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
core.playback.volume = mock.Mock()
core.playback.volume.get.side_effect = lambda: 14 # Set volume before test to 14
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(80, 10, 0)
self.assertEqual(core.playback.volume, 7)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 15)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 22)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 36)
time.sleep(1)
self.assertEqual(core.playback.volume, 44)
time.sleep(1)
self.assertEqual(core.playback.volume, 51)
time.sleep(1)
self.assertEqual(core.playback.volume, 58)
time.sleep(1)
self.assertEqual(core.playback.volume, 65)
time.sleep(1)
self.assertEqual(core.playback.volume, 73)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 80)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 80)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_1(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 1, 0)
self.assertEqual(core.playback.volume, 50)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_1(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 1, 0)
self.assertEqual(core.playback.volume, 50)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
core.mixer.set_volume.assert_called_once_with(3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.mixer.set_volume.call_count, 2)
core.mixer.set_volume.assert_called_with(6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 3)
core.mixer.set_volume.assert_called_with(10)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 4)
core.mixer.set_volume.assert_called_with(13)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 5)
core.mixer.set_volume.assert_called_with(16)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 6)
core.mixer.set_volume.assert_called_with(19)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 7)
core.mixer.set_volume.assert_called_with(23)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 8)
core.mixer.set_volume.assert_called_with(26)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 9)
core.mixer.set_volume.assert_called_with(29)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 10)
core.mixer.set_volume.assert_called_with(32)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 11)
core.mixer.set_volume.assert_called_with(35)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 12)
core.mixer.set_volume.assert_called_with(39)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 13)
core.mixer.set_volume.assert_called_with(42)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 14)
core.mixer.set_volume.assert_called_with(45)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 15)
core.mixer.set_volume.assert_called_with(48)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 16)
core.mixer.set_volume.assert_called_with(52)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 17)
core.mixer.set_volume.assert_called_with(55)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 18)
core.mixer.set_volume.assert_called_with(58)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 19)
core.mixer.set_volume.assert_called_with(61)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 20)
core.mixer.set_volume.assert_called_with(65)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 21)
core.mixer.set_volume.assert_called_with(68)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 22)
core.mixer.set_volume.assert_called_with(71)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 23)
core.mixer.set_volume.assert_called_with(74)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 24)
core.mixer.set_volume.assert_called_with(77)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 25)
core.mixer.set_volume.assert_called_with(81)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 26)
core.mixer.set_volume.assert_called_with(84)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 27)
core.mixer.set_volume.assert_called_with(87)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 28)
core.mixer.set_volume.assert_called_with(90)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 29)
core.mixer.set_volume.assert_called_with(94)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 30)
core.mixer.set_volume.assert_called_with(97)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.mixer.set_volume.call_count, 31)
core.mixer.set_volume.assert_called_with(100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.mixer.set_volume.call_count, 31)
core.mixer.set_volume.assert_called_with(100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(
1.2
) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 10)
time.sleep(1)
self.assertEqual(core.playback.volume, 13)
time.sleep(1)
self.assertEqual(core.playback.volume, 16)
time.sleep(1)
self.assertEqual(core.playback.volume, 19)
time.sleep(1)
self.assertEqual(core.playback.volume, 23)
time.sleep(1)
self.assertEqual(core.playback.volume, 26)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 32)
time.sleep(1)
self.assertEqual(core.playback.volume, 35)
time.sleep(1)
self.assertEqual(core.playback.volume, 39)
time.sleep(1)
self.assertEqual(core.playback.volume, 42)
time.sleep(1)
self.assertEqual(core.playback.volume, 45)
time.sleep(1)
self.assertEqual(core.playback.volume, 48)
time.sleep(1)
self.assertEqual(core.playback.volume, 52)
time.sleep(1)
self.assertEqual(core.playback.volume, 55)
time.sleep(1)
self.assertEqual(core.playback.volume, 58)
time.sleep(1)
self.assertEqual(core.playback.volume, 61)
time.sleep(1)
self.assertEqual(core.playback.volume, 65)
time.sleep(1)
self.assertEqual(core.playback.volume, 68)
time.sleep(1)
self.assertEqual(core.playback.volume, 71)
time.sleep(1)
self.assertEqual(core.playback.volume, 74)
time.sleep(1)
self.assertEqual(core.playback.volume, 77)
time.sleep(1)
self.assertEqual(core.playback.volume, 81)
time.sleep(1)
self.assertEqual(core.playback.volume, 84)
time.sleep(1)
self.assertEqual(core.playback.volume, 87)
time.sleep(1)
self.assertEqual(core.playback.volume, 90)
time.sleep(1)
self.assertEqual(core.playback.volume, 94)
time.sleep(1)
self.assertEqual(core.playback.volume, 97)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
def test03_adjust_volume__100_30(self):
core = mock.Mock()
threadcount = threading.active_count()
am = AlarmManager()
am.get_core(core)
self.assertEqual(threading.active_count(), threadcount)
am.adjust_volume(100, 30, 0)
self.assertEqual(core.playback.volume, 3)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1.2) # First step has additional 0.2 seconds to prevent race conditions
self.assertEqual(core.playback.volume, 6)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 10)
time.sleep(1)
self.assertEqual(core.playback.volume, 13)
time.sleep(1)
self.assertEqual(core.playback.volume, 16)
time.sleep(1)
self.assertEqual(core.playback.volume, 19)
time.sleep(1)
self.assertEqual(core.playback.volume, 23)
time.sleep(1)
self.assertEqual(core.playback.volume, 26)
time.sleep(1)
self.assertEqual(core.playback.volume, 29)
time.sleep(1)
self.assertEqual(core.playback.volume, 32)
time.sleep(1)
self.assertEqual(core.playback.volume, 35)
time.sleep(1)
self.assertEqual(core.playback.volume, 39)
time.sleep(1)
self.assertEqual(core.playback.volume, 42)
time.sleep(1)
self.assertEqual(core.playback.volume, 45)
time.sleep(1)
self.assertEqual(core.playback.volume, 48)
time.sleep(1)
self.assertEqual(core.playback.volume, 52)
time.sleep(1)
self.assertEqual(core.playback.volume, 55)
time.sleep(1)
self.assertEqual(core.playback.volume, 58)
time.sleep(1)
self.assertEqual(core.playback.volume, 61)
time.sleep(1)
self.assertEqual(core.playback.volume, 65)
time.sleep(1)
self.assertEqual(core.playback.volume, 68)
time.sleep(1)
self.assertEqual(core.playback.volume, 71)
time.sleep(1)
self.assertEqual(core.playback.volume, 74)
time.sleep(1)
self.assertEqual(core.playback.volume, 77)
time.sleep(1)
self.assertEqual(core.playback.volume, 81)
time.sleep(1)
self.assertEqual(core.playback.volume, 84)
time.sleep(1)
self.assertEqual(core.playback.volume, 87)
time.sleep(1)
self.assertEqual(core.playback.volume, 90)
time.sleep(1)
self.assertEqual(core.playback.volume, 94)
time.sleep(1)
self.assertEqual(core.playback.volume, 97)
self.assertEqual(threading.active_count(), threadcount + 1)
time.sleep(1)
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
time.sleep(5) # More than 3x increase step time
self.assertEqual(core.playback.volume, 100)
self.assertEqual(threading.active_count(), threadcount)
