3 ### Testing prime-generation functionality
5 ### (c) 2019 Straylight/Edgeware
8 ###----- Licensing notice ---------------------------------------------------
10 ### This file is part of the Python interface to Catacomb.
12 ### Catacomb/Python is free software: you can redistribute it and/or
13 ### modify it under the terms of the GNU General Public License as
14 ### published by the Free Software Foundation; either version 2 of the
15 ### License, or (at your option) any later version.
17 ### Catacomb/Python is distributed in the hope that it will be useful, but
18 ### WITHOUT ANY WARRANTY; without even the implied warranty of
19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ### General Public License for more details.
22 ### You should have received a copy of the GNU General Public License
23 ### along with Catacomb/Python. If not, write to the Free Software
24 ### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
27 ###--------------------------------------------------------------------------
35 ###--------------------------------------------------------------------------
36 class TestPrimeFilter (U
.TestCase
):
39 n0
= 55614384877957400296344428606761687241
40 pf
= C
.PrimeFilter(n0
)
41 me
.assertEqual(pf
.status
, C
.PGEN_FAIL
)
43 me
.assertEqual(pf
.x
, n0
)
44 me
.assertEqual(int(pf
), n0
)
45 while not pf
: pf
.step(2)
46 me
.assertEqual(pf
.status
, C
.PGEN_TRY
)
47 me
.assertEqual(pf
.x
, n0
+ 6)
49 n1
= 111228769755914800592688857213523374495
51 me
.assertEqual(pf1
.x
, n1
)
52 me
.assertEqual(pf1
.status
, C
.PGEN_FAIL
)
55 pf0
= C
.PrimeFilter(step
)
56 me
.assertEqual(pf0
.status
, C
.PGEN_FAIL
)
57 while not pf1
: pf1
.jump(pf0
)
58 me
.assertEqual(pf1
.x
, n1
+ 6*step
)
60 ###--------------------------------------------------------------------------
61 class TestRabinMiller (U
.TestCase
):
64 ## See `Prime and Prejudice' by Martin R. Albrecht, Jake Massimo,
65 ## Kenneth G. Paterson, and Juraj Somorovsky.
66 p1
= C
.MP(142445387161415482404826365418175962266689133006163)
67 p2
= C
.MP(5840260873618034778597880982145214452934254453252643)
68 p3
= C
.MP(14386984103302963722887462907235772188935602433622363)
72 me
.assertEqual(rm
.test(2), C
.PGEN_PASS
)
73 me
.assertEqual(rm
.test(41), C
.PGEN_FAIL
)
74 me
.assertEqual(rm
.niters
, 6)
77 me
.assertEqual(C
.RabinMiller
.iters(50), 27)
78 me
.assertEqual(C
.RabinMiller
.iters(100), 27)
79 me
.assertEqual(C
.RabinMiller
.iters(500), 6)
80 me
.assertEqual(C
.RabinMiller
.iters(1000), 3)
81 me
.assertEqual(C
.RabinMiller
.iters(2000), 2)
83 ###--------------------------------------------------------------------------
85 class FailingHandler (object):
86 def pg_begin(me
, ev
): return C
.PGEN_TRY
87 def pg_try(me
, ev
): raise T
.Explosion
88 def pg_done(me
, ev
): raise ValueError("pg_done")
90 class TestPGen (U
.TestCase
):
93 ev
= T
.EventRecorder()
94 p0
= T
.detrand("pgen").mp(256, 1)
95 p
= C
.pgen(p0
, name
= "p", event
= ev
)
96 me
.assertEqual(p
, p0
+ 54)
97 me
.assertTrue(p
.primep())
98 me
.assertEqual(ev
.events
, "[p:F4/P11/D]")
100 def test_pgen_exc(me
):
101 rng
= T
.detrand("pgen_exc")
103 def hook(why
, ty
, val
, tb
): exc
[0] = val
105 me
.assertRaises(T
.Explosion
, C
.pgen
, rng
.mp(256, 1), name
= "p",
106 event
= T
.EventRecorder(explode_after
= 19))
107 me
.assertEqual(exc
[0], None)
108 me
.assertRaises(T
.Explosion
, C
.pgen
, rng
.mp(256, 1), name
= "p",
109 event
= FailingHandler(), stepper
= FailingHandler())
110 me
.assertEqual(exc
[0].args
[0], "pg_done")
112 me
.assertRaises(T
.Explosion
, C
.limlee
, 512, 96, name
= "p", rng
= rng
,
113 event
= T
.EventRecorder(explode_after
= 8))
114 ev
= T
.EventRecorder(explode_after
= 19)
115 me
.assertRaises(T
.Explosion
, C
.limlee
, 512, 96, name
= "p", rng
= rng
,
117 me
.assertRaises(ValueError, ev
.rng
.byte
)
118 me
.assertEqual(exc
[0], None)
119 C
.lostexchook
= C
.default_lostexchook
121 def test_strongprime_setup(me
):
122 ev
= T
.EventRecorder()
123 p0
, delta
= C
.strongprime_setup(256, name
= "p", event
= ev
,
124 rng
= T
.detrand("strongprime_setup"))
125 p
= C
.pgen(p0
, name
= "p", event
= ev
,
126 stepper
= C
.PrimeGenJumper(delta
))
127 me
.assertTrue(p
.primep())
128 me
.assertEqual((p
- p0
)%delta
, 0)
129 me
.assertEqual(p
.nbits
, 256)
130 me
.assertEqual(ev
.events
,
136 def test_strongprime(me
):
137 ev
= T
.EventRecorder()
138 p
= C
.strongprime(256, name
= "p", event
= ev
,
139 rng
= T
.detrand("strongprime"))
140 me
.assertTrue(p
.primep())
141 me
.assertEqual(p
.nbits
, 256)
142 me
.assertEqual(ev
.events
,
149 ev
= T
.EventRecorder()
150 p
, qq
= C
.limlee(512, 96, name
= "p", event
= ev
, ievent
= ev
,
151 rng
= T
.detrand("limlee"))
152 me
.assertTrue(p
.primep())
153 me
.assertEqual(p
.nbits
, 512)
155 me
.assertTrue(qbig
.primep())
156 me
.assertTrue(qbig
.nbits
>= 96)
158 me
.assertTrue(q
.primep())
159 me
.assertEqual(q
.nbits
, 96)
160 me
.assertEqual(p
, C
.MPMul(qq
).factor(qbig
).factor(2).done() + 1)
161 me
.assertEqual(ev
.events
,
206 def test_sgprime(me
):
207 ev
= T
.EventRecorder()
208 q0
= T
.detrand("sgprime").mp(255, 1)
209 q
= C
.sgprime(q0
, event
= ev
)
210 me
.assertTrue(q
.primep())
212 me
.assertEqual(p
.nbits
, 256)
213 me
.assertTrue(p
.primep())
216 ev
= T
.EventRecorder()
217 p
, q
, h
= C
.kcdsaprime(512, 96, event
= ev
, rng
= T
.detrand("kcdsa"))
218 me
.assertTrue(q
.primep())
219 me
.assertEqual(q
.nbits
, 96)
220 me
.assertTrue(h
.primep())
221 me
.assertEqual(p
, 2*q
*h
+ 1)
222 me
.assertTrue(p
.primep())
223 me
.assertEqual(p
.nbits
, 512)
224 me
.assertEqual(ev
.events
, "[p [h]:F17/P6/D][p:F60/P26/D]")
226 ###----- That's all, folks --------------------------------------------------
228 if __name__
== "__main__": U
.main()