DER 2pass encoding

[pyderasn.git] / tests / test_pyderasn.py

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 9fae13ea1eae16653d587bea0d038d472b6ba719..46e10e53abdbb12848d8be51d21d58f43ff0a11b 100644 (file)
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -20,6 +20,7 @@ from copy import deepcopy
 from datetime import datetime
 from datetime import timedelta
 from importlib import import_module
 from datetime import datetime
 from datetime import timedelta
 from importlib import import_module

+from io import BytesIO

 from operator import attrgetter
 from os import environ
 from os import urandom
 from operator import attrgetter
 from os import environ
 from os import urandom


@@ -75,6 +76,7 @@ from pyderasn import BoundsError
 from pyderasn import Choice
 from pyderasn import DecodeError
 from pyderasn import DecodePathDefBy
 from pyderasn import Choice
 from pyderasn import DecodeError
 from pyderasn import DecodePathDefBy

+from pyderasn import encode2pass

 from pyderasn import encode_cer
 from pyderasn import Enumerated
 from pyderasn import EOC
 from pyderasn import encode_cer
 from pyderasn import Enumerated
 from pyderasn import EOC


@@ -422,6 +424,8 @@ class TestBoolean(CommonMixin, TestCase):
         pprint(obj, big_blobs=True, with_decode_path=True)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         repr(err.exception)
         obj = Boolean(value)
         self.assertTrue(obj.ready)
         repr(err.exception)
         obj = Boolean(value)
         self.assertTrue(obj.ready)


@@ -506,6 +510,8 @@ class TestBoolean(CommonMixin, TestCase):
         obj = Boolean(value, impl=tag_impl)
         with self.assertRaises(NotEnoughData):
             obj.decode(obj.encode()[:-1])
         obj = Boolean(value, impl=tag_impl)
         with self.assertRaises(NotEnoughData):
             obj.decode(obj.encode()[:-1])

+        with self.assertRaises(NotEnoughData):
+            obj.decode(encode2pass(obj)[:-1])

 
     @given(
         booleans(),
 
     @given(
         booleans(),


@@ -515,6 +521,8 @@ class TestBoolean(CommonMixin, TestCase):
         obj = Boolean(value, expl=tag_expl)
         with self.assertRaises(NotEnoughData):
             obj.decode(obj.encode()[:-1])
         obj = Boolean(value, expl=tag_expl)
         with self.assertRaises(NotEnoughData):
             obj.decode(obj.encode()[:-1])

+        with self.assertRaises(NotEnoughData):
+            obj.decode(encode2pass(obj)[:-1])

 
     @given(
         integers(min_value=31),
 
     @given(
         integers(min_value=31),


@@ -603,6 +611,7 @@ class TestBoolean(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -863,6 +872,8 @@ class TestInteger(CommonMixin, TestCase):
         pprint(obj, big_blobs=True, with_decode_path=True)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         repr(err.exception)
         obj = Integer(value)
         self.assertTrue(obj.ready)
         repr(err.exception)
         obj = Integer(value)
         self.assertTrue(obj.ready)


@@ -925,6 +936,10 @@ class TestInteger(CommonMixin, TestCase):
                 Integer(values[0]).encode()
             )
         repr(err.exception)
                 Integer(values[0]).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[1], values[2])).decode(
+                encode2pass(Integer(values[0]))
+            )

         with self.assertRaises(BoundsError) as err:
             Integer(value=values[2], bounds=(values[0], values[1]))
         repr(err.exception)
         with self.assertRaises(BoundsError) as err:
             Integer(value=values[2], bounds=(values[0], values[1]))
         repr(err.exception)


@@ -933,6 +948,10 @@ class TestInteger(CommonMixin, TestCase):
                 Integer(values[2]).encode()
             )
         repr(err.exception)
                 Integer(values[2]).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[0], values[1])).decode(
+                encode2pass(Integer(values[2]))
+            )

 
     @given(data_strategy())
     def test_call(self, d):
 
     @given(data_strategy())
     def test_call(self, d):


@@ -1124,6 +1143,7 @@ class TestInteger(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -1362,6 +1382,8 @@ class TestBitString(CommonMixin, TestCase):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         obj = BitString(value)
         self.assertTrue(obj.ready)
         repr(obj)
         obj = BitString(value)
         self.assertTrue(obj.ready)
         repr(obj)


@@ -1540,6 +1562,7 @@ class TestBitString(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -1965,6 +1988,8 @@ class TestOctetString(CommonMixin, TestCase):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         obj = OctetString(value)
         self.assertTrue(obj.ready)
         repr(obj)
         obj = OctetString(value)
         self.assertTrue(obj.ready)
         repr(obj)


@@ -2011,6 +2036,10 @@ class TestOctetString(CommonMixin, TestCase):
                 OctetString(value).encode()
             )
         repr(err.exception)
                 OctetString(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                encode2pass(OctetString(value))
+            )

         value = d.draw(binary(min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))
         value = d.draw(binary(min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))


@@ -2020,6 +2049,10 @@ class TestOctetString(CommonMixin, TestCase):
                 OctetString(value).encode()
             )
         repr(err.exception)
                 OctetString(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                encode2pass(OctetString(value))
+            )

 
     @given(data_strategy())
     def test_call(self, d):
 
     @given(data_strategy())
     def test_call(self, d):


