Skip the mode-mix regression tests on the pure Python fallback

The fallback rolls its buffer position back to the last checkpoint on
every OutOfData, so an incomplete read never leaves behind a stack
frame the way the C extension does. Resuming with the other method
just reparses the header from scratch and works fine there, so the
ValueError the C extension raises for that mix isn't something the
fallback needs to reproduce. Marked the two mix tests C-extension-only
with the project's existing Packer.__module__ skipif convention, and
added the fallback's own pair of tests confirming the mix still
succeeds instead of silently going untested on that backend.

Author: afonsojanu

test/test_sequnpack.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 import io
 
+import pytest
 from pytest import raises
 
 from msgpack import BufferFull, Unpacker, pack, packb
@@ -63,6 +64,10 @@ def test_foobar_skip():
         unpacker.unpack()
 
 
+@pytest.mark.skipif(
+    Unpacker.__module__ == "msgpack.fallback",
+    reason="only the C extension keeps a stack frame across an incomplete read",
+)
 def test_skip_then_unpack_across_incomplete_container():
     # skip() opens the array's stack frame without ever populating its
     # object slot (it has nothing to build), so resuming with unpack()
@@ -77,6 +82,10 @@ def test_skip_then_unpack_across_incomplete_container():
         unpacker.unpack()
 
 
+@pytest.mark.skipif(
+    Unpacker.__module__ == "msgpack.fallback",
+    reason="only the C extension keeps a stack frame across an incomplete read",
+)
 def test_unpack_then_skip_across_incomplete_container():
     unpacker = Unpacker()
     unpacker.feed(b"\x91")
@@ -105,6 +114,37 @@ def test_unpack_then_unpack_across_incomplete_container_still_works():
     assert unpacker.unpack() == [0]
 
 
+@pytest.mark.skipif(
+    Unpacker.__module__ != "msgpack.fallback",
+    reason="the C extension is the one that needs to reject this mix, see the tests above",
+)
+def test_fallback_skip_then_unpack_across_incomplete_container_still_works():
+    # The fallback never keeps a stack frame across an OutOfData; an
+    # incomplete read rolls the buffer position back to where the call
+    # started, so the next call just reparses the array header from
+    # scratch regardless of which method it uses. No corruption risk here,
+    # so unlike the C extension it doesn't need to reject the mix.
+    unpacker = Unpacker()
+    unpacker.feed(b"\x91")
+    with raises(OutOfData):
+        unpacker.skip()
+    unpacker.feed(b"\x00")
+    assert unpacker.unpack() == [0]
+
+
+@pytest.mark.skipif(
+    Unpacker.__module__ != "msgpack.fallback",
+    reason="the C extension is the one that needs to reject this mix, see the tests above",
+)
+def test_fallback_unpack_then_skip_across_incomplete_container_still_works():
+    unpacker = Unpacker()
+    unpacker.feed(b"\x91")
+    with raises(OutOfData):
+        unpacker.unpack()
+    unpacker.feed(b"\x00")
+    assert unpacker.skip() is None
+
+
 def test_maxbuffersize():
     with raises(ValueError):
         Unpacker(read_size=5, max_buffer_size=3)