Cleaner way of dealing with punctuation in C1b
[cipher-training.git] / test_enigma.py
1 import unittest
2 import collections
3
4 from enigma import *
5
6 class LetterTransformerTest(unittest.TestCase):
7
8 def test_maps1(self):
9 lt = LetterTransformer([('z', 'a')] + \
10 list(zip(string.ascii_lowercase, string.ascii_lowercase[1:])),
11 raw_transform = True)
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])
18
19
20 def test_maps2(self):
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])
28
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')
35
36
37 class PlugboardTest(unittest.TestCase):
38 def setUp(self):
39 self.pb = Plugboard('ua pf rq so ni ey bg hl tx zj'.upper())
40
41 def test_maps(self):
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)
46
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')
54
55
56 class ReflectorTest(unittest.TestCase):
57 def setUp(self):
58 self.ref = Reflector(reflector_b_spec)
59
60 def test_maps(self):
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)
65
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')
73
74
75 class SimpleWheelTest(unittest.TestCase):
76 def test_init1(self):
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')
86
87 def test_init2(self):
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')
95
96 def test_set_position(self):
97 wheel_3 = SimpleWheel(wheel_iii_spec)
98 wheel_3.set_position('a')
99 self.assertEqual(wheel_3.position, 0)
100 self.assertEqual(wheel_3.position_l, 'a')
101
102 wheel_3.set_position('f')
103 self.assertEqual(wheel_3.position, 5)
104 self.assertEqual(wheel_3.position_l, 'f')
105
106 wheel_3.advance()
107 self.assertEqual(wheel_3.position, 6)
108 self.assertEqual(wheel_3.position_l, 'g')
109
110 wheel_3.set_position(12)
111 self.assertEqual(wheel_3.position, 12)
112 self.assertEqual(wheel_3.position_l, 'm')
113
114 wheel_3.advance()
115 self.assertEqual(wheel_3.position, 13)
116 self.assertEqual(wheel_3.position_l, 'n')
117
118
119 def test_advance(self):
120 wheel_3 = SimpleWheel(wheel_iii_spec)
121 wheel_3.set_position('a')
122 wheel_3.advance()
123 self.assertEqual(cat(wheel_3.forward(l)
124 for l in string.ascii_lowercase),
125 'cegikboqswuymxdhvfzjltrpna')
126 self.assertEqual(cat(wheel_3.backward(l)
127 for l in string.ascii_lowercase),
128 'zfaobrcpdteumygxhwivkqjnls')
129 self.assertEqual(wheel_3.position, 1)
130 self.assertEqual(wheel_3.position_l, 'b')
131
132 for _ in range(24): wheel_3.advance()
133
134 self.assertEqual(wheel_3.position, 25)
135 self.assertEqual(wheel_3.position_l, 'z')
136
137 self.assertEqual(cat(wheel_3.forward(l)
138 for l in string.ascii_lowercase),
139 'pcegikmdqsuywaozfjxhblnvtr')
140 self.assertEqual(cat(wheel_3.backward(l)
141 for l in string.ascii_lowercase),
142 'nubhcqdterfvgwoaizjykxmslp')
143
144 wheel_3.advance()
145 self.assertEqual(wheel_3.position, 0)
146 self.assertEqual(wheel_3.position_l, 'a')
147
148
149 self.assertEqual(cat(wheel_3.forward(l)
150 for l in string.ascii_lowercase),
151 'bdfhjlcprtxvznyeiwgakmusqo')
152 self.assertEqual(cat(wheel_3.backward(l)
153 for l in string.ascii_lowercase),
154 'tagbpcsdqeufvnzhyixjwlrkom')
155
156
157 class WheelTest(unittest.TestCase):
158 def test_init1(self):
159 wheel = Wheel(wheel_iii_spec, wheel_iii_pegs, position='b',
160 ring_setting=1)
161 self.assertEqual(wheel.position, 1)
162 self.assertEqual(wheel.peg_positions, [20])
163 self.assertEqual(wheel.position_l, 'b')
164
165 wheel.advance()
166 self.assertEqual(wheel.position, 2)
167 self.assertEqual(wheel.peg_positions, [19])
168 self.assertEqual(wheel.position_l, 'c')
169
170 def test_init2(self):
171 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
172 ring_setting=3)
173 self.assertEqual(wheel.position, 25)
174 self.assertIn(11, wheel.peg_positions)
175 self.assertIn(24, wheel.peg_positions)
176 self.assertEqual(wheel.position_l, 'b')
177 self.assertEqual(cat(wheel.forward(l)
178 for l in string.ascii_lowercase),
179 'xkqhwpvngzrcfoiaselbtymjdu')
180 self.assertEqual(cat(wheel.backward(l)
181 for l in string.ascii_lowercase),
182 'ptlyrmidoxbswhnfckquzgeavj')
183
184 def test_advance(self):
185 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
186 ring_setting=3)
187 wheel.advance()
188
189 self.assertEqual(wheel.position, 0)
190 self.assertIn(10, wheel.peg_positions)
191 self.assertIn(23, wheel.peg_positions)
192 self.assertEqual(wheel.position_l, 'c')
193 self.assertEqual(cat(wheel.forward(l)
194 for l in string.ascii_lowercase),
195 'jpgvoumfyqbenhzrdkasxlictw')
196 self.assertEqual(cat(wheel.backward(l)
197 for l in string.ascii_lowercase),
198 'skxqlhcnwarvgmebjptyfdzuio')
199
200 def test_advance_23(self):
201 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
202 ring_setting=3)
203 for _ in range(23):
204 wheel.advance()
205
206 self.assertEqual(wheel.position, 22)
207 self.assertIn(1, wheel.peg_positions)
208 self.assertIn(14, wheel.peg_positions)
209 self.assertEqual(wheel.position_l, 'y')
210 self.assertEqual(cat(wheel.forward(l)
211 for l in string.ascii_lowercase),
212 'mgxantkzsyqjcufirldvhoewbp')
213 self.assertEqual(cat(wheel.backward(l)
214 for l in string.ascii_lowercase),
215 'dymswobuplgraevzkqifntxcjh')
216
217 def test_advance_24(self):
218 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
219 ring_setting=3)
220 for _ in range(24):
221 wheel.advance()
222
223 self.assertEqual(wheel.position, 23)
224 self.assertIn(0, wheel.peg_positions)
225 self.assertIn(13, wheel.peg_positions)
226 self.assertEqual(wheel.position_l, 'z')
227 self.assertEqual(cat(wheel.forward(l)
228 for l in string.ascii_lowercase),
229 'fwzmsjyrxpibtehqkcugndvaol')
230 self.assertEqual(cat(wheel.backward(l)
231 for l in string.ascii_lowercase),
232 'xlrvnatokfqzduyjphemswbigc')
233
234 def test_advance_25(self):
235 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
236 ring_setting=3)
237 for _ in range(25):
238 wheel.advance()
239
240 self.assertEqual(wheel.position, 24)
241 self.assertIn(25, wheel.peg_positions)
242 self.assertIn(12, wheel.peg_positions)
243 self.assertEqual(wheel.position_l, 'a')
244 self.assertEqual(cat(wheel.forward(l)
245 for l in string.ascii_lowercase),
246 'vylrixqwohasdgpjbtfmcuznke')
247 self.assertEqual(cat(wheel.backward(l)
248 for l in string.ascii_lowercase),
249 'kqumzsnjepyctxiogdlrvahfbw')
250
251 def test_advance_26(self):
252 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
253 ring_setting=3)
254 for _ in range(26):
255 wheel.advance()
256
257 self.assertEqual(wheel.position, 25)
258 self.assertIn(24, wheel.peg_positions)
259 self.assertIn(11, wheel.peg_positions)
260 self.assertEqual(wheel.position_l, 'b')
261 self.assertEqual(cat(wheel.forward(l)
262 for l in string.ascii_lowercase),
263 'xkqhwpvngzrcfoiaselbtymjdu')
264 self.assertEqual(cat(wheel.backward(l)
265 for l in string.ascii_lowercase),
266 'ptlyrmidoxbswhnfckquzgeavj')
267
268 def test_advance_27(self):
269 wheel = Wheel(wheel_vi_spec, wheel_vi_pegs, position='b',
270 ring_setting=3)
271 for _ in range(27):
272 wheel.advance()
273
274 self.assertEqual(wheel.position, 0)
275 self.assertIn(23, wheel.peg_positions)
276 self.assertIn(10, wheel.peg_positions)
277 self.assertEqual(wheel.position_l, 'c')
278 self.assertEqual(cat(wheel.forward(l)
279 for l in string.ascii_lowercase),
280 'jpgvoumfyqbenhzrdkasxlictw')
281 self.assertEqual(cat(wheel.backward(l)
282 for l in string.ascii_lowercase),
283 'skxqlhcnwarvgmebjptyfdzuio')
284
285 def test_set_position(self):
286 wheel_3 = Wheel(wheel_iii_spec, wheel_iii_pegs, ring_setting=3)
287 wheel_3.set_position('a')
288 self.assertEqual(wheel_3.position, 24)
289 self.assertEqual(wheel_3.position_l, 'a')
290 self.assertEqual(wheel_3.peg_positions, [21])
291
292 wheel_3.set_position('z')
293 self.assertEqual(wheel_3.position, 23)
294 self.assertEqual(wheel_3.position_l, 'z')
295 self.assertEqual(wheel_3.peg_positions, [22])
296
297 wheel_3.set_position(26)
298 self.assertEqual(wheel_3.position, 23)
299 self.assertEqual(wheel_3.position_l, 'z')
300 self.assertEqual(wheel_3.peg_positions, [22])
301
302 wheel_3.set_position(27)
303 self.assertEqual(wheel_3.position, 24)
304 self.assertEqual(wheel_3.position_l, 'a')
305 self.assertEqual(wheel_3.peg_positions, [21])
306
307 wheel_3.set_position('f')
308 self.assertEqual(wheel_3.position, 3)
309 self.assertEqual(wheel_3.position_l, 'f')
310 self.assertEqual(wheel_3.peg_positions, [16])
311
312 wheel_3.set_position(6)
313 self.assertEqual(wheel_3.position, 3)
314 self.assertEqual(wheel_3.position_l, 'f')
315 self.assertEqual(wheel_3.peg_positions, [16])
316
317 wheel_3.advance()
318 self.assertEqual(wheel_3.position, 4)
319 self.assertEqual(wheel_3.position_l, 'g')
320 self.assertEqual(wheel_3.peg_positions, [15])
321
322 wheel_3.set_position(12)
323 self.assertEqual(wheel_3.position, 9)
324 self.assertEqual(wheel_3.position_l, 'l')
325 self.assertEqual(wheel_3.peg_positions, [10])
326
327 wheel_3.advance()
328 self.assertEqual(wheel_3.position, 10)
329 self.assertEqual(wheel_3.position_l, 'm')
330 self.assertEqual(wheel_3.peg_positions, [9])
331
332
333 class EnigmaTest(unittest.TestCase):
334
335 def setUp(self):
336 self.enigma = Enigma(reflector_b_spec,
337 wheel_i_spec, wheel_i_pegs,
338 wheel_ii_spec, wheel_ii_pegs,
339 wheel_iii_spec, wheel_iii_pegs,
340 1, 1, 1,
341 '')
342
343 # Setting sheet line 31 from http://www.codesandciphers.org.uk/enigma/enigma3.htm
344 # Enigma simulation settings are
345 # http://enigma.louisedade.co.uk/enigma.html?m3;b;b153;AFTX;AJEU;AU-BG-EY-FP-HL-IN-JZ-OS-QR-TX
346 self.enigma31 = Enigma(reflector_b_spec,
347 wheel_i_spec, wheel_i_pegs,
348 wheel_v_spec, wheel_v_pegs,
349 wheel_iii_spec, wheel_iii_pegs,
350 6, 20, 24,
351 'ua pf rq so ni ey bg hl tx zj')
352
353 # Settings for Bletchley Park outreach department's Enigma
354 self.enigma_bp = Enigma(reflector_b_spec,
355 wheel_i_spec, wheel_i_pegs,
356 wheel_iii_spec, wheel_iii_pegs,
357 wheel_ii_spec, wheel_ii_pegs,
358 1, 26, 26,
359 'qm we ro tu zj ps dl fg')
360
361
362 def test_middle_advance(self):
363 self.enigma.set_wheels('a', 'a', 't')
364 self.assertEqual(self.enigma.wheel_positions, (0, 0, 19))
365 self.assertEqual(cat(self.enigma.wheel_positions_l), 'aat')
366 self.assertEqual(self.enigma.peg_positions, ([16], [4], [2]))
367 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
368 'puvioztjdhxmlyeawsrgbcqknf')
369
370 self.enigma.advance()
371 self.assertEqual(self.enigma.wheel_positions, (0, 0, 20))
372 self.assertEqual(cat(self.enigma.wheel_positions_l), 'aau')
373 self.assertEqual(self.enigma.peg_positions, ([16], [4], [1]))
374 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
375 'baigpldqcowfyzjehvtsxrkumn')
376
377 self.enigma.advance()
378 self.assertEqual(self.enigma.wheel_positions, (0, 0, 21))
379 self.assertEqual(cat(self.enigma.wheel_positions_l), 'aav')
380 self.assertEqual(self.enigma.peg_positions, ([16], [4], [0]))
381 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
382 'mnvfydiwgzsoablrxpkutchqej')
383
384 self.enigma.advance()
385 self.assertEqual(self.enigma.wheel_positions, (0, 1, 22))
386 self.assertEqual(cat(self.enigma.wheel_positions_l), 'abw')
387 self.assertEqual(self.enigma.peg_positions, ([16], [3], [25]))
388 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
389 'ulfopcykswhbzvderqixanjtgm')
390
391 self.enigma.advance()
392 self.assertEqual(self.enigma.wheel_positions, (0, 1, 23))
393 self.assertEqual(cat(self.enigma.wheel_positions_l), 'abx')
394 self.assertEqual(self.enigma.peg_positions, ([16], [3], [24]))
395 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
396 'qmwftdyovursbzhxaklejicpgn')
397
398 self.enigma.advance()
399 self.assertEqual(self.enigma.wheel_positions, (0, 1, 24))
400 self.assertEqual(cat(self.enigma.wheel_positions_l), 'aby')
401 self.assertEqual(self.enigma.peg_positions, ([16], [3], [23]))
402 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
403 'oljmzxrvucybdqasngpwihtfke')
404
405
406 def test_double_advance(self):
407 self.enigma.set_wheels('a', 'd', 't')
408 self.assertEqual(self.enigma.wheel_positions, (0, 3, 19))
409 self.assertEqual(cat(self.enigma.wheel_positions_l), 'adt')
410 self.assertEqual(self.enigma.peg_positions, ([16], [1], [2]))
411 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
412 'zcbpqxwsjiuonmldethrkygfva')
413
414 self.enigma.advance()
415 self.assertEqual(self.enigma.wheel_positions, (0, 3, 20))
416 self.assertEqual(cat(self.enigma.wheel_positions_l), 'adu')
417 self.assertEqual(self.enigma.peg_positions, ([16], [1], [1]))
418 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
419 'ehprawjbngotxikcsdqlzyfmvu')
420
421 self.enigma.advance()
422 self.assertEqual(self.enigma.wheel_positions, (0, 3, 21))
423 self.assertEqual(cat(self.enigma.wheel_positions_l), 'adv')
424 self.assertEqual(self.enigma.peg_positions, ([16], [1], [0]))
425 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
426 'eqzxarpihmnvjkwgbfuyslodtc')
427
428 self.enigma.advance()
429 self.assertEqual(self.enigma.wheel_positions, (0, 4, 22))
430 self.assertEqual(cat(self.enigma.wheel_positions_l), 'aew')
431 self.assertEqual(self.enigma.peg_positions, ([16], [0], [25]))
432 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
433 'qedcbtpluzmhkongavwfirsyxj')
434
435 self.enigma.advance()
436 self.assertEqual(self.enigma.wheel_positions, (1, 5, 23))
437 self.assertEqual(cat(self.enigma.wheel_positions_l), 'bfx')
438 self.assertEqual(self.enigma.peg_positions, ([15], [25], [24]))
439 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
440 'iwuedhsfazqxytvrkpgncoblmj')
441
442 self.enigma.advance()
443 self.assertEqual(self.enigma.wheel_positions, (1, 5, 24))
444 self.assertEqual(cat(self.enigma.wheel_positions_l), 'bfy')
445 self.assertEqual(self.enigma.peg_positions, ([15], [25], [23]))
446 self.assertEqual(cat(self.enigma.lookup(l) for l in string.ascii_lowercase),
447 'baknstqzrmcxjdvygiefwoulph')
448
449
450 def test_simple_encipher(self):
451 self.enigma.set_wheels('a', 'a', 'a')
452 ct = self.enigma.encipher('testmessage')
453 self.assertEqual(ct, 'olpfhnvflyn')
454
455 self.enigma.set_wheels('a', 'd', 't')
456 ct = self.enigma.encipher('testmessage')
457 self.assertEqual(ct, 'lawnjgpwjik')
458
459 self.enigma.set_wheels('b', 'd', 'q')
460 ct = self.enigma.encipher('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
461 self.assertEqual(ct,
462 'kvmmwrlqlqsqpeugjrcxzwpfyiyybwloewrouvkpoztceuwtfjzqwpbqldttsr')
463 self.assertEqual(cat(self.enigma.wheel_positions_l), 'cha')
464
465
466 def test_advance_with_ring_settings(self):
467 self.enigma31.set_wheels('j', 'e', 'u')
468
469 self.enigma31.advance()
470 self.assertEqual(self.enigma31.wheel_positions, (4, 11, 24))
471 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jev')
472 self.assertEqual(self.enigma31.peg_positions, ([7], [21], [0]))
473 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
474 'mvqjlyowkdieasgzcunxrbhtfp')
475
476 self.enigma31.advance()
477 self.assertEqual(self.enigma31.wheel_positions, (4, 12, 25))
478 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jfw')
479 self.assertEqual(self.enigma31.peg_positions, ([7], [20], [25]))
480 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
481 'sjolzuyvrbwdpxcmtiaqfhknge')
482
483 self.enigma31.advance()
484 self.assertEqual(self.enigma31.wheel_positions, (4, 12, 0))
485 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jfx')
486 self.assertEqual(self.enigma31.peg_positions, ([7], [20], [24]))
487 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
488 'qrxedkoywufmlvgsabpzjnicht')
489
490 self.enigma31.advance()
491 self.assertEqual(self.enigma31.wheel_positions, (4, 12, 1))
492 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jfy')
493 self.assertEqual(self.enigma31.peg_positions, ([7], [20], [23]))
494 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
495 'hpsukliagqefwvtbjxcodnmrzy')
496
497 self.enigma31.advance()
498 self.assertEqual(self.enigma31.wheel_positions, (4, 12, 2))
499 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jfz')
500 self.assertEqual(self.enigma31.peg_positions, ([7], [20], [22]))
501 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
502 'zevnbpyqowrtxdifhkulscjmga')
503
504
505 def test_advance_with_ring_settings_2(self):
506 self.enigma31.set_wheels('i', 'd', 'z')
507
508 self.enigma31.advance()
509 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 3))
510 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ida')
511 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [21]))
512 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
513 'ikhpqrvcambzjondefwyxgsutl')
514
515 self.enigma31.advance()
516 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 4))
517 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idb')
518 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [20]))
519 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
520 'cdabskhgzwfmlqvunyexpojtri')
521
522 self.enigma31.advance()
523 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 5))
524 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idc')
525 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [19]))
526 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
527 'pcbwiqhgemyvjsuaftnroldzkx')
528
529 self.enigma31.advance()
530 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 6))
531 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idd')
532 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [18]))
533 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
534 'xcbfvdnouptmlghjzwykierasq')
535
536 self.enigma31.advance()
537 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 7))
538 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ide')
539 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [17]))
540 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
541 'xfvglbdynuseriwqpmkzjcoaht')
542
543 self.enigma31.advance()
544 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 8))
545 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idf')
546 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [16]))
547 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
548 'tfpqlbouynsewjgcdxkahzmriv')
549
550 self.enigma31.advance()
551 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 9))
552 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idg')
553 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [15]))
554 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
555 'cjaunvlwtbygzexrspqidfhokm')
556
557 self.enigma31.advance()
558 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 10))
559 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idh')
560 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [14]))
561 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
562 'yltxkrqvowebzpingfucshjdam')
563
564 self.enigma31.advance()
565 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 11))
566 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idi')
567 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [13]))
568 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
569 'myktluzrnxceaiqsohpdfwvjbg')
570
571 self.enigma31.advance()
572 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 12))
573 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idj')
574 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [12]))
575 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
576 'pynjrmiugdqxfcvakewzhoslbt')
577
578 self.enigma31.advance()
579 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 13))
580 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idk')
581 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [11]))
582 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
583 'mwvedyplnoxhaijgrqtszcbkfu')
584
585 self.enigma31.advance()
586 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 14))
587 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idl')
588 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [10]))
589 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
590 'qcbrfeutvoxpnmjladzhgiykws')
591
592 self.enigma31.advance()
593 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 15))
594 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idm')
595 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [9]))
596 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
597 'dnoahryetsmukbcvwfjilpqzgx')
598
599 self.enigma31.advance()
600 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 16))
601 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idn')
602 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [8]))
603 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
604 'nidcfehgbqsovalyjzkxwmutpr')
605
606 self.enigma31.advance()
607 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 17))
608 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ido')
609 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [7]))
610 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
611 'joifxdulcarhzpbntkwqgysevm')
612
613 self.enigma31.advance()
614 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 18))
615 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idp')
616 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [6]))
617 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
618 'ptnlsxvozmwdjchayuebrgkfqi')
619
620 self.enigma31.advance()
621 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 19))
622 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idq')
623 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [5]))
624 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
625 'slwopzqnmxybihdeguavrtcjkf')
626
627 self.enigma31.advance()
628 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 20))
629 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idr')
630 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [4]))
631 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
632 'hcbedwlamzogixkytsrqvufnpj')
633
634 self.enigma31.advance()
635 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 21))
636 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ids')
637 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [3]))
638 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
639 'odxbjwzrmelkisavuhnyqpfctg')
640
641 self.enigma31.advance()
642 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 22))
643 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idt')
644 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [2]))
645 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
646 'udgbfeclrwnhxksvtioqapjmzy')
647
648 self.enigma31.advance()
649 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 23))
650 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idu')
651 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [1]))
652 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
653 'nrdczqxmowvshaiufblypkjgte')
654
655 self.enigma31.advance()
656 self.assertEqual(self.enigma31.wheel_positions, (3, 10, 24))
657 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'idv')
658 self.assertEqual(self.enigma31.peg_positions, ([8], [22], [0]))
659 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
660 'hkifjdoacebqtzgulyvmpsxwrn')
661
662 self.enigma31.advance()
663 self.assertEqual(self.enigma31.wheel_positions, (3, 11, 25))
664 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'iew')
665 self.assertEqual(self.enigma31.peg_positions, ([8], [21], [25]))
666 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
667 'yptzuhofqvnmlkgbixwcejsrad')
668
669 self.enigma31.advance()
670 self.assertEqual(self.enigma31.wheel_positions, (3, 11, 0))
671 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'iex')
672 self.assertEqual(self.enigma31.peg_positions, ([8], [21], [24]))
673 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
674 'vkdcwhqfjibzsptngumoraeyxl')
675
676 self.enigma31.advance()
677 self.assertEqual(self.enigma31.wheel_positions, (3, 11, 1))
678 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'iey')
679 self.assertEqual(self.enigma31.peg_positions, ([8], [21], [23]))
680 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
681 'wenpbqrouxlkychdfgzvitajms')
682
683 def test_double_advance_with_ring_settings_2(self):
684 self.enigma31.set_wheels('a', 'y', 't')
685 self.assertEqual(self.enigma31.wheel_positions, (21, 5, 22))
686 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayt')
687 self.assertEqual(self.enigma31.peg_positions, ([16], [1], [2]))
688
689 self.enigma31.advance()
690 self.assertEqual(self.enigma31.wheel_positions, (21, 5, 23))
691 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayu')
692 self.assertEqual(self.enigma31.peg_positions, ([16], [1], [1]))
693
694 self.enigma31.advance()
695 self.assertEqual(self.enigma31.wheel_positions, (21, 5, 24))
696 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayv')
697 self.assertEqual(self.enigma31.peg_positions, ([16], [1], [0]))
698
699 self.enigma31.advance()
700 self.assertEqual(self.enigma31.wheel_positions, (21, 6, 25))
701 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'azw')
702 self.assertEqual(self.enigma31.peg_positions, ([16], [0], [25]))
703
704 self.enigma31.advance()
705 self.assertEqual(self.enigma31.wheel_positions, (22, 7, 0))
706 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bax')
707 self.assertEqual(self.enigma31.peg_positions, ([15], [25], [24]))
708
709 self.enigma31.advance()
710 self.assertEqual(self.enigma31.wheel_positions, (22, 7, 1))
711 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bay')
712 self.assertEqual(self.enigma31.peg_positions, ([15], [25], [23]))
713
714 self.enigma31.set_wheels('a', 'z', 't')
715 self.assertEqual(self.enigma31.wheel_positions, (21, 6, 22))
716 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'azt')
717 self.assertEqual(self.enigma31.peg_positions, ([16], [0], [2]))
718
719 self.enigma31.advance()
720 self.assertEqual(self.enigma31.wheel_positions, (22, 7, 23))
721 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bau')
722 self.assertEqual(self.enigma31.peg_positions, ([15], [25], [1]))
723
724 self.enigma31.advance()
725 self.assertEqual(self.enigma31.wheel_positions, (22, 7, 24))
726 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bav')
727 self.assertEqual(self.enigma31.peg_positions, ([15], [25], [0]))
728
729 self.enigma31.advance()
730 self.assertEqual(self.enigma31.wheel_positions, (22, 8, 25))
731 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bbw')
732 self.assertEqual(self.enigma31.peg_positions, ([15], [24], [25]))
733
734 self.enigma31.advance()
735 self.assertEqual(self.enigma31.wheel_positions, (22, 8, 0))
736 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bbx')
737 self.assertEqual(self.enigma31.peg_positions, ([15], [24], [24]))
738
739 self.enigma31.advance()
740 self.assertEqual(self.enigma31.wheel_positions, (22, 8, 1))
741 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bby')
742 self.assertEqual(self.enigma31.peg_positions, ([15], [24], [23]))
743
744
745 def test_encipher_with_ring(self):
746
747 self.enigma31.set_wheels('i', 'z', 'd')
748 ct = self.enigma31.encipher('verylongtestmessagewithanextrabitofmessageforgoodmeasure')
749 self.assertEqual(ct,
750 'apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')
751 self.assertEqual(self.enigma31.wheel_positions, (4, 9, 10))
752 self.assertEqual(cat(self.enigma31.wheel_positions_l), 'jch')
753 self.assertEqual(self.enigma31.peg_positions, ([7], [23], [14]))
754 self.assertEqual(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase),
755 'mopnigfuesqwadbcktjrhylzvx')
756
757 self.enigma31.set_wheels('i', 'z', 'd')
758 pt = self.enigma31.decipher('apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')
759 self.assertEqual(pt,
760 'verylongtestmessagewithanextrabitofmessageforgoodmeasure')
761
762 if __name__ == '__main__':
763 unittest.main()