tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_logger.c (8472B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 /*
      5 * test_logger.c
      6 *
      7 * Tests Logger Objects
      8 *
      9 */
     10 
     11 #include "testutil.h"
     12 #include "testutil_nss.h"
     13 
     14 static void *plContext = NULL;
     15 
     16 static char *levels[] = {
     17    "None",
     18    "Fatal Error",
     19    "Error",
     20    "Warning",
     21    "Debug",
     22    "Trace"
     23 };
     24 
     25 static PKIX_Error *
     26 testLoggerCallback(
     27    PKIX_Logger *logger,
     28    PKIX_PL_String *message,
     29    PKIX_UInt32 logLevel,
     30    PKIX_ERRORCLASS logComponent,
     31    void *plContext)
     32 {
     33    char *comp = NULL;
     34    char *msg = NULL;
     35    char result[100];
     36    static int callCount = 0;
     37 
     38    PKIX_TEST_STD_VARS();
     39 
     40    msg = PKIX_String2ASCII(message, plContext);
     41    PR_snprintf(result, 100, "Logging %s (%s): %s",
     42                levels[logLevel], PKIX_ERRORCLASSNAMES[logComponent], msg);
     43    subTest(result);
     44 
     45    callCount++;
     46    if (callCount > 1) {
     47        testError("Incorrect number of Logger Callback <expect 1>");
     48    }
     49 
     50 cleanup:
     51 
     52    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(msg, plContext));
     53    PKIX_TEST_RETURN();
     54 }
     55 
     56 static PKIX_Error *
     57 testLoggerCallback2(
     58    PKIX_Logger *logger,
     59    PKIX_PL_String *message,
     60    PKIX_UInt32 logLevel,
     61    PKIX_ERRORCLASS logComponent,
     62    void *plContext)
     63 {
     64    char *comp = NULL;
     65    char *msg = NULL;
     66    char result[100];
     67 
     68    PKIX_TEST_STD_VARS();
     69 
     70    msg = PKIX_String2ASCII(message, plContext);
     71    PR_snprintf(result, 100, "Logging %s (%s): %s",
     72                levels[logLevel], PKIX_ERRORCLASSNAMES[logComponent], msg);
     73    subTest(result);
     74 
     75 cleanup:
     76    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(msg, plContext));
     77    PKIX_TEST_RETURN();
     78 }
     79 
     80 static void
     81 createLogger(PKIX_Logger **logger,
     82             PKIX_PL_Object *context,
     83             PKIX_Logger_LogCallback cb)
     84 {
     85    PKIX_TEST_STD_VARS();
     86 
     87    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_Create(cb, context, logger, plContext));
     88 
     89 cleanup:
     90 
     91    PKIX_TEST_RETURN();
     92 }
     93 
     94 static void
     95 testContextCallback(PKIX_Logger *logger, PKIX_Logger *logger2)
     96 {
     97    PKIX_Logger_LogCallback cb = NULL;
     98    PKIX_PL_Object *context = NULL;
     99    PKIX_Boolean cmpResult = PKIX_FALSE;
    100    PKIX_UInt32 length;
    101 
    102    PKIX_TEST_STD_VARS();
    103 
    104    subTest("PKIX_Logger_GetLoggerContext");
    105    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggerContext(logger2, &context, plContext));
    106 
    107    testEqualsHelper((PKIX_PL_Object *)logger, context, PKIX_TRUE, plContext);
    108 
    109    subTest("PKIX_Logger_GetLogCallback");
    110    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLogCallback(logger, &cb, plContext));
    111 
    112    if (cb != testLoggerCallback) {
    113        testError("Incorrect Logger Callback returned");
    114    }
    115 
    116 cleanup:
    117 
    118    PKIX_TEST_DECREF_AC(context);
    119    PKIX_TEST_RETURN();
    120 }
    121 
    122 static void
    123 testComponent(PKIX_Logger *logger)
    124 {
    125    PKIX_ERRORCLASS compName = (PKIX_ERRORCLASS)NULL;
    126    PKIX_ERRORCLASS compNameReturn = (PKIX_ERRORCLASS)NULL;
    127    PKIX_Boolean cmpResult = PKIX_FALSE;
    128    PKIX_TEST_STD_VARS();
    129 
    130    subTest("PKIX_Logger_GetLoggingComponent");
    131    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent(logger, &compName, plContext));
    132 
    133    if (compName != (PKIX_ERRORCLASS)NULL) {
    134        testError("Incorrect Logger Component returned. expect <NULL>");
    135    }
    136 
    137    subTest("PKIX_Logger_SetLoggingComponent");
    138    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetLoggingComponent(logger, PKIX_LIST_ERROR, plContext));
    139 
    140    subTest("PKIX_Logger_GetLoggingComponent");
    141    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetLoggingComponent(logger, &compNameReturn, plContext));
    142 
    143    if (compNameReturn != PKIX_LIST_ERROR) {
    144        testError("Incorrect Logger Component returned.");
    145    }
    146 
    147 cleanup:
    148 
    149    PKIX_TEST_RETURN();
    150 }
    151 
    152 static void
    153 testMaxLoggingLevel(PKIX_Logger *logger)
    154 {
    155    PKIX_UInt32 level = 0;
    156    PKIX_TEST_STD_VARS();
    157 
    158    subTest("PKIX_Logger_GetMaxLoggingLevel");
    159    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel(logger, &level, plContext));
    160 
    161    if (level != 0) {
    162        testError("Incorrect Logger MaxLoggingLevel returned");
    163    }
    164 
    165    subTest("PKIX_Logger_SetMaxLoggingLevel");
    166    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetMaxLoggingLevel(logger, 3, plContext));
    167 
    168    subTest("PKIX_Logger_GetMaxLoggingLevel");
    169    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_GetMaxLoggingLevel(logger, &level, plContext));
    170 
    171    if (level != 3) {
    172        testError("Incorrect Logger MaxLoggingLevel returned");
    173    }
    174 
    175 cleanup:
    176 
    177    PKIX_TEST_RETURN();
    178 }
    179 
    180 static void
    181 testLogger(PKIX_Logger *logger, PKIX_Logger *logger2)
    182 {
    183    PKIX_List *loggerList = NULL;
    184    PKIX_List *checkList = NULL;
    185    PKIX_UInt32 length;
    186    PKIX_Boolean cmpResult = PKIX_FALSE;
    187    char *expectedAscii = "[\n"
    188                          "\tLogger: \n"
    189                          "\tContext:          (null)\n"
    190                          "\tMaximum Level:    3\n"
    191                          "\tComponent Name:   LIST\n"
    192                          "]\n";
    193 
    194    PKIX_TEST_STD_VARS();
    195 
    196    subTest("PKIX_GetLoggers");
    197    PKIX_TEST_EXPECT_NO_ERROR(PKIX_GetLoggers(&loggerList, plContext));
    198    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(loggerList, &length, plContext));
    199    if (length != 0) {
    200        testError("Incorrect Logger List returned");
    201    }
    202    PKIX_TEST_DECREF_BC(loggerList);
    203 
    204    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&loggerList, plContext));
    205    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(loggerList, (PKIX_PL_Object *)logger, plContext));
    206 
    207    subTest("PKIX_SetLoggers");
    208    PKIX_TEST_EXPECT_NO_ERROR(PKIX_SetLoggers(loggerList, plContext));
    209 
    210    subTest("PKIX_Logger_SetLoggingComponent");
    211    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetLoggingComponent(logger2, PKIX_MUTEX_ERROR, plContext));
    212 
    213    subTest("PKIX_Logger_SetMaxLoggingLevel");
    214    PKIX_TEST_EXPECT_NO_ERROR(PKIX_Logger_SetMaxLoggingLevel(logger2, 5, plContext));
    215 
    216    subTest("PKIX_AddLogger");
    217    PKIX_TEST_EXPECT_NO_ERROR(PKIX_AddLogger(logger2, plContext));
    218 
    219    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&checkList, plContext));
    220    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(checkList, (PKIX_PL_Object *)logger, plContext));
    221    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(checkList, (PKIX_PL_Object *)logger2, plContext));
    222 
    223    PKIX_TEST_DECREF_BC(loggerList);
    224 
    225    subTest("PKIX_GetLoggers");
    226    PKIX_TEST_EXPECT_NO_ERROR(PKIX_GetLoggers(&loggerList, plContext));
    227    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(loggerList, &length, plContext));
    228 
    229    subTest("pkix_Loggers_Equals");
    230    testEqualsHelper((PKIX_PL_Object *)loggerList,
    231                     (PKIX_PL_Object *)checkList,
    232                     PKIX_TRUE,
    233                     plContext);
    234 
    235    subTest("pkix_Loggers_Duplicate");
    236    testDuplicateHelper((PKIX_PL_Object *)logger, plContext);
    237 
    238    subTest("pkix_Loggers_Hashcode");
    239    testHashcodeHelper((PKIX_PL_Object *)logger,
    240                       (PKIX_PL_Object *)logger,
    241                       PKIX_TRUE,
    242                       plContext);
    243 
    244    subTest("pkix_Loggers_ToString");
    245    testToStringHelper((PKIX_PL_Object *)logger, expectedAscii, plContext);
    246 
    247    subTest("PKIX Logger Callback");
    248    subTest("Expect to have ***Fatal Error (List): Null argument*** once");
    249    PKIX_TEST_EXPECT_ERROR(PKIX_List_AppendItem(NULL, (PKIX_PL_Object *)NULL, plContext));
    250 
    251 cleanup:
    252 
    253    PKIX_TEST_DECREF_AC(loggerList);
    254    PKIX_TEST_DECREF_AC(checkList);
    255    PKIX_TEST_RETURN();
    256 }
    257 
    258 static void
    259 testDestroy(PKIX_Logger *logger)
    260 {
    261    PKIX_TEST_STD_VARS();
    262 
    263    PKIX_TEST_DECREF_BC(logger);
    264 
    265 cleanup:
    266 
    267    PKIX_TEST_RETURN();
    268 }
    269 
    270 int
    271 test_logger(int argc, char *argv[])
    272 {
    273 
    274    PKIX_Logger *logger, *logger2;
    275    PKIX_UInt32 actualMinorVersion;
    276    PKIX_UInt32 j = 0;
    277 
    278    PKIX_TEST_STD_VARS();
    279 
    280    startTests("Loggers");
    281 
    282    PKIX_TEST_EXPECT_NO_ERROR(
    283        PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));
    284 
    285    subTest("PKIX_Logger_Create");
    286    createLogger(&logger, NULL, testLoggerCallback);
    287    createLogger(&logger2, (PKIX_PL_Object *)logger, testLoggerCallback2);
    288 
    289    subTest("Logger Context and Callback");
    290    testContextCallback(logger, logger2);
    291 
    292    subTest("Logger Component");
    293    testComponent(logger);
    294 
    295    subTest("Logger MaxLoggingLevel");
    296    testMaxLoggingLevel(logger);
    297 
    298    subTest("Logger List operations");
    299    testLogger(logger, logger2);
    300 
    301    subTest("PKIX_Logger_Destroy");
    302    testDestroy(logger);
    303    testDestroy(logger2);
    304 
    305 cleanup:
    306 
    307    PKIX_Shutdown(plContext);
    308 
    309    PKIX_TEST_RETURN();
    310 
    311    endTests("Loggers");
    312 
    313    return (0);
    314 }