Method test_uuid7_monotonicity

Lib/test/test_uuid.py:943–1004

(self)

        self.assertSetEqual(versions, {7})

    def test_uuid7_monotonicity(self):
        equal = self.assertEqual

        us = [self.uuid.uuid7() for _ in range(10_000)]
        equal(us, sorted(us))

        with mock.patch.multiple(
            self.uuid,
            _last_timestamp_v7=0,
            _last_counter_v7=0,
        ):
            # 1 Jan 2023 12:34:56.123_456_789
            timestamp_ns = 1672533296_123_456_789  # ns precision
            timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)

            # counter_{hi,lo} are chosen so that "counter + 1" does not overflow
            counter_hi = random.getrandbits(11)
            counter_lo = random.getrandbits(29)
            counter = (counter_hi << 30) | counter_lo
            self.assertLess(counter + 1, 0x3ff_ffff_ffff)

            tail = random.getrandbits(32)
            random_bits = counter << 32 | tail
            random_data = random_bits.to_bytes(10)

            with (
                mock.patch('time.time_ns', return_value=timestamp_ns),
                mock.patch('os.urandom', return_value=random_data) as urand
            ):
                u1 = self.uuid.uuid7()
                urand.assert_called_once_with(10)
                equal(self.uuid._last_timestamp_v7, timestamp_ms)
                equal(self.uuid._last_counter_v7, counter)
                equal(u1.time, timestamp_ms)
                equal((u1.int >> 64) & 0xfff, counter_hi)
                equal((u1.int >> 32) & 0x3fff_ffff, counter_lo)
                equal(u1.int & 0xffff_ffff, tail)

            # 1 Jan 2023 12:34:56.123_457_032 (same millisecond but not same ns)
            next_timestamp_ns = 1672533296_123_457_032
            next_timestamp_ms, _ = divmod(timestamp_ns, 1_000_000)
            equal(timestamp_ms, next_timestamp_ms)

            next_tail_bytes = os.urandom(4)
            next_fail = int.from_bytes(next_tail_bytes)

            with (
                mock.patch('time.time_ns', return_value=next_timestamp_ns),
                mock.patch('os.urandom', return_value=next_tail_bytes) as urand
            ):
                u2 = self.uuid.uuid7()
                urand.assert_called_once_with(4)
                # same milli-second
                equal(self.uuid._last_timestamp_v7, timestamp_ms)
                # 42-bit counter advanced by 1
                equal(self.uuid._last_counter_v7, counter + 1)
                equal(u2.time, timestamp_ms)
                equal((u2.int >> 64) & 0xfff, counter_hi)