andpp/mopidy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use assert{Less,Greater}[EEqual] in tests

Browse Source
This commit is contained in:
Stein Magnus Jodal 2012-09-25 11:11:15 +02:00
parent 5a6fe0eb0a
commit b3f3cfe2a0
7 changed files with 101 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/backends/base/current_playlist.py
View File

@ -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)

10
tests/backends/base/playback.py
View File

@ -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

6
tests/frontends/mpd/protocol/current_playlist_test.py
View File

@ -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')

32
tests/frontends/mpd/protocol/playback_test.py
View File

@ -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):

24
tests/frontends/mpd/status_test.py
View File

@ -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

78
tests/frontends/mpris/player_interface_test.py
View File

@ -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')

38
tests/version_test.py
View File

@ -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())