0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
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
0054
0055 #define OFSZ(s,e) EXOFFSET(s,e), EXELEM_SIZE(s,e)
0056
0057
0058
0059
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
0075
0076 typedef struct ndrx_args_test ndrx_args_test_t;
0077
0078
0079
0080
0081
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
0098
0099
0100
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
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
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
0140 assert_true(ndrx_str_ends_with(test_str, ""));
0141 }
0142
0143
0144
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
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
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
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
0279
0280
0281 Ensure(test_nstd_env_subs)
0282 {
0283 char testbuf[32+1];
0284
0285
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
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
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
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
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
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
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
0341
0342
0343
0344
0345
0346
0347
0348
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
0359
0360
0361 Ensure(test_nstd_env_subs_ctx)
0362 {
0363 char testbuf[32+1];
0364
0365
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
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
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
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
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
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
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
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
0445 assert_equal(fprintf(f, "HELLO TEST"), 10);
0446 fclose(f);
0447 assert_equal(unlink(templ), EXSUCCEED);
0448
0449
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
0457 assert_string_not_equal(templ, "temp_compile_XXXXXX.c");
0458 assert_equal(strlen(templ), strlen("temp_compile_XXXXXX.c"));
0459
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
0473 assert_equal((f=ndrx_mkstemps("README", 0, NDRX_STDF_TEST)), NULL);
0474 assert_equal(errno, EEXIST);
0475
0476 }
0477
0478
0479
0480
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
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
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
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
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
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
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
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
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
0600
0601
0602 Ensure(test_nstd_file_lock_nowait)
0603 {
0604 int fd;
0605 pid_t pid;
0606 int status;
0607 int ret;
0608
0609
0610 open_test_temp("a+");
0611
0612
0613 pid = fork();
0614
0615 if (pid==0)
0616 {
0617
0618 assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXSUCCEED);
0619
0620 sleep(3);
0621
0622 assert_equal(ndrx_file_unlock(fileno(M_test_temp_file)), EXSUCCEED);
0623 close_test_temp();
0624 exit(0);
0625 }
0626 else
0627 {
0628
0629 sleep(1);
0630 assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXFAIL);
0631 assert_equal(Nerror, NEBUSY);
0632 }
0633
0634
0635 waitpid(pid, &status, 0);
0636
0637 close_test_temp();
0638 remove_test_temp();
0639
0640
0641 assert_equal(ndrx_file_lock(-1, EXFALSE), EXFAIL);
0642 assert_equal(Nerror, NEUNIX);
0643 }
0644
0645
0646
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
0657 open_test_temp("a+");
0658
0659
0660 pid = fork();
0661
0662 if (pid==0)
0663 {
0664
0665 assert_equal(ndrx_file_lock(fileno(M_test_temp_file), EXFALSE), EXSUCCEED);
0666
0667 sleep(3);
0668
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
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
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
0694
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