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)     @pytest.mark.parametrize(
16)         ['sequence', 'base', 'expected'],
17)         [
18)             ([1, 2, 3, 4, 5, 6], 10, 123456),
19)             ([1, 2, 3, 4, 5, 6], 100, 10203040506),
20)             ([0, 0, 1, 4, 9, 7], 10, 1497),
21)             ([1, 0, 0, 1, 0, 0, 0, 0], 2, 144),
22)             ([1, 7, 5, 5], 8, 0o1755),
23)         ],
24)     )

25)     def test_200_big_endian_number(self, sequence, base, expected):
26)         assert (
27)             sequin.Sequin._big_endian_number(sequence, base=base)
28)         ) == expected

29) 

30)     @pytest.mark.parametrize(

31)         ['exc_type', 'exc_pattern', 'sequence', 'base'],
32)         [

33)             (ValueError, 'invalid base 3 digit:', [-1], 3),
34)             (ValueError, 'invalid base:', [0], 1),
35)             (TypeError, 'not an integer:', [0.0, 1.0, 0.0, 1.0], 2),

36)         ],

37)     )

38)     def test_300_big_endian_number_exceptions(
39)         self, exc_type, exc_pattern, sequence, base
40)     ):

41)         with pytest.raises(exc_type, match=exc_pattern):
42)             sequin.Sequin._big_endian_number(sequence, base=base)

43) 
44) 

45) class TestSequin:
46)     @pytest.mark.parametrize(
47)         ['sequence', 'is_bitstring', 'expected'],
48)         [
49)             (
50)                 [1, 0, 0, 1, 0, 1],
51)                 False,
52)                 [
53)                     0,
54)                     0,
55)                     0,
56)                     0,
57)                     0,
58)                     0,
59)                     0,
60)                     1,
61)                     0,
62)                     0,
63)                     0,
64)                     0,
65)                     0,
66)                     0,
67)                     0,
68)                     0,
69)                     0,
70)                     0,
71)                     0,
72)                     0,
73)                     0,
74)                     0,
75)                     0,
76)                     0,
77)                     0,
78)                     0,
79)                     0,
80)                     0,
81)                     0,
82)                     0,
83)                     0,
84)                     1,
85)                     0,
86)                     0,
87)                     0,
88)                     0,
89)                     0,
90)                     0,
91)                     0,
92)                     0,
93)                     0,
94)                     0,
95)                     0,
96)                     0,
97)                     0,
98)                     0,
99)                     0,
100)                     1,
101)                 ],
102)             ),
103)             ([1, 0, 0, 1, 0, 1], True, [1, 0, 0, 1, 0, 1]),
104)             (b'OK', False, [0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1]),
105)             ('OK', False, [0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1]),
106)         ],
107)     )

108)     def test_200_constructor(self, sequence, is_bitstring, expected):
109)         seq = sequin.Sequin(sequence, is_bitstring=is_bitstring)
110)         assert seq.bases == {2: collections.deque(expected)}

111) 

112)     def test_201_generating(self):

113)         seq = sequin.Sequin(
114)             [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], is_bitstring=True
115)         )

116)         assert seq.generate(1) == 0
117)         assert seq.generate(5) == 3
118)         assert seq.generate(5) == 3
119)         assert seq.generate(5) == 1

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

121)             seq.generate(5)

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

123)             seq.generate(1)

124)         seq = sequin.Sequin(
125)             [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], is_bitstring=True
126)         )

127)         with pytest.raises(ValueError, match='invalid target range'):
128)             seq.generate(0)

129) 

130)     def test_210_internal_generating(self):

131)         seq = sequin.Sequin(
132)             [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], is_bitstring=True
133)         )

134)         assert seq._generate_inner(5) == 3
135)         assert seq._generate_inner(5) == 3
136)         assert seq._generate_inner(5) == 1
137)         assert seq._generate_inner(5) == 5
138)         assert seq._generate_inner(1) == 0

139)         seq = sequin.Sequin(
140)             [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], is_bitstring=True
141)         )

142)         assert seq._generate_inner(1) == 0
143)         with pytest.raises(ValueError, match='invalid target range'):
144)             seq._generate_inner(0)
145)         with pytest.raises(ValueError, match='invalid base:'):
146)             seq._generate_inner(16, base=1)

147) 

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

150)         assert seq.bases == {
151)             2: collections.deque([1, 0, 1, 0, 0, 1, 0, 0, 0, 1])
152)         }

153) 

154)         assert seq._all_or_nothing_shift(3) == (1, 0, 1)
155)         assert seq._all_or_nothing_shift(3) == (0, 0, 1)
156)         assert seq.bases[2] == collections.deque([0, 0, 0, 1])

157) 

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

160) 

161)         assert seq._all_or_nothing_shift(4), (0, 0, 0, 1)
162)         assert 2 not in seq.bases

163) 

164)     @pytest.mark.parametrize(
165)         ['sequence', 'is_bitstring', 'exc_type', 'exc_pattern'],
166)         [

167)             (
168)                 [0, 1, 2, 3, 4, 5, 6, 7],
169)                 True,
170)                 ValueError,
171)                 'sequence item out of range',
172)             ),
173)             ('こんにちは。', False, ValueError, 'sequence item out of range'),
174)         ],

175)     )

176)     def test_300_constructor_exceptions(
177)         self, sequence, is_bitstring, exc_type, exc_pattern
178)     ):