@@ -2196,6 +2229,7 @@ class TestOctetString(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -2566,6 +2600,7 @@ class TestNull(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -2695,6 +2730,8 @@ class TestObjectIdentifier(CommonMixin, TestCase):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         obj = ObjectIdentifier(value)
         self.assertTrue(obj.ready)
         self.assertFalse(obj.ber_encoded)
         obj = ObjectIdentifier(value)
         self.assertTrue(obj.ready)
         self.assertFalse(obj.ber_encoded)


@@ -2932,6 +2969,7 @@ class TestObjectIdentifier(CommonMixin, TestCase):
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()
             pprint(obj, big_blobs=True, with_decode_path=True)
             self.assertFalse(obj.expled)
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             self.assertSequenceEqual(encode_cer(obj), obj_encoded)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)


@@ -3327,6 +3365,7 @@ class TestEnumerated(CommonMixin, TestCase):
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()

+        self.assertEqual(encode2pass(obj), obj_encoded)

         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         repr(obj_expled)
         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         repr(obj_expled)


@@ -3444,6 +3483,8 @@ class StringMixin(object):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         value = d.draw(text(alphabet=self.text_alphabet()))
         obj = self.base_klass(value)
         self.assertTrue(obj.ready)
         value = d.draw(text(alphabet=self.text_alphabet()))
         obj = self.base_klass(value)
         self.assertTrue(obj.ready)


@@ -3493,6 +3534,10 @@ class StringMixin(object):
                 self.base_klass(value).encode()
             )
         repr(err.exception)
                 self.base_klass(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                encode2pass(self.base_klass(value))
+            )

         value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))
         value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))


@@ -3502,6 +3547,10 @@ class StringMixin(object):
                 self.base_klass(value).encode()
             )
         repr(err.exception)
                 self.base_klass(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                encode2pass(self.base_klass(value))
+            )

 
     @given(data_strategy())
     def test_call(self, d):
 
     @given(data_strategy())
     def test_call(self, d):


@@ -3677,6 +3726,7 @@ class StringMixin(object):
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()

+        self.assertEqual(encode2pass(obj), obj_encoded)

         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         repr(obj_expled)
         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         repr(obj_expled)


