derivepassphrase.git

1) # SPDX-FileCopyrightText: 2024 Marco Ricci <m@the13thletter.info>
2) #
3) # SPDX-License-Identifier: MIT
4) 
5) """Test sequin.Sequin."""
6) 

7) import collections

8) 

9) import pytest

10) 

11) import sequin
12) 

13) 

14) class TestStaticFunctionality:

15) 

16)     @pytest.mark.parametrize(['sequence', 'base', 'expected'], [
17)         ([1, 2, 3, 4, 5, 6], 10, 123456),
18)         ([1, 2, 3, 4, 5, 6], 100, 10203040506),
19)         ([0, 0, 1, 4, 9, 7], 10, 1497),
20)         ([1, 0, 0, 1, 0, 0, 0, 0], 2, 144),
21)         ([1, 7, 5, 5], 8, 0o1755),
22)     ])
23)     def test_200_big_endian_number(self, sequence, base, expected):
24)         assert (
25)             sequin.Sequin._big_endian_number(sequence, base=base)
26)         ) == expected

27) 

28)     @pytest.mark.parametrize(

29)         ['exc_type', 'exc_pattern', 'sequence', 'base'], [

30)             (ValueError, 'invalid base 3 digit:', [-1], 3),
31)             (ValueError, 'invalid base:', [0], 1),
32)             (TypeError, 'not an integer:', [0.0, 1.0, 0.0, 1.0], 2),
33)         ]
34)     )
35)     def test_300_big_endian_number_exceptions(self, exc_type, exc_pattern,
36)                                               sequence, base):
37)         with pytest.raises(exc_type, match=exc_pattern):
38)             sequin.Sequin._big_endian_number(sequence, base=base)

39) 

40) class TestSequin:

41) 

42)     @pytest.mark.parametrize(['sequence', 'is_bitstring', 'expected'], [
43)         ([1, 0, 0, 1, 0, 1], False, [0, 0, 0, 0, 0, 0, 0, 1,
44)                                      0, 0, 0, 0, 0, 0, 0, 0,
45)                                      0, 0, 0, 0, 0, 0, 0, 0,
46)                                      0, 0, 0, 0, 0, 0, 0, 1,
47)                                      0, 0, 0, 0, 0, 0, 0, 0,
48)                                      0, 0, 0, 0, 0, 0, 0, 1]),
49)         ([1, 0, 0, 1, 0, 1], True, [1, 0, 0, 1, 0, 1]),
50)         (b'OK', False, [0, 1, 0, 0, 1, 1, 1, 1,
51)                         0, 1, 0, 0, 1, 0, 1, 1]),
52)         ('OK', False, [0, 1, 0, 0, 1, 1, 1, 1,
53)                        0, 1, 0, 0, 1, 0, 1, 1]),
54)     ])
55)     def test_200_constructor(self, sequence, is_bitstring, expected):
56)         seq = sequin.Sequin(sequence, is_bitstring=is_bitstring)
57)         assert seq.bases == {2: collections.deque(expected)}

58) 

59)     def test_201_generating(self):
60)         seq = sequin.Sequin([1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1],
61)                             is_bitstring=True)
62)         assert seq.generate(1) == 0
63)         assert seq.generate(5) == 3
64)         assert seq.generate(5) == 3
65)         assert seq.generate(5) == 1

66)         with pytest.raises(sequin.SequinExhaustedError):

67)             seq.generate(5)

68)         with pytest.raises(sequin.SequinExhaustedError):

69)             seq.generate(1)
70)         seq = sequin.Sequin([1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1],
71)                             is_bitstring=True)
72)         with pytest.raises(ValueError, match='invalid target range'):
73)             seq.generate(0)

74) 

75)     def test_210_internal_generating(self):
76)         seq = sequin.Sequin([1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1],
77)                             is_bitstring=True)
78)         assert seq._generate_inner(5) == 3
79)         assert seq._generate_inner(5) == 3
80)         assert seq._generate_inner(5) == 1
81)         assert seq._generate_inner(5) == 5
82)         assert seq._generate_inner(1) == 0
83)         seq = sequin.Sequin([1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1],
84)                             is_bitstring=True)
85)         assert seq._generate_inner(1) == 0
86)         with pytest.raises(ValueError, match='invalid target range'):
87)             seq._generate_inner(0)
88)         with pytest.raises(ValueError, match='invalid base:'):
89)             seq._generate_inner(16, base=1)

90) 

91)     def test_211_shifting(self):
92)         seq = sequin.Sequin([1, 0, 1, 0, 0, 1, 0, 0, 0, 1], is_bitstring=True)

93)         assert seq.bases == {2: collections.deque([
94)             1, 0, 1, 0, 0, 1, 0, 0, 0, 1])}

95) 

96)         assert seq._all_or_nothing_shift(3) == (1, 0, 1)
97)         assert seq._all_or_nothing_shift(3) == (0, 0, 1)
98)         assert seq.bases[2] == collections.deque([0, 0, 0, 1])

99) 

100)         assert seq._all_or_nothing_shift(5) == ()
101)         assert seq.bases[2] == collections.deque([0, 0, 0, 1])

102) 

103)         assert seq._all_or_nothing_shift(4), (0, 0, 0, 1)
104)         assert 2 not in seq.bases

105) 

106)     @pytest.mark.parametrize(
107)         ['sequence', 'is_bitstring', 'exc_type', 'exc_pattern'],
108)         [
109)             ([0, 1, 2, 3, 4, 5, 6, 7], True,
110)              ValueError, 'sequence item out of range'),

111)             ('こんにちは。', False,