From 985f9bf9d9232d5e9d77b603a24bfed65cfb9a1e Mon Sep 17 00:00:00 2001 From: WyattBlue Date: Mon, 23 Sep 2024 18:39:40 -0400 Subject: [PATCH] Replace self.assertEqual with `assert` statement Works better with mypy. `assert`s work equally well since we're using pytest now. --- tests/test_audiofifo.py | 25 ++++++------ tests/test_bitstream.py | 26 ++++++------ tests/test_codec_context.py | 62 ++++++++++++++--------------- tests/test_colorspace.py | 36 ++++++++--------- tests/test_containerformat.py | 74 ++++++++++++++++------------------- tests/test_decode.py | 44 ++++++++++----------- tests/test_encode.py | 8 ++-- tests/test_enums.py | 42 ++++++++++---------- tests/test_seek.py | 7 ---- tests/test_streams.py | 32 +++++++-------- tests/test_videoformat.py | 70 ++++++++++++++++----------------- 11 files changed, 205 insertions(+), 221 deletions(-) diff --git a/tests/test_audiofifo.py b/tests/test_audiofifo.py index 2874c7145..9eee420a8 100644 --- a/tests/test_audiofifo.py +++ b/tests/test_audiofifo.py @@ -59,17 +59,17 @@ def test_pts_simple(self) -> None: assert oframe.pts == 0 assert oframe.time_base == iframe.time_base - self.assertEqual(fifo.samples_written, 1024) - self.assertEqual(fifo.samples_read, 512) - self.assertEqual(fifo.pts_per_sample, 1.0) + assert fifo.samples_written == 1024 + assert fifo.samples_read == 512 + assert fifo.pts_per_sample == 1.0 iframe.pts = 1024 fifo.write(iframe) oframe = fifo.read(512) assert oframe is not None - self.assertEqual(oframe.pts, 512) - self.assertEqual(oframe.time_base, iframe.time_base) + assert oframe.pts == 512 + assert oframe.time_base == iframe.time_base iframe.pts = 9999 # Wrong! self.assertRaises(ValueError, fifo.write, iframe) @@ -88,8 +88,8 @@ def test_pts_complex(self) -> None: oframe = fifo.read_many(1024)[-1] - self.assertEqual(oframe.pts, 2048) - self.assertEqual(fifo.pts_per_sample, 2.0) + assert oframe.pts == 2048 + assert fifo.pts_per_sample == 2.0 def test_missing_sample_rate(self) -> None: fifo = av.AudioFifo() @@ -103,9 +103,9 @@ def test_missing_sample_rate(self) -> None: oframe = fifo.read(512) assert oframe is not None - self.assertIsNone(oframe.pts) - self.assertEqual(oframe.sample_rate, 0) - self.assertEqual(oframe.time_base, iframe.time_base) + assert oframe.pts is None + assert oframe.sample_rate == 0 + assert oframe.time_base == iframe.time_base def test_missing_time_base(self) -> None: fifo = av.AudioFifo() @@ -119,6 +119,5 @@ def test_missing_time_base(self) -> None: oframe = fifo.read(512) assert oframe is not None - self.assertIsNone(oframe.pts) - self.assertIsNone(oframe.time_base) - self.assertEqual(oframe.sample_rate, iframe.sample_rate) + assert oframe.pts is None and oframe.time_base is None + assert oframe.sample_rate == iframe.sample_rate diff --git a/tests/test_bitstream.py b/tests/test_bitstream.py index 8538594a7..335abac1c 100644 --- a/tests/test_bitstream.py +++ b/tests/test_bitstream.py @@ -23,14 +23,14 @@ def test_filter_chomp(self) -> None: ctx = BitStreamFilterContext("chomp") src_packets: tuple[Packet, None] = (Packet(b"\x0012345\0\0\0"), None) - self.assertEqual(bytes(src_packets[0]), b"\x0012345\0\0\0") + assert bytes(src_packets[0]) == b"\x0012345\0\0\0" result_packets = [] for p in src_packets: result_packets.extend(ctx.filter(p)) - self.assertEqual(len(result_packets), 1) - self.assertEqual(bytes(result_packets[0]), b"\x0012345") + assert len(result_packets) == 1 + assert bytes(result_packets[0]) == b"\x0012345" def test_filter_setts(self) -> None: ctx = BitStreamFilterContext("setts=pts=N") @@ -48,9 +48,9 @@ def test_filter_setts(self) -> None: for p in src_packets: result_packets.extend(ctx.filter(p)) - self.assertEqual(len(result_packets), 2) - self.assertEqual(result_packets[0].pts, 0) - self.assertEqual(result_packets[1].pts, 1) + assert len(result_packets) == 2 + assert result_packets[0].pts == 0 + assert result_packets[1].pts == 1 def test_filter_h264_mp4toannexb(self) -> None: with av.open(fate_suite("h264/interlaced_crop.mp4"), "r") as container: @@ -62,22 +62,22 @@ def test_filter_h264_mp4toannexb(self) -> None: self.assertFalse(is_annexb(p)) res_packets.extend(ctx.filter(p)) - self.assertEqual(len(res_packets), stream.frames) + assert len(res_packets) == stream.frames for p in res_packets: - self.assertTrue(is_annexb(p)) + assert is_annexb(p) def test_filter_output_parameters(self) -> None: with av.open(fate_suite("h264/interlaced_crop.mp4"), "r") as container: stream = container.streams.video[0] - self.assertFalse(is_annexb(stream.codec_context.extradata)) + assert not is_annexb(stream.codec_context.extradata) ctx = BitStreamFilterContext("h264_mp4toannexb", stream) - self.assertFalse(is_annexb(stream.codec_context.extradata)) + assert not is_annexb(stream.codec_context.extradata) del ctx _ = BitStreamFilterContext("h264_mp4toannexb", stream, out_stream=stream) - self.assertTrue(is_annexb(stream.codec_context.extradata)) + assert is_annexb(stream.codec_context.extradata) def test_filter_flush(self) -> None: with av.open(fate_suite("h264/interlaced_crop.mp4"), "r") as container: @@ -87,7 +87,7 @@ def test_filter_flush(self) -> None: res_packets = [] for p in container.demux(stream): res_packets.extend(ctx.filter(p)) - self.assertEqual(len(res_packets), stream.frames) + assert len(res_packets) == stream.frames container.seek(0) # Without flushing, we expect to get an error: "A non-NULL packet sent after an EOF." @@ -100,4 +100,4 @@ def test_filter_flush(self) -> None: for p in container.demux(stream): res_packets.extend(ctx.filter(p)) - self.assertEqual(len(res_packets), stream.frames * 2) + assert len(res_packets) == stream.frames * 2 diff --git a/tests/test_codec_context.py b/tests/test_codec_context.py index 12997d76a..cb89b74d0 100644 --- a/tests/test_codec_context.py +++ b/tests/test_codec_context.py @@ -38,52 +38,52 @@ def iter_raw_frames(path, packet_sizes, ctx): class TestCodecContext(TestCase): def test_skip_frame_default(self): ctx = Codec("png", "w").create() - self.assertEqual(ctx.skip_frame.name, "DEFAULT") + assert ctx.skip_frame.name == "DEFAULT" def test_codec_delay(self): with av.open(fate_suite("mkv/codec_delay_opus.mkv")) as container: - self.assertEqual(container.streams.audio[0].codec_context.delay, 312) + assert container.streams.audio[0].codec_context.delay == 312 with av.open(fate_suite("h264/interlaced_crop.mp4")) as container: - self.assertEqual(container.streams.video[0].codec_context.delay, 0) + assert container.streams.video[0].codec_context.delay == 0 def test_codec_tag(self): ctx = Codec("mpeg4", "w").create() - self.assertEqual(ctx.codec_tag, "\x00\x00\x00\x00") + assert ctx.codec_tag == "\x00\x00\x00\x00" ctx.codec_tag = "xvid" - self.assertEqual(ctx.codec_tag, "xvid") + assert ctx.codec_tag == "xvid" # wrong length with self.assertRaises(ValueError) as cm: ctx.codec_tag = "bob" - self.assertEqual(str(cm.exception), "Codec tag should be a 4 character string.") + assert str(cm.exception) == "Codec tag should be a 4 character string." # wrong type with self.assertRaises(ValueError) as cm: ctx.codec_tag = 123 - self.assertEqual(str(cm.exception), "Codec tag should be a 4 character string.") + assert str(cm.exception) == "Codec tag should be a 4 character string." with av.open(fate_suite("h264/interlaced_crop.mp4")) as container: - self.assertEqual(container.streams[0].codec_tag, "avc1") + assert container.streams[0].codec_tag == "avc1" def test_decoder_extradata(self): ctx = av.codec.Codec("h264", "r").create() - self.assertEqual(ctx.extradata, None) - self.assertEqual(ctx.extradata_size, 0) + assert ctx.extradata is None + assert ctx.extradata_size == 0 ctx.extradata = b"123" - self.assertEqual(ctx.extradata, b"123") - self.assertEqual(ctx.extradata_size, 3) + assert ctx.extradata == b"123" + assert ctx.extradata_size == 3 ctx.extradata = b"54321" - self.assertEqual(ctx.extradata, b"54321") - self.assertEqual(ctx.extradata_size, 5) + assert ctx.extradata == b"54321" + assert ctx.extradata_size == 5 ctx.extradata = None - self.assertEqual(ctx.extradata, None) - self.assertEqual(ctx.extradata_size, 0) + assert ctx.extradata is None + assert ctx.extradata_size == 0 - def test_decoder_gop_size(self): - ctx = av.codec.Codec("h264", "r").create() + def test_decoder_gop_size(self) -> None: + ctx = av.codec.Codec("h264", "r").create("video") with self.assertRaises(RuntimeError): ctx.gop_size @@ -99,7 +99,7 @@ def test_decoder_timebase(self) -> None: def test_encoder_extradata(self): ctx = av.codec.Codec("h264", "w").create() - self.assertEqual(ctx.extradata, None) + assert ctx.extradata is None self.assertEqual(ctx.extradata_size, 0) ctx.extradata = b"123" @@ -170,7 +170,7 @@ def _assert_parse(self, codec_name, path): parsed_source = b"".join(bytes(p) for p in packets) self.assertEqual(len(parsed_source), len(full_source)) - self.assertEqual(full_source, parsed_source) + assert full_source == parsed_source class TestEncoding(TestCase): @@ -214,7 +214,7 @@ def image_sequence_encode(self, codec_name: str) -> None: new_frame = frame.reformat(width, height, pix_fmt) new_packets = ctx.encode(new_frame) - self.assertEqual(len(new_packets), 1) + assert len(new_packets) == 1 new_packet = new_packets[0] path = self.sandboxed( @@ -240,9 +240,9 @@ def image_sequence_encode(self, codec_name: str) -> None: packet = Packet(size) size = f.readinto(packet) frame = ctx.decode(packet)[0] - self.assertEqual(frame.width, width) - self.assertEqual(frame.height, height) - self.assertEqual(frame.format.name, pix_fmt) + assert frame.width == width + assert frame.height == height + assert frame.format.name == pix_fmt def test_encoding_h264(self): self.video_encoding("h264", {"crf": "19"}) @@ -333,13 +333,13 @@ def video_encoding(self, codec_name, options={}, codec_tag=None): decoded_frame_count = 0 for frame in iter_raw_frames(path, packet_sizes, ctx): decoded_frame_count += 1 - self.assertEqual(frame.width, width) - self.assertEqual(frame.height, height) - self.assertEqual(frame.format.name, pix_fmt) + assert frame.width == width + assert frame.height == height + assert frame.format.name == pix_fmt if frame.key_frame: keyframe_indices.append(decoded_frame_count) - self.assertEqual(frame_count, decoded_frame_count) + assert frame_count == decoded_frame_count self.assertIsInstance( all(keyframe_index for keyframe_index in keyframe_indices), int @@ -352,7 +352,7 @@ def video_encoding(self, codec_name, options={}, codec_tag=None): ): raise SkipTest() for i in decoded_gop_sizes: - self.assertEqual(i, gop_size) + assert i == gop_size final_gop_size = decoded_frame_count - max(keyframe_indices) self.assertLessEqual(final_gop_size, gop_size) @@ -433,5 +433,5 @@ def _audio_encoding( for frame in iter_raw_frames(path, packet_sizes, ctx): result_samples += frame.samples - self.assertEqual(frame.sample_rate, sample_rate) - self.assertEqual(frame.layout.nb_channels, 2) + assert frame.sample_rate == sample_rate + assert frame.layout.nb_channels == 2 diff --git a/tests/test_colorspace.py b/tests/test_colorspace.py index afc16846f..b54229643 100644 --- a/tests/test_colorspace.py +++ b/tests/test_colorspace.py @@ -1,31 +1,29 @@ import av from av.video.reformatter import ColorRange, Colorspace -from .common import TestCase, fate_suite +from .common import fate_suite -class TestColorSpace(TestCase): +class TestColorSpace: def test_penguin_joke(self) -> None: container = av.open( fate_suite("amv/MTV_high_res_320x240_sample_Penguin_Joke_MTV_from_WMV.amv") ) stream = container.streams.video[0] - self.assertEqual(stream.codec_context.color_range, 2) - self.assertEqual(stream.codec_context.color_range, ColorRange.JPEG) + assert stream.codec_context.color_range == 2 + assert stream.codec_context.color_range == ColorRange.JPEG - self.assertEqual(stream.codec_context.color_primaries, 2) - self.assertEqual(stream.codec_context.color_trc, 2) + assert stream.codec_context.color_primaries == 2 + assert stream.codec_context.color_trc == 2 - self.assertEqual(stream.codec_context.colorspace, 5) - self.assertEqual(stream.codec_context.colorspace, Colorspace.ITU601) + assert stream.codec_context.colorspace == 5 + assert stream.codec_context.colorspace == Colorspace.ITU601 - for packet in container.demux(stream): - for frame in packet.decode(): - assert isinstance(frame, av.VideoFrame) - self.assertEqual(frame.color_range, ColorRange.JPEG) # a.k.a "pc" - self.assertEqual(frame.colorspace, Colorspace.ITU601) - return + for frame in container.decode(stream): + assert frame.color_range == ColorRange.JPEG # a.k.a "pc" + assert frame.colorspace == Colorspace.ITU601 + return def test_sky_timelapse(self) -> None: container = av.open( @@ -33,8 +31,8 @@ def test_sky_timelapse(self) -> None: ) stream = container.streams.video[0] - self.assertEqual(stream.codec_context.color_range, 1) - self.assertEqual(stream.codec_context.color_range, ColorRange.MPEG) - self.assertEqual(stream.codec_context.color_primaries, 1) - self.assertEqual(stream.codec_context.color_trc, 1) - self.assertEqual(stream.codec_context.colorspace, 1) + assert stream.codec_context.color_range == 1 + assert stream.codec_context.color_range == ColorRange.MPEG + assert stream.codec_context.color_primaries == 1 + assert stream.codec_context.color_trc == 1 + assert stream.codec_context.colorspace == 1 diff --git a/tests/test_containerformat.py b/tests/test_containerformat.py index 5b6d31c35..6475cf9cd 100644 --- a/tests/test_containerformat.py +++ b/tests/test_containerformat.py @@ -1,63 +1,57 @@ from av import ContainerFormat, formats_available, open -from .common import TestCase - -class TestContainerFormats(TestCase): +class TestContainerFormats: def test_matroska(self) -> None: with open("test.mkv", "w") as container: - self.assertNotEqual(container.default_video_codec, "none") - self.assertNotEqual(container.default_audio_codec, "none") - self.assertEqual(container.default_subtitle_codec, "ass") - self.assertIn("ass", container.supported_codecs) + assert container.default_video_codec != "none" + assert container.default_audio_codec != "none" + assert container.default_subtitle_codec == "ass" + assert "ass" in container.supported_codecs fmt = ContainerFormat("matroska") - self.assertTrue(fmt.is_input) - self.assertTrue(fmt.is_output) - self.assertEqual(fmt.name, "matroska") - self.assertEqual(fmt.long_name, "Matroska") - self.assertIn("mkv", fmt.extensions) - self.assertFalse(fmt.no_file) + assert fmt.is_input and fmt.is_output + assert fmt.name == "matroska" + assert fmt.long_name == "Matroska" + assert "mkv" in fmt.extensions + assert not fmt.no_file def test_mov(self) -> None: with open("test.mov", "w") as container: - self.assertNotEqual(container.default_video_codec, "none") - self.assertNotEqual(container.default_audio_codec, "none") - self.assertEqual(container.default_subtitle_codec, "none") - self.assertIn("h264", container.supported_codecs) + assert container.default_video_codec != "none" + assert container.default_audio_codec != "none" + assert container.default_subtitle_codec == "none" + assert "h264" in container.supported_codecs fmt = ContainerFormat("mov") - self.assertTrue(fmt.is_input) - self.assertTrue(fmt.is_output) - self.assertEqual(fmt.name, "mov") - self.assertEqual(fmt.long_name, "QuickTime / MOV") - self.assertIn("mov", fmt.extensions) - self.assertFalse(fmt.no_file) + assert fmt.is_input and fmt.is_output + assert fmt.name == "mov" + assert fmt.long_name == "QuickTime / MOV" + assert "mov" in fmt.extensions + assert not fmt.no_file def test_gif(self) -> None: with open("test.gif", "w") as container: - self.assertEqual(container.default_video_codec, "gif") - self.assertEqual(container.default_audio_codec, "none") - self.assertEqual(container.default_subtitle_codec, "none") - self.assertIn("gif", container.supported_codecs) + assert container.default_video_codec == "gif" + assert container.default_audio_codec == "none" + assert container.default_subtitle_codec == "none" + assert "gif" in container.supported_codecs def test_stream_segment(self) -> None: # This format goes by two names, check both. fmt = ContainerFormat("stream_segment") - self.assertFalse(fmt.is_input) - self.assertTrue(fmt.is_output) - self.assertEqual(fmt.name, "stream_segment") - self.assertEqual(fmt.long_name, "streaming segment muxer") - self.assertEqual(fmt.extensions, set()) - self.assertTrue(fmt.no_file) + assert not fmt.is_input and fmt.is_output + assert fmt.name == "stream_segment" + assert fmt.long_name == "streaming segment muxer" + assert fmt.extensions == set() + assert fmt.no_file fmt = ContainerFormat("ssegment") - self.assertFalse(fmt.is_input) - self.assertTrue(fmt.is_output) - self.assertEqual(fmt.name, "ssegment") - self.assertEqual(fmt.long_name, "streaming segment muxer") - self.assertEqual(fmt.extensions, set()) - self.assertTrue(fmt.no_file) + assert not fmt.is_input and fmt.is_output + assert fmt.name == "ssegment" + assert fmt.long_name == "streaming segment muxer" + assert fmt.extensions == set() + assert fmt.no_file def test_formats_available(self) -> None: - self.assertTrue(formats_available) + assert formats_available diff --git a/tests/test_decode.py b/tests/test_decode.py index 87a84ba12..82e8461e2 100644 --- a/tests/test_decode.py +++ b/tests/test_decode.py @@ -6,21 +6,19 @@ class TestDecode(TestCase): - def test_decoded_video_frame_count(self): + def test_decoded_video_frame_count(self) -> None: container = av.open(fate_suite("h264/interlaced_crop.mp4")) video_stream = next(s for s in container.streams if s.type == "video") - self.assertIs(video_stream, container.streams.video[0]) + assert video_stream is container.streams.video[0] frame_count = 0 + for frame in container.decode(video_stream): + frame_count += 1 - for packet in container.demux(video_stream): - for frame in packet.decode(): - frame_count += 1 + assert frame_count == video_stream.frames - self.assertEqual(frame_count, video_stream.frames) - - def test_decode_audio_corrupt(self): + def test_decode_audio_corrupt(self) -> None: # write an empty file path = self.sandboxed("empty.flac") with open(path, "wb"): @@ -35,36 +33,38 @@ def test_decode_audio_corrupt(self): frame_count += 1 packet_count += 1 - self.assertEqual(packet_count, 1) - self.assertEqual(frame_count, 0) + assert packet_count == 1 + assert frame_count == 0 - def test_decode_audio_sample_count(self): + def test_decode_audio_sample_count(self) -> None: container = av.open(fate_suite("audio-reference/chorusnoise_2ch_44kHz_s16.wav")) audio_stream = next(s for s in container.streams if s.type == "audio") - self.assertIs(audio_stream, container.streams.audio[0]) + assert audio_stream is container.streams.audio[0] + assert isinstance(audio_stream, av.audio.AudioStream) sample_count = 0 - for packet in container.demux(audio_stream): - for frame in packet.decode(): - sample_count += frame.samples + for frame in container.decode(audio_stream): + sample_count += frame.samples + assert audio_stream.duration is not None + assert audio_stream.time_base is not None total_samples = ( audio_stream.duration * audio_stream.sample_rate.numerator ) / audio_stream.time_base.denominator - self.assertEqual(sample_count, total_samples) + assert sample_count == total_samples def test_decoded_time_base(self): container = av.open(fate_suite("h264/interlaced_crop.mp4")) stream = container.streams.video[0] - self.assertEqual(stream.time_base, Fraction(1, 25)) + assert stream.time_base == Fraction(1, 25) for packet in container.demux(stream): for frame in packet.decode(): - self.assertEqual(packet.time_base, frame.time_base) - self.assertEqual(stream.time_base, frame.time_base) + assert packet.time_base == frame.time_base + assert stream.time_base == frame.time_base return def test_decoded_motion_vectors(self): @@ -109,8 +109,8 @@ def test_decode_video_corrupt(self): frame_count += 1 packet_count += 1 - self.assertEqual(packet_count, 1) - self.assertEqual(frame_count, 0) + assert packet_count == 1 + assert frame_count == 0 def test_decode_close_then_use(self): container = av.open(fate_suite("h264/interlaced_crop.mp4")) @@ -155,4 +155,4 @@ def test_flush_decoded_video_frame_count(self): self.assertIsNone(frame.time_base) output_count += 1 - self.assertEqual(output_count, input_count) + assert output_count == input_count diff --git a/tests/test_encode.py b/tests/test_encode.py index 79c8423bf..40b17cd73 100644 --- a/tests/test_encode.py +++ b/tests/test_encode.py @@ -232,13 +232,13 @@ class TestEncodeStreamSemantics(TestCase): def test_stream_index(self) -> None: with av.open(self.sandboxed("output.mov"), "w") as output: vstream = output.add_stream("mpeg4", 24) - self.assertIn(vstream, output.streams.video) + assert vstream in output.streams.video vstream.pix_fmt = "yuv420p" vstream.width = 320 vstream.height = 240 astream = output.add_stream("mp2", 48000) - self.assertIn(astream, output.streams.audio) + assert astream in output.streams.audio astream.layout = "stereo" # type: ignore astream.format = "s16" # type: ignore @@ -248,7 +248,7 @@ def test_stream_index(self) -> None: vframe = VideoFrame(320, 240, "yuv420p") vpacket = vstream.encode(vframe)[0] - self.assertIs(vpacket.stream, vstream) + assert vpacket.stream is vstream assert vpacket.stream_index == 0 for i in range(10): @@ -264,7 +264,7 @@ def test_stream_index(self) -> None: apacket = apackets[0] break - self.assertIs(apacket.stream, astream) + assert apacket.stream is astream assert apacket.stream_index == 1 def test_stream_audio_resample(self) -> None: diff --git a/tests/test_enums.py b/tests/test_enums.py index 8e4839a77..30eb125f1 100644 --- a/tests/test_enums.py +++ b/tests/test_enums.py @@ -31,9 +31,9 @@ def test_access(self): foo2 = cls["FOO"] foo3 = cls[1] foo4 = cls[foo1] - self.assertIs(foo1, foo2) - self.assertIs(foo1, foo3) - self.assertIs(foo1, foo4) + assert foo1 is foo2 + assert foo1 is foo3 + assert foo1 is foo4 self.assertIn(foo1, cls) self.assertIn("FOO", cls) @@ -44,7 +44,7 @@ def test_access(self): self.assertRaises(TypeError, lambda: cls[()]) self.assertEqual(cls.get("FOO"), foo1) - self.assertIs(cls.get("not a foo"), None) + assert cls.get("not a foo") is None def test_casting(self): cls = self.define_foobar() @@ -86,8 +86,8 @@ def test_as_key(self): d = {foo: "value"} self.assertEqual(d[foo], "value") - self.assertIs(d.get("FOO"), None) - self.assertIs(d.get(1), None) + assert d.get("FOO") is None + assert d.get(1) is None def test_pickleable(self): cls = PickleableFooBar @@ -97,7 +97,7 @@ def test_pickleable(self): foo2 = pickle.loads(enc) - self.assertIs(foo, foo2) + assert foo is foo2 def test_create_unknown(self): cls = self.define_foobar() @@ -118,7 +118,7 @@ def test_multiple_names(self): ), ) - self.assertIs(cls.F, cls.FOO) + assert cls.F is cls.FOO self.assertEqual(cls.F.name, "FOO") self.assertNotEqual(cls.F.name, "F") # This is actually the string. @@ -140,24 +140,24 @@ def test_flag_basics(self): bar = cls.BAR foobar = foo | bar - self.assertIs(foobar, cls.FOOBAR) + assert foobar is cls.FOOBAR foo2 = foobar & foo - self.assertIs(foo2, foo) + assert foo2 is foo bar2 = foobar ^ foo - self.assertIs(bar2, bar) + assert bar2 is bar bar3 = foobar & ~foo - self.assertIs(bar3, bar) + assert bar3 is bar x = cls.FOO x |= cls.BAR - self.assertIs(x, cls.FOOBAR) + assert x is cls.FOOBAR x = cls.FOOBAR x &= cls.FOO - self.assertIs(x, cls.FOO) + assert x is cls.FOO def test_multi_flags_basics(self): cls = self.define_foobar(is_flags=True) @@ -173,9 +173,9 @@ def test_multi_flags_basics(self): foobar3 = cls[3] foobar4 = cls[foobar] - self.assertIs(foobar, foobar2) - self.assertIs(foobar, foobar3) - self.assertIs(foobar, foobar4) + assert foobar is foobar2 + assert foobar is foobar3 + assert foobar is foobar4 self.assertRaises(KeyError, lambda: cls["FOO|BAR"]) @@ -186,7 +186,7 @@ def test_multi_flags_create_missing(self): cls = self.define_foobar(is_flags=True) foobar = cls[3] - self.assertIs(foobar, cls.FOO | cls.BAR) + assert foobar is cls.FOO | cls.BAR self.assertRaises(KeyError, lambda: cls[4]) # Not FOO or BAR self.assertRaises(KeyError, lambda: cls[7]) # FOO and BAR and missing flag. @@ -212,16 +212,16 @@ def flags(self, value): obj = Class("FOO") - self.assertIs(obj.flags, Flags.FOO) + assert obj.flags is Flags.FOO self.assertTrue(obj.foo) self.assertFalse(obj.bar) obj.bar = True - self.assertIs(obj.flags, foobar) + assert obj.flags is foobar self.assertTrue(obj.foo) self.assertTrue(obj.bar) obj.foo = False - self.assertIs(obj.flags, Flags.BAR) + assert obj.flags is Flags.BAR self.assertFalse(obj.foo) self.assertTrue(obj.bar) diff --git a/tests/test_seek.py b/tests/test_seek.py index ee6f84536..1ba71cc34 100644 --- a/tests/test_seek.py +++ b/tests/test_seek.py @@ -13,13 +13,6 @@ def timestamp_to_frame(timestamp, stream): return frame -def step_forward(container, stream): - for packet in container.demux(stream): - for frame in packet.decode(): - if frame: - return frame - - class TestSeek(TestCase): def test_seek_float(self): container = av.open(fate_suite("h264/interlaced_crop.mp4")) diff --git a/tests/test_streams.py b/tests/test_streams.py index c146abfb1..64bb63c36 100644 --- a/tests/test_streams.py +++ b/tests/test_streams.py @@ -1,18 +1,18 @@ import av -from .common import TestCase, fate_suite +from .common import fate_suite -class TestStreams(TestCase): - def test_stream_tuples(self): +class TestStreams: + def test_stream_tuples(self) -> None: for fate_name in ("h264/interlaced_crop.mp4",): container = av.open(fate_suite(fate_name)) video_streams = tuple([s for s in container.streams if s.type == "video"]) - self.assertEqual(video_streams, container.streams.video) + assert video_streams == container.streams.video audio_streams = tuple([s for s in container.streams if s.type == "audio"]) - self.assertEqual(audio_streams, container.streams.audio) + assert audio_streams == container.streams.audio def test_selection(self) -> None: container = av.open( @@ -21,29 +21,29 @@ def test_selection(self) -> None: video = container.streams.video[0] audio = container.streams.audio[0] - self.assertEqual([video], container.streams.get(video=0)) - self.assertEqual([video], container.streams.get(video=(0,))) + assert [video] == container.streams.get(video=0) + assert [video] == container.streams.get(video=(0,)) - self.assertEqual(video, container.streams.best("video")) - self.assertEqual(audio, container.streams.best("audio")) + assert video == container.streams.best("video") + assert audio == container.streams.best("audio") container = av.open(fate_suite("sub/MovText_capability_tester.mp4")) subtitle = container.streams.subtitles[0] - self.assertEqual(subtitle, container.streams.best("subtitle")) + assert subtitle == container.streams.best("subtitle") container = av.open(fate_suite("mxf/track_01_v02.mxf")) data = container.streams.data[0] - self.assertEqual(data, container.streams.best("data")) + assert data == container.streams.best("data") - def test_noside_data(self): + def test_noside_data(self) -> None: container = av.open(fate_suite("h264/interlaced_crop.mp4")) video = container.streams.video[0] - self.assertEqual(video.nb_side_data, 0) + assert video.nb_side_data == 0 - def test_side_data(self): + def test_side_data(self) -> None: container = av.open(fate_suite("mov/displaymatrix.mov")) video = container.streams.video[0] - self.assertEqual(video.nb_side_data, 1) - self.assertEqual(video.side_data["DISPLAYMATRIX"], -90.0) + assert video.nb_side_data == 1 + assert video.side_data["DISPLAYMATRIX"] == -90.0 diff --git a/tests/test_videoformat.py b/tests/test_videoformat.py index 61b9ca0fc..4670dc217 100644 --- a/tests/test_videoformat.py +++ b/tests/test_videoformat.py @@ -7,47 +7,47 @@ class TestVideoFormats(TestCase): def test_invalid_pixel_format(self): with self.assertRaises(ValueError) as cm: VideoFormat("__unknown_pix_fmt", 640, 480) - self.assertEqual(str(cm.exception), "not a pixel format: '__unknown_pix_fmt'") + assert str(cm.exception) == "not a pixel format: '__unknown_pix_fmt'" def test_rgb24_inspection(self): fmt = VideoFormat("rgb24", 640, 480) - self.assertEqual(fmt.name, "rgb24") - self.assertEqual(len(fmt.components), 3) + assert fmt.name == "rgb24" + assert len(fmt.components) == 3 self.assertFalse(fmt.is_planar) self.assertFalse(fmt.has_palette) self.assertTrue(fmt.is_rgb) - self.assertEqual(fmt.chroma_width(), 640) - self.assertEqual(fmt.chroma_height(), 480) - self.assertEqual(fmt.chroma_width(1024), 1024) - self.assertEqual(fmt.chroma_height(1024), 1024) + assert fmt.chroma_width() == 640 + assert fmt.chroma_height() == 480 + assert fmt.chroma_width(1024) == 1024 + assert fmt.chroma_height(1024) == 1024 for i in range(3): comp = fmt.components[i] - self.assertEqual(comp.plane, 0) - self.assertEqual(comp.bits, 8) + assert comp.plane == 0 + assert comp.bits == 8 self.assertFalse(comp.is_luma) self.assertFalse(comp.is_chroma) self.assertFalse(comp.is_alpha) - self.assertEqual(comp.width, 640) - self.assertEqual(comp.height, 480) + assert comp.width == 640 + assert comp.height == 480 def test_yuv420p_inspection(self): fmt = VideoFormat("yuv420p", 640, 480) - self.assertEqual(fmt.name, "yuv420p") - self.assertEqual(len(fmt.components), 3) + assert fmt.name == "yuv420p" + assert len(fmt.components) == 3 self._test_yuv420(fmt) def _test_yuv420(self, fmt): self.assertTrue(fmt.is_planar) self.assertFalse(fmt.has_palette) self.assertFalse(fmt.is_rgb) - self.assertEqual(fmt.chroma_width(), 320) - self.assertEqual(fmt.chroma_height(), 240) - self.assertEqual(fmt.chroma_width(1024), 512) - self.assertEqual(fmt.chroma_height(1024), 512) + assert fmt.chroma_width() == 320 + assert fmt.chroma_height() == 240 + assert fmt.chroma_width(1024) == 512 + assert fmt.chroma_height(1024) == 512 for i, comp in enumerate(fmt.components): comp = fmt.components[i] - self.assertEqual(comp.plane, i) - self.assertEqual(comp.bits, 8) + assert comp.plane == i + assert comp.bits == 8 self.assertFalse(fmt.components[0].is_chroma) self.assertTrue(fmt.components[1].is_chroma) self.assertTrue(fmt.components[2].is_chroma) @@ -57,38 +57,38 @@ def _test_yuv420(self, fmt): self.assertFalse(fmt.components[0].is_alpha) self.assertFalse(fmt.components[1].is_alpha) self.assertFalse(fmt.components[2].is_alpha) - self.assertEqual(fmt.components[0].width, 640) - self.assertEqual(fmt.components[1].width, 320) - self.assertEqual(fmt.components[2].width, 320) + assert fmt.components[0].width == 640 + assert fmt.components[1].width == 320 + assert fmt.components[2].width == 320 def test_yuva420p_inspection(self): fmt = VideoFormat("yuva420p", 640, 480) - self.assertEqual(len(fmt.components), 4) + assert len(fmt.components) == 4 self._test_yuv420(fmt) self.assertFalse(fmt.components[3].is_chroma) - self.assertEqual(fmt.components[3].width, 640) + assert fmt.components[3].width == 640 def test_gray16be_inspection(self): fmt = VideoFormat("gray16be", 640, 480) - self.assertEqual(fmt.name, "gray16be") - self.assertEqual(len(fmt.components), 1) + assert fmt.name == "gray16be" + assert len(fmt.components) == 1 self.assertFalse(fmt.is_planar) self.assertFalse(fmt.has_palette) self.assertFalse(fmt.is_rgb) - self.assertEqual(fmt.chroma_width(), 640) - self.assertEqual(fmt.chroma_height(), 480) - self.assertEqual(fmt.chroma_width(1024), 1024) - self.assertEqual(fmt.chroma_height(1024), 1024) + assert fmt.chroma_width() == 640 + assert fmt.chroma_height() == 480 + assert fmt.chroma_width(1024) == 1024 + assert fmt.chroma_height(1024) == 1024 comp = fmt.components[0] - self.assertEqual(comp.plane, 0) - self.assertEqual(comp.bits, 16) + assert comp.plane == 0 + assert comp.bits == 16 self.assertTrue(comp.is_luma) self.assertFalse(comp.is_chroma) - self.assertEqual(comp.width, 640) - self.assertEqual(comp.height, 480) + assert comp.width == 640 + assert comp.height == 480 self.assertFalse(comp.is_alpha) def test_pal8_inspection(self): fmt = VideoFormat("pal8", 640, 480) - self.assertEqual(len(fmt.components), 1) + assert len(fmt.components) == 1 self.assertTrue(fmt.has_palette)