diff --git a/tests/backends/base/current_playlist.py b/tests/backends/base/current_playlist.py index 430e4c40..a42e7eac 100644 --- a/tests/backends/base/current_playlist.py +++ b/tests/backends/base/current_playlist.py @@ -205,7 +205,7 @@ class CurrentPlaylistControllerTest(object): track2 = self.controller.tracks[2] version = self.controller.version self.controller.remove(uri=track1.uri) - self.assert_(version < self.controller.version) + self.assertLess(version, self.controller.version) self.assertNotIn(track1, self.controller.tracks) self.assertEqual(track2, self.controller.tracks[1]) @@ -281,4 +281,4 @@ class CurrentPlaylistControllerTest(object): def test_version_increases_when_appending_something(self): version = self.controller.version self.controller.append([Track()]) - self.assert_(version < self.controller.version) + self.assertLess(version, self.controller.version) diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index 1e434e35..e052a907 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -618,7 +618,7 @@ class PlaybackControllerTest(object): def test_seek_when_stopped_updates_position(self): self.playback.seek(1000) position = self.playback.time_position - self.assert_(position >= 990, position) + self.assertGreaterEqual(position, 990) def test_seek_on_empty_playlist(self): self.assertFalse(self.playback.seek(0)) @@ -644,7 +644,7 @@ class PlaybackControllerTest(object): self.playback.play() self.playback.seek(length - 1000) position = self.playback.time_position - self.assert_(position >= length - 1010, position) + self.assertGreaterEqual(position, length - 1010) @populate_playlist def test_seek_when_paused(self): @@ -660,7 +660,7 @@ class PlaybackControllerTest(object): self.playback.pause() self.playback.seek(length - 1000) position = self.playback.time_position - self.assert_(position >= length - 1010, position) + self.assertGreaterEqual(position, length - 1010) @populate_playlist def test_seek_when_paused_triggers_play(self): @@ -702,7 +702,7 @@ class PlaybackControllerTest(object): self.playback.play() self.playback.seek(-1000) position = self.playback.time_position - self.assert_(position >= 0, position) + self.assertGreaterEqual(position, 0) self.assertEqual(self.playback.state, PlaybackState.PLAYING) @populate_playlist @@ -749,7 +749,7 @@ class PlaybackControllerTest(object): first = self.playback.time_position time.sleep(1) second = self.playback.time_position - self.assert_(second > first, '%s - %s' % (first, second)) + self.assertGreater(second, first) @unittest.SkipTest # Uses sleep @populate_playlist diff --git a/tests/frontends/mpd/protocol/current_playlist_test.py b/tests/frontends/mpd/protocol/current_playlist_test.py index 21889e82..4aed5de1 100644 --- a/tests/frontends/mpd/protocol/current_playlist_test.py +++ b/tests/frontends/mpd/protocol/current_playlist_test.py @@ -415,7 +415,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): version = self.backend.current_playlist.version.get() self.sendRequest(u'shuffle') - self.assert_(version < self.backend.current_playlist.version.get()) + self.assertLess(version, self.backend.current_playlist.version.get()) self.assertInResponse(u'OK') def test_shuffle_with_open_range(self): @@ -426,7 +426,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): version = self.backend.current_playlist.version.get() self.sendRequest(u'shuffle "4:"') - self.assert_(version < self.backend.current_playlist.version.get()) + self.assertLess(version, self.backend.current_playlist.version.get()) tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'b') @@ -442,7 +442,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): version = self.backend.current_playlist.version.get() self.sendRequest(u'shuffle "1:3"') - self.assert_(version < self.backend.current_playlist.version.get()) + self.assertLess(version, self.backend.current_playlist.version.get()) tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[3].name, 'd') diff --git a/tests/frontends/mpd/protocol/playback_test.py b/tests/frontends/mpd/protocol/playback_test.py index 4f8f7430..112a13ae 100644 --- a/tests/frontends/mpd/protocol/playback_test.py +++ b/tests/frontends/mpd/protocol/playback_test.py @@ -259,25 +259,29 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): def test_play_minus_is_ignored_if_playing(self): self.backend.current_playlist.append([Track(length=40000)]) self.backend.playback.seek(30000) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertEquals(PLAYING, self.backend.playback.state.get()) self.sendRequest(u'play "-1"') self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_play_minus_one_resumes_if_paused(self): self.backend.current_playlist.append([Track(length=40000)]) self.backend.playback.seek(30000) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertEquals(PLAYING, self.backend.playback.state.get()) self.backend.playback.pause() self.assertEquals(PAUSED, self.backend.playback.state.get()) self.sendRequest(u'play "-1"') self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_playid(self): @@ -327,25 +331,29 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): def test_playid_minus_is_ignored_if_playing(self): self.backend.current_playlist.append([Track(length=40000)]) self.backend.playback.seek(30000) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertEquals(PLAYING, self.backend.playback.state.get()) self.sendRequest(u'playid "-1"') self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_playid_minus_one_resumes_if_paused(self): self.backend.current_playlist.append([Track(length=40000)]) self.backend.playback.seek(30000) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertEquals(PLAYING, self.backend.playback.state.get()) self.backend.playback.pause() self.assertEquals(PAUSED, self.backend.playback.state.get()) self.sendRequest(u'playid "-1"') self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_playid_which_does_not_exist(self): @@ -363,7 +371,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.sendRequest(u'seek "0"') self.sendRequest(u'seek "0" "30"') - self.assert_(self.backend.playback.time_position >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position, 30000) self.assertInResponse(u'OK') def test_seek_with_songpos(self): @@ -380,13 +388,15 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.sendRequest(u'seek 0') self.sendRequest(u'seek 0 30') - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_seekid(self): self.backend.current_playlist.append([Track(length=40000)]) self.sendRequest(u'seekid "0" "30"') - self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertGreaterEqual(self.backend.playback.time_position.get(), + 30000) self.assertInResponse(u'OK') def test_seekid_with_cpid(self): diff --git a/tests/frontends/mpd/status_test.py b/tests/frontends/mpd/status_test.py index 2bc3488b..59418a3b 100644 --- a/tests/frontends/mpd/status_test.py +++ b/tests/frontends/mpd/status_test.py @@ -27,19 +27,19 @@ class StatusHandlerTest(unittest.TestCase): def test_stats_method(self): result = status.stats(self.context) self.assertIn('artists', result) - self.assert_(int(result['artists']) >= 0) + self.assertGreaterEqual(int(result['artists']), 0) self.assertIn('albums', result) - self.assert_(int(result['albums']) >= 0) + self.assertGreaterEqual(int(result['albums']), 0) self.assertIn('songs', result) - self.assert_(int(result['songs']) >= 0) + self.assertGreaterEqual(int(result['songs']), 0) self.assertIn('uptime', result) - self.assert_(int(result['uptime']) >= 0) + self.assertGreaterEqual(int(result['uptime']), 0) self.assertIn('db_playtime', result) - self.assert_(int(result['db_playtime']) >= 0) + self.assertGreaterEqual(int(result['db_playtime']), 0) self.assertIn('db_update', result) - self.assert_(int(result['db_update']) >= 0) + self.assertGreaterEqual(int(result['db_update']), 0) self.assertIn('playtime', result) - self.assert_(int(result['playtime']) >= 0) + self.assertGreaterEqual(int(result['playtime']), 0) def test_status_method_contains_volume_with_na_value(self): result = dict(status.status(self.context)) @@ -98,12 +98,12 @@ class StatusHandlerTest(unittest.TestCase): def test_status_method_contains_playlistlength(self): result = dict(status.status(self.context)) self.assertIn('playlistlength', result) - self.assert_(int(result['playlistlength']) >= 0) + self.assertGreaterEqual(int(result['playlistlength']), 0) def test_status_method_contains_xfade(self): result = dict(status.status(self.context)) self.assertIn('xfade', result) - self.assert_(int(result['xfade']) >= 0) + self.assertGreaterEqual(int(result['xfade']), 0) def test_status_method_contains_state_is_play(self): self.backend.playback.state = PLAYING @@ -129,7 +129,7 @@ class StatusHandlerTest(unittest.TestCase): self.backend.playback.play() result = dict(status.status(self.context)) self.assertIn('song', result) - self.assert_(int(result['song']) >= 0) + self.assertGreaterEqual(int(result['song']), 0) def test_status_method_when_playlist_loaded_contains_cpid_as_songid(self): self.backend.current_playlist.append([Track()]) @@ -146,7 +146,7 @@ class StatusHandlerTest(unittest.TestCase): (position, total) = result['time'].split(':') position = int(position) total = int(total) - self.assert_(position <= total) + self.assertLessEqual(position, total) def test_status_method_when_playing_contains_time_with_length(self): self.backend.current_playlist.append([Track(length=10000)]) @@ -156,7 +156,7 @@ class StatusHandlerTest(unittest.TestCase): (position, total) = result['time'].split(':') position = int(position) total = int(total) - self.assert_(position <= total) + self.assertLessEqual(position, total) def test_status_method_when_playing_contains_elapsed(self): self.backend.playback.state = PAUSED diff --git a/tests/frontends/mpris/player_interface_test.py b/tests/frontends/mpris/player_interface_test.py index db7f9265..89f7f1d4 100644 --- a/tests/frontends/mpris/player_interface_test.py +++ b/tests/frontends/mpris/player_interface_test.py @@ -89,12 +89,12 @@ class PlayerInterfaceTest(unittest.TestCase): def test_get_rate_is_greater_or_equal_than_minimum_rate(self): rate = self.mpris.Get(objects.PLAYER_IFACE, 'Rate') minimum_rate = self.mpris.Get(objects.PLAYER_IFACE, 'MinimumRate') - self.assert_(rate >= minimum_rate) + self.assertGreaterEqual(rate, minimum_rate) def test_get_rate_is_less_or_equal_than_maximum_rate(self): rate = self.mpris.Get(objects.PLAYER_IFACE, 'Rate') maximum_rate = self.mpris.Get(objects.PLAYER_IFACE, 'MaximumRate') - self.assert_(rate >= maximum_rate) + self.assertGreaterEqual(rate, maximum_rate) def test_set_rate_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False @@ -246,7 +246,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(10000) result_in_microseconds = self.mpris.Get(objects.PLAYER_IFACE, 'Position') result_in_milliseconds = result_in_microseconds // 1000 - self.assert_(result_in_milliseconds >= 10000) + self.assertGreaterEqual(result_in_milliseconds, 10000) def test_get_position_when_no_current_track_should_be_zero(self): result_in_microseconds = self.mpris.Get(objects.PLAYER_IFACE, 'Position') @@ -255,11 +255,11 @@ class PlayerInterfaceTest(unittest.TestCase): def test_get_minimum_rate_is_one_or_less(self): result = self.mpris.Get(objects.PLAYER_IFACE, 'MinimumRate') - self.assert_(result <= 1.0) + self.assertLessEqual(result, 1.0) def test_get_maximum_rate_is_one_or_more(self): result = self.mpris.Get(objects.PLAYER_IFACE, 'MaximumRate') - self.assert_(result >= 1.0) + self.assertGreaterEqual(result, 1.0) def test_can_go_next_is_true_if_can_control_and_other_next_track(self): self.mpris.get_CanControl = lambda *_: True @@ -490,13 +490,13 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.state.get(), PAUSED) at_pause = self.backend.playback.time_position.get() - self.assert_(at_pause >= 0) + self.assertGreaterEqual(at_pause, 0) self.mpris.PlayPause() self.assertEquals(self.backend.playback.state.get(), PLAYING) after_pause = self.backend.playback.time_position.get() - self.assert_(after_pause >= at_pause) + self.assertGreaterEqual(after_pause, at_pause) def test_playpause_when_stopped_should_start_playback(self): self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) @@ -545,17 +545,17 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.play() before_pause = self.backend.playback.time_position.get() - self.assert_(before_pause >= 0) + self.assertGreaterEqual(before_pause, 0) self.mpris.Pause() self.assertEquals(self.backend.playback.state.get(), PAUSED) at_pause = self.backend.playback.time_position.get() - self.assert_(at_pause >= before_pause) + self.assertGreaterEqual(at_pause, before_pause) self.mpris.Play() self.assertEquals(self.backend.playback.state.get(), PLAYING) after_pause = self.backend.playback.time_position.get() - self.assert_(after_pause >= at_pause) + self.assertGreaterEqual(after_pause, at_pause) def test_play_when_there_is_no_track_has_no_effect(self): self.backend.current_playlist.clear() @@ -569,7 +569,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.play() before_seek = self.backend.playback.time_position.get() - self.assert_(before_seek >= 0) + self.assertGreaterEqual(before_seek, 0) milliseconds_to_seek = 10000 microseconds_to_seek = milliseconds_to_seek * 1000 @@ -577,15 +577,15 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Seek(microseconds_to_seek) after_seek = self.backend.playback.time_position.get() - self.assert_(before_seek <= after_seek < ( - before_seek + milliseconds_to_seek)) + self.assertLessEqual(before_seek, after_seek) + self.assertLess(after_seek, before_seek + milliseconds_to_seek) def test_seek_seeks_given_microseconds_forward_in_the_current_track(self): self.backend.current_playlist.append([Track(uri='a', length=40000)]) self.backend.playback.play() before_seek = self.backend.playback.time_position.get() - self.assert_(before_seek >= 0) + self.assertGreaterEqual(before_seek, 0) milliseconds_to_seek = 10000 microseconds_to_seek = milliseconds_to_seek * 1000 @@ -595,7 +595,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.state.get(), PLAYING) after_seek = self.backend.playback.time_position.get() - self.assert_(after_seek >= (before_seek + milliseconds_to_seek)) + self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) def test_seek_seeks_given_microseconds_backward_if_negative(self): self.backend.current_playlist.append([Track(uri='a', length=40000)]) @@ -603,7 +603,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_seek = self.backend.playback.time_position.get() - self.assert_(before_seek >= 20000) + self.assertGreaterEqual(before_seek, 20000) milliseconds_to_seek = -10000 microseconds_to_seek = milliseconds_to_seek * 1000 @@ -613,8 +613,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.state.get(), PLAYING) after_seek = self.backend.playback.time_position.get() - self.assert_(after_seek >= (before_seek + milliseconds_to_seek)) - self.assert_(after_seek < before_seek) + self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) + self.assertLess(after_seek, before_seek) def test_seek_seeks_to_start_of_track_if_new_position_is_negative(self): self.backend.current_playlist.append([Track(uri='a', length=40000)]) @@ -622,7 +622,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_seek = self.backend.playback.time_position.get() - self.assert_(before_seek >= 20000) + self.assertGreaterEqual(before_seek, 20000) milliseconds_to_seek = -30000 microseconds_to_seek = milliseconds_to_seek * 1000 @@ -632,9 +632,9 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.state.get(), PLAYING) after_seek = self.backend.playback.time_position.get() - self.assert_(after_seek >= (before_seek + milliseconds_to_seek)) - self.assert_(after_seek < before_seek) - self.assert_(after_seek >= 0) + self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) + self.assertLess(after_seek, before_seek) + self.assertGreaterEqual(after_seek, 0) def test_seek_skips_to_next_track_if_new_position_larger_than_track_length(self): self.backend.current_playlist.append([Track(uri='a', length=40000), @@ -643,7 +643,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_seek = self.backend.playback.time_position.get() - self.assert_(before_seek >= 20000) + self.assertGreaterEqual(before_seek, 20000) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -656,8 +656,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.current_track.get().uri, 'b') after_seek = self.backend.playback.time_position.get() - self.assert_(after_seek >= 0) - self.assert_(after_seek < before_seek) + self.assertGreaterEqual(after_seek, 0) + self.assertLess(after_seek, before_seek) def test_set_position_is_ignored_if_can_seek_is_false(self): self.mpris.get_CanSeek = lambda *_: False @@ -665,7 +665,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.play() before_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position <= 5000) + self.assertLessEqual(before_set_position, 5000) track_id = 'a' @@ -675,15 +675,15 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) after_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position <= after_set_position < - position_to_set_in_milliseconds) + self.assertLessEqual(before_set_position, after_set_position) + self.assertLess(after_set_position, position_to_set_in_milliseconds) def test_set_position_sets_the_current_track_position_in_microsecs(self): self.backend.current_playlist.append([Track(uri='a', length=40000)]) self.backend.playback.play() before_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position <= 5000) + self.assertLessEqual(before_set_position, 5000) self.assertEquals(self.backend.playback.state.get(), PLAYING) track_id = '/com/mopidy/track/0' @@ -696,7 +696,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.backend.playback.state.get(), PLAYING) after_set_position = self.backend.playback.time_position.get() - self.assert_(after_set_position >= position_to_set_in_milliseconds) + self.assertGreaterEqual(after_set_position, position_to_set_in_milliseconds) def test_set_position_does_nothing_if_the_position_is_negative(self): self.backend.current_playlist.append([Track(uri='a', length=40000)]) @@ -704,8 +704,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position >= 20000) - self.assert_(before_set_position <= 25000) + self.assertGreaterEqual(before_set_position, 20000) + self.assertLessEqual(before_set_position, 25000) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -717,7 +717,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) after_set_position = self.backend.playback.time_position.get() - self.assert_(after_set_position >= before_set_position) + self.assertGreaterEqual(after_set_position, before_set_position) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -727,8 +727,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position >= 20000) - self.assert_(before_set_position <= 25000) + self.assertGreaterEqual(before_set_position, 20000) + self.assertLessEqual(before_set_position, 25000) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -740,7 +740,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) after_set_position = self.backend.playback.time_position.get() - self.assert_(after_set_position >= before_set_position) + self.assertGreaterEqual(after_set_position, before_set_position) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -750,8 +750,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.playback.seek(20000) before_set_position = self.backend.playback.time_position.get() - self.assert_(before_set_position >= 20000) - self.assert_(before_set_position <= 25000) + self.assertGreaterEqual(before_set_position, 20000) + self.assertLessEqual(before_set_position, 25000) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') @@ -763,7 +763,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) after_set_position = self.backend.playback.time_position.get() - self.assert_(after_set_position >= before_set_position) + self.assertGreaterEqual(after_set_position, before_set_position) self.assertEquals(self.backend.playback.state.get(), PLAYING) self.assertEquals(self.backend.playback.current_track.get().uri, 'a') diff --git a/tests/version_test.py b/tests/version_test.py index c3eb00c1..678dc221 100644 --- a/tests/version_test.py +++ b/tests/version_test.py @@ -11,25 +11,25 @@ class VersionTest(unittest.TestCase): SV(__version__) def test_versions_can_be_strictly_ordered(self): - self.assert_(SV('0.1.0a0') < SV('0.1.0a1')) - self.assert_(SV('0.1.0a1') < SV('0.1.0a2')) - self.assert_(SV('0.1.0a2') < SV('0.1.0a3')) - self.assert_(SV('0.1.0a3') < SV('0.1.0')) - self.assert_(SV('0.1.0') < SV('0.2.0')) - self.assert_(SV('0.1.0') < SV('1.0.0')) - self.assert_(SV('0.2.0') < SV('0.3.0')) - self.assert_(SV('0.3.0') < SV('0.3.1')) - self.assert_(SV('0.3.1') < SV('0.4.0')) - self.assert_(SV('0.4.0') < SV('0.4.1')) - self.assert_(SV('0.4.1') < SV('0.5.0')) - self.assert_(SV('0.5.0') < SV('0.6.0')) - self.assert_(SV('0.6.0') < SV('0.6.1')) - self.assert_(SV('0.6.1') < SV('0.7.0')) - self.assert_(SV('0.7.0') < SV('0.7.1')) - self.assert_(SV('0.7.1') < SV('0.7.2')) - self.assert_(SV('0.7.2') < SV('0.7.3')) - self.assert_(SV('0.7.3') < SV(__version__)) - self.assert_(SV(__version__) < SV('0.8.1')) + self.assertLess(SV('0.1.0a0'), SV('0.1.0a1')) + self.assertLess(SV('0.1.0a1'), SV('0.1.0a2')) + self.assertLess(SV('0.1.0a2'), SV('0.1.0a3')) + self.assertLess(SV('0.1.0a3'), SV('0.1.0')) + self.assertLess(SV('0.1.0'), SV('0.2.0')) + self.assertLess(SV('0.1.0'), SV('1.0.0')) + self.assertLess(SV('0.2.0'), SV('0.3.0')) + self.assertLess(SV('0.3.0'), SV('0.3.1')) + self.assertLess(SV('0.3.1'), SV('0.4.0')) + self.assertLess(SV('0.4.0'), SV('0.4.1')) + self.assertLess(SV('0.4.1'), SV('0.5.0')) + self.assertLess(SV('0.5.0'), SV('0.6.0')) + self.assertLess(SV('0.6.0'), SV('0.6.1')) + self.assertLess(SV('0.6.1'), SV('0.7.0')) + self.assertLess(SV('0.7.0'), SV('0.7.1')) + self.assertLess(SV('0.7.1'), SV('0.7.2')) + self.assertLess(SV('0.7.2'), SV('0.7.3')) + self.assertLess(SV('0.7.3'), SV(__version__)) + self.assertLess(SV(__version__), SV('0.8.1')) def test_get_platform_contains_platform(self): self.assertIn(platform.platform(), get_platform())