source/ubftest/test_nstd_util.c

0001 /**
0002  * @brief Standard utility library tests
0003  *
0004  * @file test_nstd_util.c
0005  */
0006 /* -----------------------------------------------------------------------------
0007  * Enduro/X Middleware Platform for Distributed Transaction Processing
0008  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0009  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0010  * This software is released under one of the following licenses:
0011  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0012  * See LICENSE file for full text.
0013  * -----------------------------------------------------------------------------
0014  * AGPL license:
0015  *
0016  * This program is free software; you can redistribute it and/or modify it under
0017  * the terms of the GNU Affero General Public License, version 3 as published
0018  * by the Free Software Foundation;
0019  *
0020  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0021  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0022  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0023  * for more details.
0024  *
0025  * You should have received a copy of the GNU Affero General Public License along
0026  * with this program; if not, write to the Free Software Foundation, Inc.,
0027  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0028  *
0029  * -----------------------------------------------------------------------------
0030  * A commercial use license is available from Mavimax, Ltd
0031  * contact@mavimax.com
0032  * -----------------------------------------------------------------------------
0033  */
0034
0035 #include <stdio.h>
0036 #include <stdlib.h>
0037 #include <sys/types.h>
0038 #include <sys/wait.h>
0039
0040 #include <cgreen/cgreen.h>
0041 #include <ubf.h>
0042 #include <ndrstandard.h>
0043 #include <string.h>
0044 #include <ndebug.h>
0045 #include <exbase64.h>
0046 #include <nstdutil.h>
0047 #include "test.fd.h"
0048 #include "ubfunit1.h"
0049 #include "xatmi.h"
0050 #include "nstopwatch.h"
0051 #include "sys_unix.h"
0052
0053 /*---------------------------Externs------------------------------------*/
0054 /*---------------------------Macros-------------------------------------*/
0055 #define OFSZ(s,e)   EXOFFSET(s,e), EXELEM_SIZE(s,e)
0056 /*---------------------------Enums--------------------------------------*/
0057 /*---------------------------Typedefs-----------------------------------*/
0058 /**
0059  * Argument testing struct
0060  */
0061 struct ndrx_args_test
0062 {
0063     int int1;
0064     int int2;
0065     int int3;
0066
0067     int bool1;
0068     int bool2;
0069     int bool3;
0070     int bool4;
0071 };
0072
0073 /**
0074  * Argument testing type
0075  */
0076 typedef struct ndrx_args_test ndrx_args_test_t;
0077 /*---------------------------Globals------------------------------------*/
0078 /*---------------------------Statics------------------------------------*/
0079
0080 /**
0081  * Mapping structure for arguments testing
0082  */
0083 static ndrx_args_loader_t M_args_test_map[] =
0084 {
0085     {OFSZ(ndrx_args_test_t,int1), "int1", NDRX_ARGS_INT, 0, 0, -10, 10},
0086     {OFSZ(ndrx_args_test_t,int2), "int2", NDRX_ARGS_INT, 0, 0, 0, INT_MAX},
0087     {OFSZ(ndrx_args_test_t,int3), "int3", NDRX_ARGS_INT, 0, 0, 0, 0},
0088
0089     {OFSZ(ndrx_args_test_t,bool1), "bool1", NDRX_ARGS_BOOL, 0, 0, 0, 0},
0090     {OFSZ(ndrx_args_test_t,bool2), "bool2", NDRX_ARGS_BOOL, 0, 0, 0, 0},
0091     {OFSZ(ndrx_args_test_t,bool3), "bool3", NDRX_ARGS_BOOL, 0, 0, 0, 0},
0092     {OFSZ(ndrx_args_test_t,bool4), "bool4", NDRX_ARGS_BOOL, 0, 0, 0, 0},
0093
0094     {EXFAIL}
0095 };
0096
0097 /*---------------------------Prototypes---------------------------------*/
0098
0099 /**
0100  * Check that file exists
0101  */
0102 Ensure(test_nstd_file_exists)
0103 {
0104     assert_equal(ndrx_file_exists("ubftab_test/test1.fd"), EXTRUE);
0105     assert_equal(ndrx_file_exists("ubftab_test/hello/test2.fd"), EXFALSE);
0106     assert_equal(ndrx_file_exists("ubftab_test"), EXTRUE);
0107     assert_equal(ndrx_file_exists("ubftab_test_non_exist"), EXFALSE);
0108 }
0109
0110 /**
0111  * Enduro/X version of strsep...
0112  */
0113 Ensure(test_nstd_strsep)
0114 {
0115     char test_str[] = "HELLO//WORLD";
0116     char *p;
0117
0118     p = test_str;
0119
0120     assert_string_equal(ndrx_strsep(&p, "/"), "HELLO");
0121
0122     assert_string_equal(ndrx_strsep(&p, "/"), "");
0123     assert_string_equal(ndrx_strsep(&p, "/"), "WORLD");
0124     assert_true(NULL==ndrx_strsep(&p, "/"));
0125
0126 }
0127
0128 /**
0129  * Check ndrx_str_ends_with() implementation
0130  */
0131 Ensure(test_nstd_ends_with)
0132 {
0133     char test_str[] = "HELLO//WORLD";
0134
0135     assert_true(ndrx_str_ends_with(test_str, "WORLD"));
0136     assert_false(ndrx_str_ends_with(test_str, "NONE"));
0137     assert_false(ndrx_str_ends_with(test_str, "XXHELLO//WORLD"));
0138     assert_true(ndrx_str_ends_with(test_str, "HELLO//WORLD"));
0139     /* empty strings matches too */
0140     assert_true(ndrx_str_ends_with(test_str, ""));
0141 }
0142
0143 /**
0144  * Test argument setter and getter
0145  */
0146 Ensure(test_nstd_args)
0147 {
0148     ndrx_args_test_t test_val;
0149     char val[128];
0150     char errbuf[256];
0151
0152     test_val.int1 = 2;
0153     test_val.int2 = 3;
0154     test_val.int3 = 4;
0155
0156     test_val.bool1 = EXTRUE;
0157     test_val.bool2 = EXFALSE;
0158     test_val.bool3 = EXTRUE;
0159     test_val.bool4 = EXFALSE;
0160
0161
0162     /* read the current values ...*/
0163
0164     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0165         "int1", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0166     assert_string_equal(val, "2");
0167
0168     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0169         "int2", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0170     assert_string_equal(val, "3");
0171
0172     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0173         "int3", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0174     assert_string_equal(val, "4");
0175
0176     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0177         "bool1", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0178     assert_string_equal(val, "Y");
0179
0180     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0181         "bool2", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0182     assert_string_equal(val, "N");
0183
0184     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0185         "bool3", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0186     assert_string_equal(val, "Y");
0187
0188     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0189         "bool4", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0190     assert_string_equal(val, "N");
0191
0192     /* change some values, and test the buffer... */
0193
0194     errbuf[0] = EXEOS;
0195     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0196         "int2", "5555", errbuf, sizeof(errbuf)), EXSUCCEED);
0197     assert_string_equal(errbuf, "");
0198
0199     errbuf[0] = EXEOS;
0200     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0201         "int1", "-12344", errbuf, sizeof(errbuf)), EXFAIL);
0202     assert_string_not_equal(errbuf, "");
0203
0204     errbuf[0] = EXEOS;
0205     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0206         "int1", "12344", errbuf, sizeof(errbuf)), EXFAIL);
0207     assert_string_not_equal(errbuf, "");
0208
0209     errbuf[0] = EXEOS;
0210     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0211         "int1", "-2", errbuf, sizeof(errbuf)), EXSUCCEED);
0212     assert_string_equal(errbuf, "");
0213
0214     errbuf[0] = EXEOS;
0215     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0216         "bool1", "X", errbuf, sizeof(errbuf)), EXFAIL);
0217     assert_string_not_equal(errbuf, "");
0218
0219     errbuf[0] = EXEOS;
0220     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0221         "bool1", "n", errbuf, sizeof(errbuf)), EXSUCCEED);
0222     assert_string_equal(errbuf, "");\
0223
0224     errbuf[0] = EXEOS;
0225     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0226         "bool2", "Y", errbuf, sizeof(errbuf)), EXSUCCEED);
0227     assert_string_equal(errbuf, "");
0228
0229     errbuf[0] = EXEOS;
0230     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0231         "bool3", "N", errbuf, sizeof(errbuf)), EXSUCCEED);
0232     assert_string_equal(errbuf, "");
0233
0234     errbuf[0] = EXEOS;
0235     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0236         "bool4", "y", errbuf, sizeof(errbuf)), EXSUCCEED);
0237     assert_string_equal(errbuf, "");
0238
0239     errbuf[0] = EXEOS;
0240     assert_equal(ndrx_args_loader_set(M_args_test_map, &test_val,
0241         "not_exists", "y", errbuf, sizeof(errbuf)), EXFAIL);
0242     assert_string_not_equal(errbuf, "");
0243
0244
0245     /* read values again and test... */
0246
0247     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0248         "int1", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0249     assert_string_equal(val, "-2");
0250
0251     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0252         "int2", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0253     assert_string_equal(val, "5555");
0254
0255     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0256         "int3", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0257     assert_string_equal(val, "4");
0258
0259     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0260         "bool1", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0261     assert_string_equal(val, "N");
0262
0263     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0264         "bool2", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0265     assert_string_equal(val, "Y");
0266
0267     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0268         "bool3", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0269     assert_string_equal(val, "N");
0270
0271     assert_equal(ndrx_args_loader_get(M_args_test_map, &test_val,
0272         "bool4", val, sizeof(val), errbuf, sizeof(errbuf)), EXSUCCEED);
0273     assert_string_equal(val, "Y");
0274
0275 }
0276
0277 /**
0278  * Test environment substitute routines
0279  * Bug #452
0280  */
0281 Ensure(test_nstd_env_subs)
0282 {
0283     char testbuf[32+1];
0284
0285     /* value is changed : (value longer than env var)*/
0286     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0287     setenv("NDRX_TESTXXXX", "DEBUG_MEGA_LONG_TESTZZZ", EXTRUE);
0288     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0289     assert_string_equal(testbuf, "DB1_JDBC/DEBUG_MEGA_LONG_TESTZZZ");
0290
0291     /* value longer and no space */
0292     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0293     setenv("NDRX_TESTXXXX", "DEBUG_MEGA_LONG_TESTZZZZ", EXTRUE);
0294     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0295     assert_string_equal(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0296
0297     /* value shorter than env var */
0298     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0299     setenv("NDRX_TESTXXXX", "DEBUG", EXTRUE);
0300     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0301     assert_string_equal(testbuf, "DB1_JDBC/DEBUG");
0302
0303     /* value equals in len.. */
0304     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0305     setenv("NDRX_TESTXXXX", "AAAAAAAAAAAAAAAA", EXTRUE);
0306     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0307     assert_string_equal(testbuf, "DB1_JDBC/AAAAAAAAAAAAAAAA");
0308
0309     /* value longer than var, two vars */
0310     NDRX_STRCPY_SAFE(testbuf, "A${NDRX_TX}B${NDRX_TC}Z");
0311     setenv("NDRX_TX", "THIS_HELLO", EXTRUE);
0312     setenv("NDRX_TC", "THIS_WORLD", EXTRUE);
0313     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0314     assert_string_equal(testbuf, "ATHIS_HELLOBTHIS_WORLDZ");
0315
0316     /* value shorter */
0317     NDRX_STRCPY_SAFE(testbuf, "A${NDRX_TX}B${NDRX_TC}Z");
0318     setenv("NDRX_TX", "HELLO", EXTRUE);
0319     setenv("NDRX_TC", "WORLD", EXTRUE);
0320     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0321     assert_string_equal(testbuf, "AHELLOBWORLDZ");
0322
0323     /* check escapes.. */
0324     NDRX_STRCPY_SAFE(testbuf, "A\\${NDRX_TX}B${NDRX_TC}Z");
0325     setenv("NDRX_TX", "HELLO", EXTRUE);
0326     setenv("NDRX_TC", "WORLD", EXTRUE);
0327     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0328     assert_string_equal(testbuf, "A${NDRX_TX}BWORLDZ");
0329
0330     NDRX_STRCPY_SAFE(testbuf, "A\\\\${NDRX_TX}B${NDRX_TC}Z");
0331     setenv("NDRX_TX", "HELLO", EXTRUE);
0332     setenv("NDRX_TC", "WORLD", EXTRUE);
0333     ndrx_str_env_subs_len(testbuf, sizeof(testbuf));
0334     assert_string_equal(testbuf, "A\\HELLOBWORLDZ");
0335
0336
0337 }
0338
0339 /**
0340  * Just get the env.
0341  * @param data1
0342  * @param data2
0343  * @param data3
0344  * @param data4
0345  * @param symbol
0346  * @param outbuf
0347  * @param outbufsz
0348  * @return
0349  */
0350 int test_get_env(void *data1, void *data2, void *data3, void *data4,
0351             char *symbol, char *outbuf, long outbufsz)
0352 {
0353     NDRX_STRCPY_SAFE_DST(outbuf, getenv(symbol), outbufsz);
0354
0355     return EXSUCCEED;
0356 }
0357 /**
0358  * Test environment substitute routines, context
0359  * Bug #452
0360  */
0361 Ensure(test_nstd_env_subs_ctx)
0362 {
0363     char testbuf[32+1];
0364
0365     /* value is changed : (value longer than env var)*/
0366     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0367     setenv("NDRX_TESTXXXX", "DEBUG_MEGA_LONG_TESTZZZ", EXTRUE);
0368
0369     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0370                     test_get_env);
0371
0372     assert_string_equal(testbuf, "DB1_JDBC/DEBUG_MEGA_LONG_TESTZZZ");
0373
0374     /* value longer and no space */
0375     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0376     setenv("NDRX_TESTXXXX", "DEBUG_MEGA_LONG_TESTZZZZ", EXTRUE);
0377     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0378                     test_get_env);
0379     assert_string_equal(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0380
0381     /* value shorter than env var */
0382     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0383     setenv("NDRX_TESTXXXX", "DEBUG", EXTRUE);
0384     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0385                     test_get_env);
0386     assert_string_equal(testbuf, "DB1_JDBC/DEBUG");
0387
0388     /* value equals in len.. */
0389     NDRX_STRCPY_SAFE(testbuf, "DB1_JDBC/${NDRX_TESTXXXX}");
0390     setenv("NDRX_TESTXXXX", "AAAAAAAAAAAAAAAA", EXTRUE);
0391     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0392                     test_get_env);
0393     assert_string_equal(testbuf, "DB1_JDBC/AAAAAAAAAAAAAAAA");
0394
0395     /* value longer than var, two vars */
0396     NDRX_STRCPY_SAFE(testbuf, "A${NDRX_TX}B${NDRX_TC}Z");
0397     setenv("NDRX_TX", "THIS_HELLO", EXTRUE);
0398     setenv("NDRX_TC", "THIS_WORLD", EXTRUE);
0399     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0400                     test_get_env);
0401     assert_string_equal(testbuf, "ATHIS_HELLOBTHIS_WORLDZ");
0402
0403     /* value shorter */
0404     NDRX_STRCPY_SAFE(testbuf, "A${NDRX_TX}B${NDRX_TC}Z");
0405     setenv("NDRX_TX", "HELLO", EXTRUE);
0406     setenv("NDRX_TC", "WORLD", EXTRUE);
0407     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0408                     test_get_env);
0409     assert_string_equal(testbuf, "AHELLOBWORLDZ");
0410
0411     /* check escapes.. */
0412     NDRX_STRCPY_SAFE(testbuf, "A\\${NDRX_TX}B${NDRX_TC}Z");
0413     setenv("NDRX_TX", "HELLO", EXTRUE);
0414     setenv("NDRX_TC", "WORLD", EXTRUE);
0415     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0416                     test_get_env);
0417     assert_string_equal(testbuf, "A${NDRX_TX}BWORLDZ");
0418
0419     NDRX_STRCPY_SAFE(testbuf, "A\\\\${NDRX_TX}B${NDRX_TC}Z");
0420     setenv("NDRX_TX", "HELLO", EXTRUE);
0421     setenv("NDRX_TC", "WORLD", EXTRUE);
0422     ndrx_str_subs_context(testbuf, sizeof(testbuf), '{', '}', NULL, NULL, NULL, NULL,
0423                     test_get_env);
0424     assert_string_equal(testbuf, "A\\HELLOBWORLDZ");
0425 }
0426
0427 /**
0428  * Check the random file name generator
0429  */
0430 Ensure(test_nstd_ndrx_mkstemps)
0431 {
0432     FILE *f;
0433     char templ[128];
0434     char tmp[128];
0435
0436     NDRX_STRCPY_SAFE(templ, "XXXXXX");
0437     assert_equal(ndrx_mkstemps(templ, 1, 0), NULL);
0438     assert_equal(errno, EINVAL);
0439
0440     assert_not_equal((f=ndrx_mkstemps(templ, 0, 0)), NULL);
0441
0442     assert_string_not_equal(templ, "XXXXXX");
0443     ndrx_file_exists(templ);
0444     /* try write */
0445     assert_equal(fprintf(f, "HELLO TEST"), 10);
0446     fclose(f);
0447     assert_equal(unlink(templ), EXSUCCEED);
0448
0449     /* try file file with some extension */
0450     NDRX_STRCPY_SAFE(templ, "temp_compile_XXXXXX.c");
0451     NDRX_LOG(log_info, "0 Got name: [%s]", templ);
0452     assert_not_equal((f=ndrx_mkstemps(templ, 2, 0)), NULL);
0453
0454     NDRX_LOG(log_info, "Got name: [%s]", templ);
0455
0456     /* file open ok */
0457     assert_string_not_equal(templ, "temp_compile_XXXXXX.c");
0458     assert_equal(strlen(templ), strlen("temp_compile_XXXXXX.c"));
0459     /* check the positions... that other parts are OK */
0460     NDRX_LOG(log_debug, "Got templ: [%s]", templ);
0461     NDRX_STRNCPY_EOS(tmp, templ, 13, sizeof(tmp));
0462     assert_string_equal(tmp, "temp_compile_");
0463
0464
0465     NDRX_LOG(log_debug, "Got templ+12: [%s]", templ+19);
0466
0467     NDRX_STRNCPY_EOS(tmp, templ+19, 2, sizeof(tmp));
0468     assert_string_equal(tmp, ".c");
0469     fclose(f);
0470     assert_equal(unlink(templ), EXSUCCEED);
0471
0472     /* check file exists error */
0473     assert_equal((f=ndrx_mkstemps("README", 0, NDRX_STDF_TEST)), NULL);
0474     assert_equal(errno, EEXIST);
0475
0476 }
0477
0478
0479 /**
0480  * Check Enduro/X Stop watch
0481  */
0482 Ensure(test_nstd_stopwatch)
0483 {
0484     ndrx_stopwatch_t w1;
0485     ndrx_stopwatch_t w2;
0486
0487     ndrx_stopwatch_reset(&w1);
0488
0489     /* so set to 5 sec... it will give the seconds T-X milis or seconds */
0490     ndrx_stopwatch_timer_set(&w2, 5000);
0491
0492     while (ndrx_stopwatch_get_delta_sec(&w1) < 5)
0493     {
0494         assert_true(ndrx_stopwatch_get_delta(&w2) < 0);
0495         NDRX_LOG(log_error, "Stopwatch: %ld", ndrx_stopwatch_get_delta(&w2));
0496         sleep(1);
0497     }
0498     /* wait to complete... the timer */
0499     sleep(1);
0500
0501     NDRX_LOG(log_error, "Stopwatch: %ld", ndrx_stopwatch_get_delta(&w2));
0502
0503     assert_true(ndrx_stopwatch_get_delta(&w2) > 0);
0504
0505 }
0506
0507 /**
0508  * Ensure  ndrx_strnlen() correct work
0509  */
0510 Ensure(test_nstd_ndrx_strnlen)
0511 {
0512     char buf[5];
0513
0514     memset(buf, ' ', sizeof(buf));
0515     assert_equal(ndrx_strnlen(buf, sizeof(buf)), sizeof(buf));
0516 }
0517
0518 /**
0519  * Test Enduro/X random generator
0520  */
0521 Ensure(test_nstd_ndrx_rand)
0522 {
0523     ndrx_stopwatch_t w;
0524     int rand1, ok=EXFALSE;
0525     ndrx_stopwatch_reset(&w);
0526
0527     rand1 = ndrx_rand();
0528
0529     /* during 1 sec, there must be different values */
0530     while (ndrx_stopwatch_get_delta_sec(&w)<1)
0531     {
0532         if (rand1!=ndrx_rand())
0533         {
0534             ok=EXTRUE;
0535             break;
0536         }
0537     }
0538
0539     assert_equal(ok, EXTRUE);
0540
0541 }
0542
0543 /**
0544  * check standard string hash
0545  */
0546 Ensure(test_nstd_ndrx_string_hash)
0547 {
0548     string_hash_t *h = NULL;
0549
0550     assert_equal(ndrx_string_hash_get(h, "ABC"), NULL);
0551     assert_not_equal(ndrx_string_hash_add_cnt(&h, "ABC"), NULL);
0552     assert_equal(ndrx_string_hash_get(h, "ABC")->cnt, 1);
0553     assert_not_equal(ndrx_string_hash_add_cnt(&h, "ABC"), NULL);
0554     assert_equal(ndrx_string_hash_get(h, "ABC")->cnt, 2);
0555
0556     ndrx_string_hash_free(h);
0557 }
0558
0559 /**
0560  * Test compare functions of the standard library
0561  */
0562 Ensure(test_nstd_compare)
0563 {
0564     assert_equal(ndrx_compare3(1,1,1,1,1,1), 0);
0565
0566     assert_true(ndrx_compare3(0,1,1,1,1,1)<0);
0567     assert_true(ndrx_compare3(1,1,1,0,1,1)>0);
0568
0569     assert_true(ndrx_compare3(0,0,1,0,1,1)<0);
0570     assert_true(ndrx_compare3(0,1,1,0,0,1)>0);
0571
0572     assert_true(ndrx_compare3(0,0,0,1,0,1)<0);
0573     assert_true(ndrx_compare3(0,0,1,0,0,0)>0);
0574
0575     assert_equal(ndrx_compare4(1,1,1,1, 1,1,1,1), 0);
0576
0577     assert_true(ndrx_compare4(0,1,1,1, 1,1,1,1)<0);
0578     assert_true(ndrx_compare4(1,1,1,1, 0,1,1,1)>0);
0579
0580     assert_true(ndrx_compare4(0,0,1,1, 0,1,1,1)<0);
0581     assert_true(ndrx_compare4(0,1,1,1, 0,0,1,1)>0);
0582
0583     assert_true(ndrx_compare4(0,0,0,1, 0,0,1,1)<0);
0584     assert_true(ndrx_compare4(0,0,1,1, 0,0,0,1)>0);
0585
0586     assert_true(ndrx_compare4(0,0,0,0, 0,0,0,1)<0);
0587     assert_true(ndrx_compare4(0,0,0,1, 0,0,0,0)>0);
0588 }
0589 /**
0590  * Test standard libary, file handling routines
0591  */
0592 Ensure(test_nstd_file_handling)
0593 {
0594     assert_string_equal(ndrx_basename("/some/hello/string"), "string");
0595     assert_string_equal(ndrx_basename("string"), "string");
0596 }
0597
0598 /**
0599  * Test file locking functionality.
0600  * no wait.
0601  */
0602 Ensure(test_nstd_file_lock_nowait)
0603 {
0604     int fd;
0605     pid_t pid;
0606     int status;
0607     int ret;
0608
0609     /* open the file */
0610     open_test_temp("a+");
0611
0612     /* fork the process */
0613     pid = fork();
0614
0615     if (pid==0)
0616     {
0617         /* lock the stuff */
0618         assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXSUCCEED);
0619         /* child */
0620         sleep(3);
0621         /* file handle unlcoked automatically */
0622         assert_equal(ndrx_file_unlock(fileno(M_test_temp_file)), EXSUCCEED);
0623         close_test_temp();
0624         exit(0);
0625     }
0626     else
0627     {
0628         /* let the forked process to run on */
0629         sleep(1);
0630         assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXFAIL);
0631         assert_equal(Nerror, NEBUSY);
0632     }
0633
0634     /* wait for child to complete */
0635     waitpid(pid, &status, 0);
0636
0637     close_test_temp();
0638     remove_test_temp();
0639
0640     /* test system error on bad file handle */
0641     assert_equal(ndrx_file_lock(-1, EXFALSE), EXFAIL);
0642     assert_equal(Nerror, NEUNIX);
0643 }
0644
0645 /**
0646  * file lock with wait
0647  */
0648 Ensure(test_nstd_file_lock_wait)
0649 {
0650     int fd;
0651     ndrx_stopwatch_t w;
0652     pid_t pid;
0653     int status;
0654     int ret;
0655
0656     /* open the file */
0657     open_test_temp("a+");
0658
0659     /* fork the process */
0660     pid = fork();
0661
0662     if (pid==0)
0663     {
0664         /* lock the stuff */
0665         assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXSUCCEED);
0666         /* child */
0667         sleep(3);
0668         /* file handle unlcoked automatically */
0669         assert_equal(ndrx_file_unlock(fileno(M_test_temp_file)), EXSUCCEED);
0670         close_test_temp();
0671         exit(0);
0672     }
0673     else
0674     {
0675         ndrx_stopwatch_reset(&w);
0676
0677         /* let the forked process to run on */
0678         sleep(1);
0679         assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXTRUE), EXSUCCEED);
0680         assert_true(ndrx_stopwatch_get_delta_sec(&w)>=2);
0681     }
0682
0683     /* wait for child to complete */
0684     waitpid(pid, &status, 0);
0685
0686     assert_equal(ndrx_file_unlock(fileno(M_test_temp_file)), EXSUCCEED);
0687     close_test_temp();
0688     remove_test_temp();
0689
0690 }
0691
0692 /**
0693  * Standard library tests
0694  * @return
0695  */
0696 TestSuite *ubf_nstd_util(void)
0697 {
0698     TestSuite *suite = create_test_suite();
0699
0700     add_test(suite, test_nstd_strsep);
0701     add_test(suite, test_nstd_ends_with);
0702     add_test(suite, test_nstd_args);
0703     add_test(suite, test_nstd_env_subs);
0704     add_test(suite, test_nstd_env_subs_ctx);
0705     add_test(suite, test_nstd_file_exists);
0706     add_test(suite, test_nstd_ndrx_mkstemps);
0707     add_test(suite, test_nstd_stopwatch);
0708     add_test(suite, test_nstd_ndrx_strnlen);
0709     add_test(suite, test_nstd_ndrx_rand);
0710     add_test(suite, test_nstd_ndrx_string_hash);
0711     add_test(suite, test_nstd_compare);
0712     add_test(suite, test_nstd_file_handling);
0713     add_test(suite, test_nstd_file_lock_nowait);
0714     add_test(suite, test_nstd_file_lock_wait);
0715
0716
0717     return suite;
0718 }
0719 /* vim: set ts=4 sw=4 et smartindent: */