@@ -4033,6 +4083,8 @@ class TimeMixin(object):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         value = d.draw(datetimes(
             min_value=self.min_datetime,
             max_value=self.max_datetime,
         value = d.draw(datetimes(
             min_value=self.min_datetime,
             max_value=self.max_datetime,


@@ -4191,6 +4243,7 @@ class TimeMixin(object):
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()

+        self.assertEqual(encode2pass(obj), obj_encoded)

         self.additional_symmetric_check(value, obj_encoded)
         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         self.additional_symmetric_check(value, obj_encoded)
         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)


@@ -5000,6 +5053,8 @@ class TestAny(CommonMixin, TestCase):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         obj = Any(value)
         self.assertTrue(obj.ready)
         repr(obj)
         obj = Any(value)
         self.assertTrue(obj.ready)
         repr(obj)


@@ -5148,6 +5203,7 @@ class TestAny(CommonMixin, TestCase):
             tag_class, _, tag_num = tag_decode(tag_strip(value)[0])
             self.assertEqual(obj.tag_order, (tag_class, tag_num))
             obj_encoded = obj.encode()
             tag_class, _, tag_num = tag_decode(tag_strip(value)[0])
             self.assertEqual(obj.tag_order, (tag_class, tag_num))
             obj_encoded = obj.encode()

+            self.assertEqual(encode2pass(obj), obj_encoded)

             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             tag_class, _, tag_num = tag_decode(tag_expl)
             obj_expled = obj(value, expl=tag_expl)
             self.assertTrue(obj_expled.expled)
             tag_class, _, tag_num = tag_decode(tag_expl)


@@ -5384,6 +5440,8 @@ class TestChoice(CommonMixin, TestCase):
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             obj.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(obj)

         obj["whatever"] = Boolean()
         self.assertFalse(obj.ready)
         repr(obj)
         obj["whatever"] = Boolean()
         self.assertFalse(obj.ready)
         repr(obj)


@@ -5532,6 +5590,7 @@ class TestChoice(CommonMixin, TestCase):
         self.assertFalse(obj.expled)
         self.assertEqual(obj.tag_order, obj.value.tag_order)
         obj_encoded = obj.encode()
         self.assertFalse(obj.expled)
         self.assertEqual(obj.tag_order, obj.value.tag_order)
         obj_encoded = obj.encode()

+        self.assertEqual(encode2pass(obj), obj_encoded)

         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         tag_class, _, tag_num = tag_decode(tag_expl)
         obj_expled = obj(value, expl=tag_expl)
         self.assertTrue(obj_expled.expled)
         tag_class, _, tag_num = tag_decode(tag_expl)


@@ -5879,6 +5938,8 @@ class SeqMixing(object):
         with self.assertRaises(ObjNotReady) as err:
             seq.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             seq.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(seq)

         for name, value in non_ready.items():
             seq[name] = Boolean(value)
         self.assertTrue(seq.ready)
         for name, value in non_ready.items():
             seq[name] = Boolean(value)
         self.assertTrue(seq.ready)


@@ -6067,6 +6128,7 @@ class SeqMixing(object):
         pprint(seq, big_blobs=True, with_decode_path=True)
         self.assertTrue(seq.ready)
         seq_encoded = seq.encode()
         pprint(seq, big_blobs=True, with_decode_path=True)
         self.assertTrue(seq.ready)
         seq_encoded = seq.encode()

+        self.assertEqual(encode2pass(seq), seq_encoded)

         seq_encoded_cer = encode_cer(seq)
         self.assertNotEqual(seq_encoded_cer, seq_encoded)
         self.assertSequenceEqual(
         seq_encoded_cer = encode_cer(seq)
         self.assertNotEqual(seq_encoded_cer, seq_encoded)
         self.assertSequenceEqual(


@@ -6155,6 +6217,7 @@ class SeqMixing(object):
         seq, expect_outers = d.draw(sequences_strategy(seq_klass=self.base_klass))
         self.assertTrue(seq.ready)
         seq_encoded = seq.encode()
         seq, expect_outers = d.draw(sequences_strategy(seq_klass=self.base_klass))
         self.assertTrue(seq.ready)
         seq_encoded = seq.encode()

+        self.assertEqual(encode2pass(seq), seq_encoded)

         seq_decoded, tail = seq.decode(seq_encoded)
         self.assertEqual(tail, b"")
         self.assertTrue(seq.ready)
         seq_decoded, tail = seq.decode(seq_encoded)
         self.assertEqual(tail, b"")
         self.assertTrue(seq.ready)


@@ -6527,6 +6590,8 @@ class SeqOfMixing(object):
         with self.assertRaises(ObjNotReady) as err:
             seqof.encode()
         repr(err.exception)
         with self.assertRaises(ObjNotReady) as err:
             seqof.encode()
         repr(err.exception)

+        with self.assertRaises(ObjNotReady) as err:
+            encode2pass(seqof)

         for i, value in enumerate(values):
             self.assertEqual(seqof[i], value)
             if not seqof[i].ready:
         for i, value in enumerate(values):
             self.assertEqual(seqof[i], value)
             if not seqof[i].ready:


@@ -6570,6 +6635,10 @@ class SeqOfMixing(object):
                 SeqOf(value).encode()
             )
         repr(err.exception)
                 SeqOf(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                encode2pass(SeqOf(value))
+            )

         value = [Boolean(True)] * d.draw(integers(
             min_value=bound_max + 1,
             max_value=bound_max + 10,
         value = [Boolean(True)] * d.draw(integers(
             min_value=bound_max + 1,
             max_value=bound_max + 10,


@@ -6582,6 +6651,10 @@ class SeqOfMixing(object):
                 SeqOf(value).encode()
             )
         repr(err.exception)
                 SeqOf(value).encode()
             )
         repr(err.exception)

+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                encode2pass(SeqOf(value))
+            )

 
     @given(integers(min_value=1, max_value=10))
     def test_out_of_bounds(self, bound_max):
 
     @given(integers(min_value=1, max_value=10))
     def test_out_of_bounds(self, bound_max):


@@ -6788,6 +6861,7 @@ class SeqOfMixing(object):
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()
         pprint(obj, big_blobs=True, with_decode_path=True)
         self.assertFalse(obj.expled)
         obj_encoded = obj.encode()

+        self.assertEqual(encode2pass(obj), obj_encoded)

         obj_encoded_cer = encode_cer(obj)
         self.assertNotEqual(obj_encoded_cer, obj_encoded)
         self.assertSequenceEqual(
         obj_encoded_cer = encode_cer(obj)
         self.assertNotEqual(obj_encoded_cer, obj_encoded)
         self.assertSequenceEqual(


@@ -6973,6 +7047,26 @@ class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
         register_class(SeqOf)
         pickle_dumps(seqof)
 
         register_class(SeqOf)
         pickle_dumps(seqof)
 

+    def test_iterator_2pass(self):
+        class SeqOf(SequenceOf):
+            schema = Integer()
+            bounds = (1, float("+inf"))
+        def gen():
+            for i in six_xrange(10):
+                yield Integer(i)
+        seqof = SeqOf(gen())
+        self.assertTrue(seqof.ready)
+        _, state = seqof.encode1st()
+        self.assertFalse(seqof.ready)
+        seqof = seqof(gen())
+        self.assertTrue(seqof.ready)
+        buf = BytesIO()
+        seqof.encode2nd(buf.write, iter(state))
+        self.assertSequenceEqual(
+            [int(i) for i in seqof.decod(buf.getvalue())],
+            list(gen()),
+        )
+

     def test_non_ready_bound_min(self):
         class SeqOf(SequenceOf):
             schema = Integer()
     def test_non_ready_bound_min(self):
         class SeqOf(SequenceOf):
             schema = Integer()