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