1with AUnit.Assertions;
2with Crypto.Types.Big_Numbers;
3with Big_Number_Mult2_Results;
4
5pragma Elaborate_All(Crypto.Types.Big_Numbers);
6pragma Optimize(Time);
7
8package body Test.Big_Number_Mult2 is
9
10------------------------------------------------------------------------------------
11------------------------------------------------------------------------------------
12-------------------------------- Type - Declaration --------------------------------
13------------------------------------------------------------------------------------
14------------------------------------------------------------------------------------
15
16	package Big is new Crypto.Types.Big_Numbers(22400);
17    use Big;
18    use Big.Utils;
19
20	use Big_Number_Mult2_Results;
21
22	A, B, C, D, E, F, G, H, I, A1, B1, C1, D1, E1, F1, G1, H1, I1,
23	Result0, Result1, Result2, Result3, Result4, Result5, Result6, Result7, Result8
24	: Big_Unsigned;
25
26    procedure Constants is
27	begin
28
29		A := To_Big_Unsigned(Cons_1);
30		A1 := To_Big_Unsigned(Cons_1_1);
31		Result0 := To_Big_Unsigned(Cons_R1);
32		B := To_Big_Unsigned(Cons_2);
33		B1 := To_Big_Unsigned(Cons_2_1);
34		Result1 := To_Big_Unsigned(Cons_R2);
35		C := To_Big_Unsigned(Cons_3);
36		C1 := To_Big_Unsigned(Cons_3_1);
37		Result2 := To_Big_Unsigned(Cons_R3);
38		D := To_Big_Unsigned(Cons_4);
39		D1 := To_Big_Unsigned(Cons_4_1);
40		Result3 := To_Big_Unsigned(Cons_R4);
41		E := To_Big_Unsigned(Cons_5);
42		E1 := To_Big_Unsigned(Cons_5_1);
43		Result4 := To_Big_Unsigned(Cons_R5);
44		F := To_Big_Unsigned(Cons_6);
45		F1 := To_Big_Unsigned(Cons_6_1);
46		Result5 := To_Big_Unsigned(Cons_R6);
47		G := To_Big_Unsigned(Cons_7);
48		G1 := To_Big_Unsigned(Cons_7_1);
49		Result6 := To_Big_Unsigned(Cons_R7);
50		H := To_Big_Unsigned(Cons_8);
51		H1 := To_Big_Unsigned(Cons_8_1);
52		Result7 := To_Big_Unsigned(Cons_R8);
53		I := To_Big_Unsigned(Cons_9);
54		I1 := To_Big_Unsigned(Cons_9_1);
55		Result8 := To_Big_Unsigned(Cons_R9);
56
57	end Constants;
58
59------------------------------------------------------------------------------------
60---------------------------- Register Big_Number Test 1 ----------------------------
61------------------------------------------------------------------------------------
62
63	procedure Register_Tests(T : in out Big_Number_Test) is
64		use Test_Cases.Registration;
65	begin
66		Register_Routine(T, Big_Number_Test1'Access,"Schoolboy Multiplication");
67		Register_Routine(T, Big_Number_Test2'Access,"Russian Peasant Multiplication");
68		Register_Routine(T, Big_Number_Test3'Access,"Karatsuba Multiplication");
69		Register_Routine(T, Big_Number_Test4'Access,"Parallel Karatsuba Multiplication");
70		Register_Routine(T, Big_Number_Test5'Access,"Toom-Cook Multiplication");
71		Register_Routine(T, Big_Number_Test6'Access,"Parallel Toom-Cook Multiplication");
72	end Register_Tests;
73
74------------------------------------------------------------------------------------
75------------------------------- Name Big_Number Test -------------------------------
76------------------------------------------------------------------------------------
77
78	function Name(T : Big_Number_Test) return Test_String is
79	begin
80		return new String'("Big Number Tests");
81	end Name;
82
83------------------------------------------------------------------------------------
84------------------------------------ Start Tests -----------------------------------
85------------------------------------------------------------------------------------
86-------------------------------------- Test 1 --------------------------------------
87------------------------------------------------------------------------------------
88
89   procedure Big_Number_Test1(T : in out Test_Cases.Test_Case'Class) is
90      use AUnit.Assertions;
91   begin
92      Constants;
93      Assert(A * A1 = Result0, "Failed with A.");
94      Assert(B * B1 = Result1, "Failed with B.");
95      Assert(C * C1 = Result2, "Failed with C.");
96      Assert(D * D1 = Result3, "Failed with D.");
97      Assert(E * E1 = Result4, "Failed with E.");
98      Assert(F * F1 = Result5, "Failed with F.");
99      Assert(G * G1 = Result6, "Failed with G.");
100      Assert(H * H1 = Result7, "Failed with H.");
101      Assert(I * I1 = Result8, "Failed with I.");
102   end Big_Number_Test1;
103
104------------------------------------------------------------------------------------
105-------------------------------------- Test 2 --------------------------------------
106------------------------------------------------------------------------------------
107
108   procedure Big_Number_Test2(T : in out Test_Cases.Test_Case'Class) is
109      use AUnit.Assertions;
110   begin
111      Assert(Russ(A,A1) = Result0, "Failed with A.");
112      Assert(Russ(B,B1) = Result1, "Failed with B.");
113      Assert(Russ(C,C1) = Result2, "Failed with C.");
114      Assert(Russ(D,D1) = Result3, "Failed with D.");
115      Assert(Russ(E,E1) = Result4, "Failed with E.");
116      Assert(Russ(F,F1) = Result5, "Failed with F.");
117      Assert(Russ(G,G1) = Result6, "Failed with G.");
118      Assert(Russ(H,H1) = Result7, "Failed with H.");
119      Assert(Russ(I,I1) = Result8, "Failed with I.");
120   end Big_Number_Test2;
121
122------------------------------------------------------------------------------------
123-------------------------------------- Test 3 --------------------------------------
124------------------------------------------------------------------------------------
125
126   procedure Big_Number_Test3(T : in out Test_Cases.Test_Case'Class) is
127      use AUnit.Assertions;
128   begin
129      Assert(Karatsuba(A,A1) = Result0, "Failed with A.");
130      Assert(Karatsuba(B,B1) = Result1, "Failed with B.");
131      Assert(Karatsuba(C,C1) = Result2, "Failed with C.");
132      Assert(Karatsuba(D,D1) = Result3, "Failed with D.");
133      Assert(Karatsuba(E,E1) = Result4, "Failed with E.");
134      Assert(Karatsuba(F,F1) = Result5, "Failed with F.");
135      Assert(Karatsuba(G,G1) = Result6, "Failed with G.");
136      Assert(Karatsuba(H,H1) = Result7, "Failed with H.");
137      Assert(Karatsuba(I,I1) = Result8, "Failed with I.");
138   end Big_Number_Test3;
139
140------------------------------------------------------------------------------------
141-------------------------------------- Test 4 --------------------------------------
142------------------------------------------------------------------------------------
143
144   procedure Big_Number_Test4(T : in out Test_Cases.Test_Case'Class) is
145      use AUnit.Assertions;
146   begin
147      Assert(Karatsuba_P(A,A1) = Result0, "Failed with A.");
148      Assert(Karatsuba_P(B,B1) = Result1, "Failed with B.");
149      Assert(Karatsuba_P(C,C1) = Result2, "Failed with C.");
150      Assert(Karatsuba_P(D,D1) = Result3, "Failed with D.");
151      Assert(Karatsuba_P(E,E1) = Result4, "Failed with E.");
152      Assert(Karatsuba_P(F,F1) = Result5, "Failed with F.");
153      Assert(Karatsuba_P(G,G1) = Result6, "Failed with G.");
154      Assert(Karatsuba_P(H,H1) = Result7, "Failed with H.");
155      Assert(Karatsuba_P(I,I1) = Result8, "Failed with I.");
156   end Big_Number_Test4;
157
158------------------------------------------------------------------------------------
159-------------------------------------- Test 5 --------------------------------------
160------------------------------------------------------------------------------------
161
162   procedure Big_Number_Test5(T : in out Test_Cases.Test_Case'Class) is
163      use AUnit.Assertions;
164   begin
165      Assert(Toom_Cook(A,A1) = Result0, "Failed with A.");
166      Assert(Toom_Cook(B,B1) = Result1, "Failed with B.");
167      Assert(Toom_Cook(C,C1) = Result2, "Failed with C.");
168      Assert(Toom_Cook(D,D1) = Result3, "Failed with D.");
169      Assert(Toom_Cook(E,E1) = Result4, "Failed with E.");
170      Assert(Toom_Cook(F,F1) = Result5, "Failed with F.");
171      Assert(Toom_Cook(G,G1) = Result6, "Failed with G.");
172      Assert(Toom_Cook(H,H1) = Result7, "Failed with H.");
173      Assert(Toom_Cook(I,I1) = Result8, "Failed with I.");
174   end Big_Number_Test5;
175
176------------------------------------------------------------------------------------
177-------------------------------------- Test 6 --------------------------------------
178------------------------------------------------------------------------------------
179
180   procedure Big_Number_Test6(T : in out Test_Cases.Test_Case'Class) is
181      use AUnit.Assertions;
182   begin
183      Assert(Toom_Cook_P(A,A1) = Result0, "Failed with A.");
184      Assert(Toom_Cook_P(B,B1) = Result1, "Failed with B.");
185      Assert(Toom_Cook_P(C,C1) = Result2, "Failed with C.");
186      Assert(Toom_Cook_P(D,D1) = Result3, "Failed with D.");
187      Assert(Toom_Cook_P(E,E1) = Result4, "Failed with E.");
188      Assert(Toom_Cook_P(F,F1) = Result5, "Failed with F.");
189      Assert(Toom_Cook_P(G,G1) = Result6, "Failed with G.");
190      Assert(Toom_Cook_P(H,H1) = Result7, "Failed with H.");
191      Assert(Toom_Cook_P(I,I1) = Result8, "Failed with I.");
192   end Big_Number_Test6;
193
194------------------------------------------------------------------------------------
195
196end Test.Big_Number_Mult2;
197