6 class LetterTransformerTest(unittest
.TestCase
):
9 lt
= LetterTransformer([('z', 'a')] + \
10 list(zip(string
.ascii_lowercase
, string
.ascii_lowercase
[1:])),
12 self
.assertEqual(lt
.forward_map
,
13 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
14 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0])
15 self
.assertEqual(lt
.backward_map
,
16 [25, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
17 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])
21 lt
= LetterTransformer(cat(collections
.OrderedDict
.fromkeys('zyxwc' + string
.ascii_lowercase
)))
22 self
.assertEqual(lt
.forward_map
,
23 [25, 24, 23, 22, 2, 0, 1, 3, 4, 5, 6, 7, 8, 9,
24 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21])
25 self
.assertEqual(lt
.backward_map
,
26 [5, 6, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
27 17, 18, 19, 20, 21, 22, 23, 24, 25, 3, 2, 1, 0])
29 def test_transform(self
):
30 lt
= LetterTransformer(cat(collections
.OrderedDict
.fromkeys('zyxwc' + string
.ascii_lowercase
)))
31 self
.assertEqual(cat(lt
.forward(l
) for l
in string
.ascii_lowercase
),
32 'zyxwcabdefghijklmnopqrstuv')
33 self
.assertEqual(cat(lt
.backward(l
) for l
in string
.ascii_lowercase
),
34 'fgehijklmnopqrstuvwxyzdcba')
37 class PlugboardTest(unittest
.TestCase
):
39 self
.pb
= Plugboard('ua pf rq so ni ey bg hl tx zj'.upper())
42 self
.assertEqual(self
.pb
.forward_map
,
43 [20, 6, 2, 3, 24, 15, 1, 11, 13, 25, 10, 7, 12,
44 8, 18, 5, 17, 16, 14, 23, 0, 21, 22, 19, 4, 9])
45 self
.assertEqual(self
.pb
.forward_map
, self
.pb
.backward_map
)
47 def test_transform(self
):
48 self
.assertEqual(cat(self
.pb
.forward(l
)
49 for l
in string
.ascii_lowercase
),
50 'ugcdypblnzkhmisfrqoxavwtej')
51 self
.assertEqual(cat(self
.pb
.backward(l
)
52 for l
in string
.ascii_lowercase
),
53 'ugcdypblnzkhmisfrqoxavwtej')
56 class ReflectorTest(unittest
.TestCase
):
58 self
.ref
= Reflector(reflector_b_spec
)
61 self
.assertEqual(self
.ref
.forward_map
,
62 [24, 17, 20, 7, 16, 18, 11, 3, 15, 23, 13, 6, 14,
63 10, 12, 8, 4, 1, 5, 25, 2, 22, 21, 9, 0, 19])
64 self
.assertEqual(self
.ref
.forward_map
, self
.ref
.backward_map
)
66 def test_transform(self
):
67 self
.assertEqual(cat(self
.ref
.forward(l
)
68 for l
in string
.ascii_lowercase
),
69 'yruhqsldpxngokmiebfzcwvjat')
70 self
.assertEqual(cat(self
.ref
.backward(l
)
71 for l
in string
.ascii_lowercase
),
72 'yruhqsldpxngokmiebfzcwvjat')
75 class SimpleWheelTest(unittest
.TestCase
):
77 rotor_1_transform
= list(zip(string
.ascii_lowercase
,
78 'EKMFLGDQVZNTOWYHXUSPAIBRCJ'.lower()))
79 wheel_1
= SimpleWheel(rotor_1_transform
, raw_transform
=True)
80 self
.assertEqual(cat(wheel_1
.forward(l
)
81 for l
in string
.ascii_lowercase
),
82 'ekmflgdqvzntowyhxuspaibrcj')
83 self
.assertEqual(cat(wheel_1
.backward(l
)
84 for l
in string
.ascii_lowercase
),
85 'uwygadfpvzbeckmthxslrinqoj')
88 wheel_2
= SimpleWheel(wheel_ii_spec
)
89 self
.assertEqual(cat(wheel_2
.forward(l
)
90 for l
in string
.ascii_lowercase
),
91 'ajdksiruxblhwtmcqgznpyfvoe')
92 self
.assertEqual(cat(wheel_2
.backward(l
)
93 for l
in string
.ascii_lowercase
),
94 'ajpczwrlfbdkotyuqgenhxmivs')
96 def test_advance(self
):
97 wheel_3
= SimpleWheel(wheel_iii_spec
)
98 wheel_3
.set_position('a')
100 self
.assertEqual(cat(wheel_3
.forward(l
)
101 for l
in string
.ascii_lowercase
),
102 'cegikboqswuymxdhvfzjltrpna')
103 self
.assertEqual(cat(wheel_3
.backward(l
)
104 for l
in string
.ascii_lowercase
),
105 'zfaobrcpdteumygxhwivkqjnls')
106 self
.assertEqual(wheel_3
.position
, 1)
107 self
.assertEqual(wheel_3
.position_l
, 'b')
109 for _
in range(24): wheel_3
.advance()
111 self
.assertEqual(wheel_3
.position
, 25)
112 self
.assertEqual(wheel_3
.position_l
, 'z')
114 self
.assertEqual(cat(wheel_3
.forward(l
)
115 for l
in string
.ascii_lowercase
),
116 'pcegikmdqsuywaozfjxhblnvtr')
117 self
.assertEqual(cat(wheel_3
.backward(l
)
118 for l
in string
.ascii_lowercase
),
119 'nubhcqdterfvgwoaizjykxmslp')
122 self
.assertEqual(wheel_3
.position
, 0)
123 self
.assertEqual(wheel_3
.position_l
, 'a')
126 self
.assertEqual(cat(wheel_3
.forward(l
)
127 for l
in string
.ascii_lowercase
),
128 'bdfhjlcprtxvznyeiwgakmusqo')
129 self
.assertEqual(cat(wheel_3
.backward(l
)
130 for l
in string
.ascii_lowercase
),
131 'tagbpcsdqeufvnzhyixjwlrkom')
134 class SimpleWheelTest(unittest
.TestCase
):
135 def test_init1(self
):
136 wheel
= Wheel(wheel_iii_spec
, wheel_iii_pegs
, position
='b',
138 self
.assertEqual(wheel
.position
, 1)
139 self
.assertEqual(wheel
.peg_positions
, [20])
140 self
.assertEqual(wheel
.position_l
, 'b')
143 self
.assertEqual(wheel
.position
, 2)
144 self
.assertEqual(wheel
.peg_positions
, [19])
145 self
.assertEqual(wheel
.position_l
, 'c')
147 def test_init2(self
):
148 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
150 self
.assertEqual(wheel
.position
, 25)
151 self
.assertIn(11, wheel
.peg_positions
)
152 self
.assertIn(24, wheel
.peg_positions
)
153 self
.assertEqual(wheel
.position_l
, 'b')
154 self
.assertEqual(cat(wheel
.forward(l
)
155 for l
in string
.ascii_lowercase
),
156 'xkqhwpvngzrcfoiaselbtymjdu')
157 self
.assertEqual(cat(wheel
.backward(l
)
158 for l
in string
.ascii_lowercase
),
159 'ptlyrmidoxbswhnfckquzgeavj')
162 def test_advance(self
):
163 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
167 self
.assertEqual(wheel
.position
, 0)
168 self
.assertIn(10, wheel
.peg_positions
)
169 self
.assertIn(23, wheel
.peg_positions
)
170 self
.assertEqual(wheel
.position_l
, 'c')
171 self
.assertEqual(cat(wheel
.forward(l
)
172 for l
in string
.ascii_lowercase
),
173 'jpgvoumfyqbenhzrdkasxlictw')
174 self
.assertEqual(cat(wheel
.backward(l
)
175 for l
in string
.ascii_lowercase
),
176 'skxqlhcnwarvgmebjptyfdzuio')
178 def test_advance_23(self
):
179 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
184 self
.assertEqual(wheel
.position
, 22)
185 self
.assertIn(1, wheel
.peg_positions
)
186 self
.assertIn(14, wheel
.peg_positions
)
187 self
.assertEqual(wheel
.position_l
, 'y')
188 self
.assertEqual(cat(wheel
.forward(l
)
189 for l
in string
.ascii_lowercase
),
190 'mgxantkzsyqjcufirldvhoewbp')
191 self
.assertEqual(cat(wheel
.backward(l
)
192 for l
in string
.ascii_lowercase
),
193 'dymswobuplgraevzkqifntxcjh')
195 def test_advance_24(self
):
196 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
201 self
.assertEqual(wheel
.position
, 23)
202 self
.assertIn(0, wheel
.peg_positions
)
203 self
.assertIn(13, wheel
.peg_positions
)
204 self
.assertEqual(wheel
.position_l
, 'z')
205 self
.assertEqual(cat(wheel
.forward(l
)
206 for l
in string
.ascii_lowercase
),
207 'fwzmsjyrxpibtehqkcugndvaol')
208 self
.assertEqual(cat(wheel
.backward(l
)
209 for l
in string
.ascii_lowercase
),
210 'xlrvnatokfqzduyjphemswbigc')
212 def test_advance_25(self
):
213 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
218 self
.assertEqual(wheel
.position
, 24)
219 self
.assertIn(25, wheel
.peg_positions
)
220 self
.assertIn(12, wheel
.peg_positions
)
221 self
.assertEqual(wheel
.position_l
, 'a')
222 self
.assertEqual(cat(wheel
.forward(l
)
223 for l
in string
.ascii_lowercase
),
224 'vylrixqwohasdgpjbtfmcuznke')
225 self
.assertEqual(cat(wheel
.backward(l
)
226 for l
in string
.ascii_lowercase
),
227 'kqumzsnjepyctxiogdlrvahfbw')
229 def test_advance_26(self
):
230 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
235 self
.assertEqual(wheel
.position
, 25)
236 self
.assertIn(24, wheel
.peg_positions
)
237 self
.assertIn(11, wheel
.peg_positions
)
238 self
.assertEqual(wheel
.position_l
, 'b')
239 self
.assertEqual(cat(wheel
.forward(l
)
240 for l
in string
.ascii_lowercase
),
241 'xkqhwpvngzrcfoiaselbtymjdu')
242 self
.assertEqual(cat(wheel
.backward(l
)
243 for l
in string
.ascii_lowercase
),
244 'ptlyrmidoxbswhnfckquzgeavj')
247 def test_advance_27(self
):
248 wheel
= Wheel(wheel_vi_spec
, wheel_vi_pegs
, position
='b',
253 self
.assertEqual(wheel
.position
, 0)
254 self
.assertIn(23, wheel
.peg_positions
)
255 self
.assertIn(10, wheel
.peg_positions
)
256 self
.assertEqual(wheel
.position_l
, 'c')
257 self
.assertEqual(cat(wheel
.forward(l
)
258 for l
in string
.ascii_lowercase
),
259 'jpgvoumfyqbenhzrdkasxlictw')
260 self
.assertEqual(cat(wheel
.backward(l
)
261 for l
in string
.ascii_lowercase
),
262 'skxqlhcnwarvgmebjptyfdzuio')
264 class EnigmaTest(unittest
.TestCase
):
267 self
.enigma
= Enigma(reflector_b_spec
,
268 wheel_i_spec
, wheel_i_pegs
,
269 wheel_ii_spec
, wheel_ii_pegs
,
270 wheel_iii_spec
, wheel_iii_pegs
,
274 # Setting sheet line 31 from http://www.codesandciphers.org.uk/enigma/enigma3.htm
275 # Enigma simulation settings are
276 # http://enigma.louisedade.co.uk/enigma.html?m3;b;b153;AFTX;AJEU;AU-BG-EY-FP-HL-IN-JZ-OS-QR-TX
277 self
.enigma31
= Enigma(reflector_b_spec
,
278 wheel_i_spec
, wheel_i_pegs
,
279 wheel_v_spec
, wheel_v_pegs
,
280 wheel_iii_spec
, wheel_iii_pegs
,
282 'ua pf rq so ni ey bg hl tx zj')
285 def test_middle_advance(self
):
286 self
.enigma
.set_wheels('a', 'a', 't')
287 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 0, 19))
288 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'aat')
289 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [4], [2]))
290 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
291 'puvioztjdhxmlyeawsrgbcqknf')
293 self
.enigma
.advance()
294 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 0, 20))
295 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'aau')
296 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [4], [1]))
297 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
298 'baigpldqcowfyzjehvtsxrkumn')
300 self
.enigma
.advance()
301 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 0, 21))
302 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'aav')
303 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [4], [0]))
304 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
305 'mnvfydiwgzsoablrxpkutchqej')
307 self
.enigma
.advance()
308 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 1, 22))
309 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'abw')
310 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [3], [25]))
311 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
312 'ulfopcykswhbzvderqixanjtgm')
314 self
.enigma
.advance()
315 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 1, 23))
316 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'abx')
317 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [3], [24]))
318 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
319 'qmwftdyovursbzhxaklejicpgn')
321 self
.enigma
.advance()
322 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 1, 24))
323 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'aby')
324 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [3], [23]))
325 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
326 'oljmzxrvucybdqasngpwihtfke')
329 def test_double_advance(self
):
330 self
.enigma
.set_wheels('a', 'd', 't')
331 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 3, 19))
332 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'adt')
333 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [1], [2]))
334 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
335 'zcbpqxwsjiuonmldethrkygfva')
337 self
.enigma
.advance()
338 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 3, 20))
339 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'adu')
340 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [1], [1]))
341 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
342 'ehprawjbngotxikcsdqlzyfmvu')
344 self
.enigma
.advance()
345 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 3, 21))
346 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'adv')
347 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [1], [0]))
348 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
349 'eqzxarpihmnvjkwgbfuyslodtc')
351 self
.enigma
.advance()
352 self
.assertEqual(self
.enigma
.wheel_positions
, (0, 4, 22))
353 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'aew')
354 self
.assertEqual(self
.enigma
.peg_positions
, ([16], [0], [25]))
355 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
356 'qedcbtpluzmhkongavwfirsyxj')
358 self
.enigma
.advance()
359 self
.assertEqual(self
.enigma
.wheel_positions
, (1, 5, 23))
360 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'bfx')
361 self
.assertEqual(self
.enigma
.peg_positions
, ([15], [25], [24]))
362 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
363 'iwuedhsfazqxytvrkpgncoblmj')
365 self
.enigma
.advance()
366 self
.assertEqual(self
.enigma
.wheel_positions
, (1, 5, 24))
367 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'bfy')
368 self
.assertEqual(self
.enigma
.peg_positions
, ([15], [25], [23]))
369 self
.assertEqual(cat(self
.enigma
.lookup(l
) for l
in string
.ascii_lowercase
),
370 'baknstqzrmcxjdvygiefwoulph')
373 def test_simple_encipher(self
):
374 self
.enigma
.set_wheels('a', 'a', 'a')
375 ct
= self
.enigma
.encipher('testmessage')
376 self
.assertEqual(ct
, 'olpfhnvflyn')
378 self
.enigma
.set_wheels('a', 'd', 't')
379 ct
= self
.enigma
.encipher('testmessage')
380 self
.assertEqual(ct
, 'lawnjgpwjik')
382 self
.enigma
.set_wheels('b', 'd', 'q')
383 ct
= self
.enigma
.encipher('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
385 'kvmmwrlqlqsqpeugjrcxzwpfyiyybwloewrouvkpoztceuwtfjzqwpbqldttsr')
386 self
.assertEqual(cat(self
.enigma
.wheel_positions_l
), 'cha')
389 def test_advance_with_ring_settings(self
):
390 self
.enigma31
.set_wheels('j', 'e', 'u')
392 self
.enigma31
.advance()
393 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 11, 24))
394 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jev')
395 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [21], [0]))
396 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
397 'mvqjlyowkdieasgzcunxrbhtfp')
399 self
.enigma31
.advance()
400 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 12, 25))
401 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jfw')
402 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [20], [25]))
403 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
404 'sjolzuyvrbwdpxcmtiaqfhknge')
406 self
.enigma31
.advance()
407 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 12, 0))
408 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jfx')
409 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [20], [24]))
410 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
411 'qrxedkoywufmlvgsabpzjnicht')
413 self
.enigma31
.advance()
414 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 12, 1))
415 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jfy')
416 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [20], [23]))
417 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
418 'hpsukliagqefwvtbjxcodnmrzy')
420 self
.enigma31
.advance()
421 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 12, 2))
422 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jfz')
423 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [20], [22]))
424 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
425 'zevnbpyqowrtxdifhkulscjmga')
428 def test_advance_with_ring_settings_2(self
):
429 self
.enigma31
.set_wheels('i', 'd', 'z')
431 self
.enigma31
.advance()
432 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 3))
433 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ida')
434 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [21]))
435 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
436 'ikhpqrvcambzjondefwyxgsutl')
438 self
.enigma31
.advance()
439 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 4))
440 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idb')
441 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [20]))
442 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
443 'cdabskhgzwfmlqvunyexpojtri')
445 self
.enigma31
.advance()
446 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 5))
447 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idc')
448 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [19]))
449 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
450 'pcbwiqhgemyvjsuaftnroldzkx')
452 self
.enigma31
.advance()
453 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 6))
454 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idd')
455 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [18]))
456 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
457 'xcbfvdnouptmlghjzwykierasq')
459 self
.enigma31
.advance()
460 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 7))
461 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ide')
462 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [17]))
463 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
464 'xfvglbdynuseriwqpmkzjcoaht')
466 self
.enigma31
.advance()
467 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 8))
468 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idf')
469 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [16]))
470 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
471 'tfpqlbouynsewjgcdxkahzmriv')
473 self
.enigma31
.advance()
474 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 9))
475 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idg')
476 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [15]))
477 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
478 'cjaunvlwtbygzexrspqidfhokm')
480 self
.enigma31
.advance()
481 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 10))
482 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idh')
483 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [14]))
484 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
485 'yltxkrqvowebzpingfucshjdam')
487 self
.enigma31
.advance()
488 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 11))
489 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idi')
490 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [13]))
491 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
492 'myktluzrnxceaiqsohpdfwvjbg')
494 self
.enigma31
.advance()
495 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 12))
496 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idj')
497 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [12]))
498 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
499 'pynjrmiugdqxfcvakewzhoslbt')
501 self
.enigma31
.advance()
502 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 13))
503 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idk')
504 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [11]))
505 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
506 'mwvedyplnoxhaijgrqtszcbkfu')
508 self
.enigma31
.advance()
509 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 14))
510 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idl')
511 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [10]))
512 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
513 'qcbrfeutvoxpnmjladzhgiykws')
515 self
.enigma31
.advance()
516 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 15))
517 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idm')
518 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [9]))
519 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
520 'dnoahryetsmukbcvwfjilpqzgx')
522 self
.enigma31
.advance()
523 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 16))
524 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idn')
525 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [8]))
526 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
527 'nidcfehgbqsovalyjzkxwmutpr')
529 self
.enigma31
.advance()
530 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 17))
531 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ido')
532 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [7]))
533 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
534 'joifxdulcarhzpbntkwqgysevm')
536 self
.enigma31
.advance()
537 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 18))
538 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idp')
539 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [6]))
540 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
541 'ptnlsxvozmwdjchayuebrgkfqi')
543 self
.enigma31
.advance()
544 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 19))
545 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idq')
546 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [5]))
547 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
548 'slwopzqnmxybihdeguavrtcjkf')
550 self
.enigma31
.advance()
551 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 20))
552 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idr')
553 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [4]))
554 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
555 'hcbedwlamzogixkytsrqvufnpj')
557 self
.enigma31
.advance()
558 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 21))
559 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ids')
560 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [3]))
561 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
562 'odxbjwzrmelkisavuhnyqpfctg')
564 self
.enigma31
.advance()
565 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 22))
566 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idt')
567 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [2]))
568 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
569 'udgbfeclrwnhxksvtioqapjmzy')
571 self
.enigma31
.advance()
572 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 23))
573 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idu')
574 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [1]))
575 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
576 'nrdczqxmowvshaiufblypkjgte')
578 self
.enigma31
.advance()
579 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 10, 24))
580 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'idv')
581 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [22], [0]))
582 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
583 'hkifjdoacebqtzgulyvmpsxwrn')
585 self
.enigma31
.advance()
586 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 11, 25))
587 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'iew')
588 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [21], [25]))
589 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
590 'yptzuhofqvnmlkgbixwcejsrad')
592 self
.enigma31
.advance()
593 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 11, 0))
594 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'iex')
595 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [21], [24]))
596 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
597 'vkdcwhqfjibzsptngumoraeyxl')
599 self
.enigma31
.advance()
600 self
.assertEqual(self
.enigma31
.wheel_positions
, (3, 11, 1))
601 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'iey')
602 self
.assertEqual(self
.enigma31
.peg_positions
, ([8], [21], [23]))
603 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
604 'wenpbqrouxlkychdfgzvitajms')
606 def test_double_advance_with_ring_settings_2(self
):
607 self
.enigma31
.set_wheels('a', 'y', 't')
608 self
.assertEqual(self
.enigma31
.wheel_positions
, (21, 5, 22))
609 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ayt')
610 self
.assertEqual(self
.enigma31
.peg_positions
, ([16], [1], [2]))
612 self
.enigma31
.advance()
613 self
.assertEqual(self
.enigma31
.wheel_positions
, (21, 5, 23))
614 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ayu')
615 self
.assertEqual(self
.enigma31
.peg_positions
, ([16], [1], [1]))
617 self
.enigma31
.advance()
618 self
.assertEqual(self
.enigma31
.wheel_positions
, (21, 5, 24))
619 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'ayv')
620 self
.assertEqual(self
.enigma31
.peg_positions
, ([16], [1], [0]))
622 self
.enigma31
.advance()
623 self
.assertEqual(self
.enigma31
.wheel_positions
, (21, 6, 25))
624 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'azw')
625 self
.assertEqual(self
.enigma31
.peg_positions
, ([16], [0], [25]))
627 self
.enigma31
.advance()
628 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 7, 0))
629 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bax')
630 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [25], [24]))
632 self
.enigma31
.advance()
633 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 7, 1))
634 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bay')
635 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [25], [23]))
637 self
.enigma31
.set_wheels('a', 'z', 't')
638 self
.assertEqual(self
.enigma31
.wheel_positions
, (21, 6, 22))
639 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'azt')
640 self
.assertEqual(self
.enigma31
.peg_positions
, ([16], [0], [2]))
642 self
.enigma31
.advance()
643 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 7, 23))
644 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bau')
645 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [25], [1]))
647 self
.enigma31
.advance()
648 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 7, 24))
649 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bav')
650 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [25], [0]))
652 self
.enigma31
.advance()
653 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 8, 25))
654 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bbw')
655 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [24], [25]))
657 self
.enigma31
.advance()
658 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 8, 0))
659 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bbx')
660 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [24], [24]))
662 self
.enigma31
.advance()
663 self
.assertEqual(self
.enigma31
.wheel_positions
, (22, 8, 1))
664 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'bby')
665 self
.assertEqual(self
.enigma31
.peg_positions
, ([15], [24], [23]))
668 def test_encipher_with_ring(self
):
670 self
.enigma31
.set_wheels('i', 'z', 'd')
671 ct
= self
.enigma31
.encipher('verylongtestmessagewithanextrabitofmessageforgoodmeasure')
673 'apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')
674 self
.assertEqual(self
.enigma31
.wheel_positions
, (4, 9, 10))
675 self
.assertEqual(cat(self
.enigma31
.wheel_positions_l
), 'jch')
676 self
.assertEqual(self
.enigma31
.peg_positions
, ([7], [23], [14]))
677 self
.assertEqual(cat(self
.enigma31
.lookup(l
) for l
in string
.ascii_lowercase
),
678 'mopnigfuesqwadbcktjrhylzvx')
680 self
.enigma31
.set_wheels('i', 'z', 'd')
681 pt
= self
.enigma31
.decipher('apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')
683 'verylongtestmessagewithanextrabitofmessageforgoodmeasure')
685 if __name__
== '__main__':