security/nss/cmd/libpkix/pkix_pl/system/test_bigint.c

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the PKIX-C library.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Sun Microsystems, Inc.
  18  * Portions created by the Initial Developer are
  19  * Copyright 2004-2007 Sun Microsystems, Inc.  All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Sun Microsystems, Inc.
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37 /*
  38  * test_bigint.c
  39  *
  40  * Tests BigInt Types
  41  *
  42  */
  43
  44 #include "testutil.h"
  45 #include "testutil_nss.h"
  46
  47 static void *plContext = NULL;
  48
  49 static void
  50 createBigInt(
  51         PKIX_PL_BigInt **bigInts,
  52         char *bigIntAscii,
  53         PKIX_Boolean errorHandling)
  54 {
  55         PKIX_PL_String *bigIntString = NULL;
  56
  57         PKIX_TEST_STD_VARS();
  58
  59         PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create
  60                                     (PKIX_ESCASCII,
  61                                     bigIntAscii,
  62                                     PL_strlen(bigIntAscii),
  63                                     &bigIntString,
  64                                     plContext));
  65
  66         if (errorHandling){
  67                 PKIX_TEST_EXPECT_ERROR(PKIX_PL_BigInt_Create
  68                                             (bigIntString,
  69                                             bigInts,
  70                                             plContext));
  71         } else {
  72                 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_BigInt_Create
  73                                             (bigIntString,
  74                                             bigInts,
  75                                             plContext));
  76         }
  77
  78 cleanup:
  79
  80         PKIX_TEST_DECREF_AC(bigIntString);
  81
  82         PKIX_TEST_RETURN();
  83 }
  84
  85 static void
  86 testToString(
  87         PKIX_PL_BigInt *bigInt,
  88         char *expAscii)
  89 {
  90         PKIX_PL_String *bigIntString = NULL;
  91         char *temp = NULL;
  92
  93         PKIX_TEST_STD_VARS();
  94
  95         PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString
  96                                     ((PKIX_PL_Object*)bigInt,
  97                                     &bigIntString, plContext));
  98
  99         temp = PKIX_String2ASCII(bigIntString, plContext);
 100         if (temp == plContext){
 101                 testError("PKIX_String2Ascii failed");
 102                 goto cleanup;
 103         }
 104
 105         if (PL_strcmp(temp, expAscii) != 0) {
 106                 (void) printf("\tBigInt ToString: %s %s\n", temp, expAscii);
 107                 testError("Output string does not match source");
 108         }
 109
 110         PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext));
 111
 112 cleanup:
 113
 114         PKIX_TEST_DECREF_AC(bigIntString);
 115
 116         PKIX_TEST_RETURN();
 117 }
 118
 119 static void
 120 testCompare(
 121         PKIX_PL_BigInt *firstBigInt,
 122         PKIX_PL_BigInt *secondBigInt,
 123         PKIX_Int32 *cmpResult)
 124 {
 125         PKIX_TEST_STD_VARS();
 126
 127         PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Compare
 128                                     ((PKIX_PL_Object*)firstBigInt,
 129                                     (PKIX_PL_Object*)secondBigInt,
 130                                     cmpResult, plContext));
 131 cleanup:
 132
 133         PKIX_TEST_RETURN();
 134 }
 135
 136 static void
 137 testDestroy(
 138         PKIX_PL_BigInt *bigInt)
 139 {
 140         PKIX_TEST_STD_VARS();
 141
 142         PKIX_TEST_DECREF_BC(bigInt);
 143
 144 cleanup:
 145
 146         PKIX_TEST_RETURN();
 147 }
 148
 149 int test_bigint(int argc, char *argv[]) {
 150
 151         PKIX_UInt32 size = 4, badSize = 3, i = 0;
 152         PKIX_PL_BigInt *testBigInt[4] = {NULL};
 153         PKIX_Int32 cmpResult;
 154         PKIX_UInt32 actualMinorVersion;
 155         PKIX_UInt32 j = 0;
 156
 157         char *bigIntValue[4] =
 158         {
 159                 "03",
 160                 "ff",
 161                 "1010101010101010101010101010101010101010",
 162                 "1010101010101010101010101010101010101010",
 163         };
 164
 165         char *badValue[3] = {"00ff", "fff", "-ff"};
 166
 167         PKIX_TEST_STD_VARS();
 168
 169         startTests("BigInts");
 170
 171         PKIX_TEST_EXPECT_NO_ERROR(
 172             PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));
 173
 174         for (i = 0; i < badSize; i++) {
 175                 subTest("PKIX_PL_BigInt_Create <error_handling>");
 176                 createBigInt(&testBigInt[i], badValue[i], PKIX_TRUE);
 177         }
 178
 179         for (i = 0; i < size; i++) {
 180                 subTest("PKIX_PL_BigInt_Create");
 181                 createBigInt(&testBigInt[i], bigIntValue[i], PKIX_FALSE);
 182         }
 183
 184         PKIX_TEST_EQ_HASH_TOSTR_DUP
 185                 (testBigInt[2],
 186                 testBigInt[3],
 187                 testBigInt[1],
 188                 bigIntValue[2],
 189                 BigInt,
 190                 PKIX_TRUE);
 191
 192         for (i = 0; i < size; i++) {
 193                 subTest("PKIX_PL_BigInt_ToString");
 194                 testToString(testBigInt[i], bigIntValue[i]);
 195         }
 196
 197         subTest("PKIX_PL_BigInt_Compare <gt>");
 198         testCompare(testBigInt[2], testBigInt[1], &cmpResult);
 199         if (cmpResult <= 0){
 200                 testError("Invalid Result from String Compare");
 201         }
 202
 203         subTest("PKIX_PL_BigInt_Compare <lt>");
 204         testCompare(testBigInt[1], testBigInt[2], &cmpResult);
 205         if (cmpResult >= 0){
 206                 testError("Invalid Result from String Compare");
 207         }
 208
 209         subTest("PKIX_PL_BigInt_Compare <eq>");
 210         testCompare(testBigInt[2], testBigInt[3], &cmpResult);
 211         if (cmpResult != 0){
 212                 testError("Invalid Result from String Compare");
 213         }
 214
 215         for (i = 0; i < size; i++) {
 216                 subTest("PKIX_PL_BigInt_Destroy");
 217                 testDestroy(testBigInt[i]);
 218         }
 219
 220 cleanup:
 221
 222         PKIX_Shutdown(plContext);
 223
 224         endTests("BigInt");
 225
 226         return (0);
 227 }