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 <cgreen/cgreen.h>
0038 #include <string.h>
0039 #include <sys/resource.h>
0040
0041 #include <ubf.h>
0042 #include <ndrstandard.h>
0043 #include "test.fd.h"
0044 #include "ubfunit1.h"
0045 #include <ndebug.h>
0046 #include <ubf_int.h>
0047
0048
0049 void delete_fb_test_data(UBFH *p_ub)
0050 {
0051
0052 assert_equal(Bdel(p_ub, T_SHORT_FLD, 0), EXSUCCEED);
0053 assert_equal(Bdel(p_ub, T_LONG_FLD, 0), EXSUCCEED);
0054 assert_equal(Bdel(p_ub, T_CHAR_FLD, 0), EXSUCCEED);
0055 assert_equal(Bdel(p_ub, T_FLOAT_FLD, 0), EXSUCCEED);
0056 assert_equal(Bdel(p_ub, T_DOUBLE_FLD, 0), EXSUCCEED);
0057 assert_equal(Bdel(p_ub, T_STRING_FLD, 0), EXSUCCEED);
0058 assert_equal(Bdel(p_ub, T_CARRAY_FLD, 0), EXSUCCEED);
0059
0060 }
0061
0062 void load_expr_test_data_1(UBFH *p_ub)
0063 {
0064 short s = 102;
0065 long l = 10212312;
0066 char c = 'a';
0067 float f = 127.001;
0068 double d = 12312312.1112;
0069 char carr[] = "CARRAY TEST";
0070 BFLDLEN len = strlen(carr);
0071
0072 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0073 assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0074 assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0075 assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0076 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0077 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0078 assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0079
0080
0081 s = 212;
0082 l = 212;
0083 c = 'b';
0084 f = 12127;
0085 d = 1231232.1;
0086 carr[0] = 'X';
0087 assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 0, (char *)&s, 0), EXSUCCEED);
0088 assert_equal(Bchg(p_ub, T_LONG_2_FLD, 0, (char *)&l, 0), EXSUCCEED);
0089 assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 0, (char *)&c, 0), EXSUCCEED);
0090 assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 0, (char *)&f, 0), EXSUCCEED);
0091 assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 0, (char *)&d, 0), EXSUCCEED);
0092 assert_equal(Bchg(p_ub, T_STRING_2_FLD, 0, (char *)"XTEST STR VAL", 0), EXSUCCEED);
0093 assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 0, (char *)carr, len), EXSUCCEED);
0094 }
0095
0096 void load_expr_test_data_2(UBFH *p_ub)
0097 {
0098 short s = -102;
0099 long l = -10212312;
0100 char c = 't';
0101 float f = -127.001;
0102 double d = -12312312.1112;
0103 char carr[] = "ZARRAY TEST";
0104 BFLDLEN len = strlen(carr);
0105
0106 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0107 assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0108 assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0109 assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0110 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0111 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0112 assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0113
0114
0115 s = -212;
0116 l = -212;
0117 c = 'c';
0118 f = -12127;
0119 d = -1231232.1;
0120 carr[0] = 'Z';
0121 assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 0, (char *)&s, 0), EXSUCCEED);
0122 assert_equal(Bchg(p_ub, T_LONG_2_FLD, 0, (char *)&l, 0), EXSUCCEED);
0123 assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 0, (char *)&c, 0), EXSUCCEED);
0124 assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 0, (char *)&f, 0), EXSUCCEED);
0125 assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 0, (char *)&d, 0), EXSUCCEED);
0126 assert_equal(Bchg(p_ub, T_STRING_2_FLD, 0, (char *)"XTEST STR VAL", 0), EXSUCCEED);
0127 assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 0, (char *)carr, len), EXSUCCEED);
0128 }
0129
0130 Ensure(test_expr_basic)
0131 {
0132 char buf[2048];
0133 UBFH *p_ub = (UBFH *)buf;
0134 char *tree = NULL;
0135
0136
0137 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0138
0139 tree=Bboolco ("2+2*4==10 && 'abc' %% '.bc'");
0140 assert_not_equal(tree, NULL);
0141 assert_equal(Bboolev(NULL, tree), EXFAIL);
0142 Btreefree(tree);
0143
0144
0145 tree=Bboolco ("100+1=='101' || 1==1 || 2==2 || 1 || #");
0146 B_error("Bboolco");
0147 assert_equal(tree, NULL);
0148 assert_equal(Berror, BSYNTAX);
0149
0150 Btreefree(tree);
0151
0152 {
0153 char buf[2048];
0154 strcpy(buf, getenv("FIELDTBLS"));
0155 unsetenv("FIELDTBLS");
0156
0157 tree=Bboolco ("100+1=='101' || 1==1 || 2==2 || 1 || T_STRING_2_FLD %% '58.*'");
0158
0159 B_error("Bboolco");
0160 assert_equal(tree, NULL);
0161 assert_equal(Berror, BFTOPEN);
0162 Btreefree(tree);
0163 setenv("FIELDTBLS", buf, 1);
0164 }
0165
0166
0167 load_field_table();
0168
0169 assert_equal(CBadd(p_ub, T_STRING_2_FLD, "0123456789012345", 0, BFLD_STRING), EXSUCCEED);
0170 assert_equal(CBadd(p_ub, T_CHAR_FLD, "2", 0, BFLD_STRING), EXSUCCEED);
0171 tree=Bboolco ("T_STRING_2_FLD=='0123456789012345' && T_CHAR_FLD==2");
0172 assert_not_equal(tree, NULL);
0173 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0174 Btreefree(tree);
0175
0176
0177 tree=Bboolco ("T_STRING_2_FLD=='0123456789012345' && T_CHAR_FLD==2 && B_AD_FIELDNAME");
0178 assert_equal(tree, NULL);
0179 B_error("Bboolco");
0180 assert_equal(Berror, BBADNAME);
0181 Btreefree(tree);
0182
0183
0184 tree=Bboolco ("!'0'+1==2");
0185 assert_not_equal(tree, NULL);
0186 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0187 Btreefree(tree);
0188
0189
0190
0191
0192
0193
0194 tree=Bboolco ("!T_STRING_2_FLD 0");
0195 assert_equal(tree, NULL);
0196 assert_equal(Berror, BSYNTAX);
0197 Btreefree(tree);
0198
0199 }
0200
0201
0202
0203
0204 Ensure(test_expr_basic_logic)
0205 {
0206 char buf[1024];
0207 UBFH *p_ub = (UBFH *)buf;
0208 char *tree = NULL;
0209 double f;
0210 short s;
0211 double d_large=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0212 float f_large=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0213 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0214 load_field_table();
0215
0216
0217
0218 f = 127.001;
0219 assert_equal(Badd(p_ub, T_STRING_FLD, "TEST STR VAL", 0), EXSUCCEED);
0220 assert_equal(Badd(p_ub, T_DOUBLE_FLD, (char *)&f, 0), EXSUCCEED);
0221
0222 tree=Bboolco ("T_DOUBLE_FLD==127.001 || T_STRING_FLD=='TEST STR VAL'");
0223 assert_not_equal(tree, NULL);
0224 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0225
0226
0227 f = 127.002;
0228 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "TEST STR VAL", 0), EXSUCCEED);
0229 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0230 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0231
0232 f = 127.001;
0233 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "XTEST STR VAL", 0), EXSUCCEED);
0234 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0235 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0236
0237
0238 f = 127.002;
0239 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "XTEST STR VAL", 0), EXSUCCEED);
0240 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0241 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0242 Btreefree(tree);
0243
0244
0245
0246 f = 127.001;
0247 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "TEST STR VAL", 0), EXSUCCEED);
0248 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0249 tree=Bboolco ("T_DOUBLE_FLD==127.001 && T_STRING_FLD=='TEST STR VAL'");
0250 assert_not_equal(tree, NULL);
0251 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0252
0253 f = 127.002;
0254 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0255 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0256
0257 f = 127.001;
0258 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0259 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "XTEST STR VAL", 0), EXSUCCEED);
0260 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0261
0262 f = 127.002;
0263 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&f, 0), EXSUCCEED);
0264 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "XTEST STR VAL", 0), EXSUCCEED);
0265 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0266 Btreefree(tree);
0267
0268
0269 s = 0;
0270 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0271 tree=Bboolco ("T_DOUBLE_FLD || !1");
0272 assert_not_equal(tree, NULL);
0273 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0274
0275 s = 1;
0276 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0277 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0278 Btreefree(tree);
0279
0280 tree=Bboolco ("!1");
0281 assert_not_equal(tree, NULL);
0282 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0283 Btreefree(tree);
0284
0285 s = 0;
0286 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0287 tree=Bboolco ("!T_SHORT_FLD || T_SHORT_FLD");
0288 assert_not_equal(tree, NULL);
0289 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0290 Btreefree(tree);
0291
0292 tree=Bboolco ("!T_SHORT_FLD || !T_SHORT_FLD");
0293 assert_not_equal(tree, NULL);
0294 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0295 Btreefree(tree);
0296
0297
0298
0299 s = 1;
0300
0301 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, "2", 0, BFLD_STRING), EXSUCCEED);
0302 assert_equal(Bdel(p_ub, T_SHORT_FLD, 0), EXSUCCEED);
0303
0304 tree=Bboolco ("((T_CHAR_FLD== '1') || (T_CHAR_FLD == '2') || (T_CHAR_FLD=='3') || (T_CHAR_FLD=='4') || (T_CHAR_FLD=='Y')) && !(T_SHORT_FLD==1)");
0305 assert_not_equal(tree, NULL);
0306 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0307 Btreefree(tree);
0308
0309 tree=Bboolco ("((T_CHAR_FLD== '1') || (T_CHAR_FLD == '2') || (T_CHAR_FLD=='3') || (T_CHAR_FLD=='4') || (T_CHAR_FLD=='Y')) && !(1-2)");
0310 assert_not_equal(tree, NULL);
0311 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0312 Btreefree(tree);
0313
0314 tree=Bboolco ("(!(2-1)+1)==(!(4-3)+1)");
0315 assert_not_equal(tree, NULL);
0316 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0317 Btreefree(tree);
0318
0319 tree=Bboolco ("(4-4)");
0320 assert_not_equal(tree, NULL);
0321 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0322 Btreefree(tree);
0323
0324
0325
0326 tree=Bboolco ("1 ^ 1");
0327 assert_not_equal(tree, NULL);
0328 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0329 Btreefree(tree);
0330
0331 tree=Bboolco ("0 ^ 1");
0332 assert_not_equal(tree, NULL);
0333 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0334 Btreefree(tree);
0335
0336 tree=Bboolco ("1 ^ 0");
0337 assert_not_equal(tree, NULL);
0338 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0339 Btreefree(tree);
0340
0341 tree=Bboolco ("0 ^ 0");
0342 assert_not_equal(tree, NULL);
0343 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0344 Btreefree(tree);
0345
0346
0347 assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f_large, 0), EXSUCCEED);
0348 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d_large, 0), EXSUCCEED);
0349
0350 tree=Bboolco ("T_FLOAT_FLD=='abc'");
0351 assert_not_equal(tree, NULL);
0352 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0353 Btreefree(tree);
0354
0355 tree=Bboolco ("T_DOUBLE_FLD=='abc'");
0356 assert_not_equal(tree, NULL);
0357 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0358 Btreefree(tree);
0359
0360
0361 }
0362
0363
0364
0365 Ensure(test_expr_basic_equality)
0366 {
0367 char buf[1024];
0368 UBFH *p_ub = (UBFH *)buf;
0369 char *tree = NULL;
0370 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0371 load_field_table();
0372
0373
0374 load_expr_test_data_1(p_ub);
0375 tree=Bboolco ("T_SHORT_FLD==102 && T_LONG_FLD==10212312 && T_CHAR_FLD=='a'&&"
0376 "T_FLOAT_FLD-127.001<0.01 && T_FLOAT_2_FLD==12127 && "
0377 "T_DOUBLE_FLD==12312312.1112 && "
0378 "T_STRING_FLD=='TEST STR VAL' && T_CARRAY_FLD=='CARRAY TEST'");
0379 assert_not_equal(tree, NULL);
0380 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0381 load_expr_test_data_2(p_ub);
0382 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0383 Btreefree(tree);
0384
0385 load_expr_test_data_1(p_ub);
0386 tree=Bboolco ("T_SHORT_FLD!=102 || T_LONG_FLD!=10212312 || T_CHAR_FLD!='a'||"
0387 "T_FLOAT_FLD-127.001>=0.01 || T_DOUBLE_FLD!=12312312.1112 || "
0388 "T_DOUBLE_FLD!=12312312.1112 || "
0389 "T_STRING_FLD!='TEST STR VAL' || T_CARRAY_FLD!='CARRAY TEST'");
0390 assert_not_equal(tree, NULL);
0391 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0392 load_expr_test_data_2(p_ub);
0393 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0394 Btreefree(tree);
0395
0396
0397
0398
0399 load_expr_test_data_1(p_ub);
0400 tree=Bboolco ("T_SHORT_FLD %% '1.2' && T_LONG_FLD %% '1021.312' && T_CHAR_FLD %% 'a'&&"
0401 "T_FLOAT_FLD-127.001 %% '0\\.0.*' && T_DOUBLE_FLD %% '12312312.1112' && "
0402 "T_STRING_FLD %% 'TEST STR ...' && T_CARRAY_FLD %% 'CA..AY TEST'");
0403 assert_equal(tree, NULL);
0404 assert_equal(Berror, BSYNTAX);
0405
0406 tree=Bboolco ("T_SHORT_FLD %% '1.2' && T_LONG_FLD %% '1021.312' && T_CHAR_FLD %% 'a'&&"
0407 "T_FLOAT_FLD %% '127.*' && T_DOUBLE_FLD %% '12312312\\.111.*' && "
0408 "T_STRING_FLD %% 'TEST STR ...' && T_CARRAY_FLD %% 'CA..AY TEST'");
0409 assert_not_equal(tree, NULL);
0410
0411 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0412 load_expr_test_data_2(p_ub);
0413
0414 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0415 Btreefree(tree);
0416
0417
0418 load_expr_test_data_1(p_ub);
0419 tree=Bboolco ("T_SHORT_FLD %% '((((())))(()()\\9\12\1\\3\1((('");
0420 assert_not_equal(tree, NULL);
0421 assert_not_equal(Berror, BSYNTAX);
0422
0423 assert_equal(Bboolev(p_ub, tree), EXFAIL);
0424 assert_equal(Berror, BSYNTAX);
0425 Btreefree(tree);
0426
0427
0428
0429 tree=Bboolco ("T_SHORT_FLD !% '1.2' || T_LONG_FLD !% '1021.312' || T_CHAR_FLD !% 'a'||"
0430 "T_FLOAT_FLD !% '127.*' || T_DOUBLE_FLD !% '12312312\\.111.*' || "
0431 "T_STRING_FLD !% 'TEST STR ...' || T_CARRAY_FLD !% 'CA..AY TEST'");
0432 assert_not_equal(tree, NULL);
0433
0434
0435 load_expr_test_data_1(p_ub);
0436 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0437 load_expr_test_data_2(p_ub);
0438
0439 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0440
0441 Btreefree(tree);
0442
0443
0444 tree=Bboolco ("(T_STRING_9_FLD %% '79.*') || (T_STRING_10_FLD %% '79.*') || (T_STRING_FLD %% '79.*')");
0445 assert_not_equal(tree, NULL);
0446
0447
0448 load_expr_test_data_1(p_ub);
0449 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0450
0451 Btreefree(tree);
0452
0453
0454
0455
0456 tree=Bboolco ("T_SHORT_FLD==T_SHORT_FLD && T_LONG_FLD==T_LONG_FLD && T_CHAR_FLD==T_CHAR_FLD&&"
0457 "T_FLOAT_FLD==T_FLOAT_FLD && T_DOUBLE_FLD==T_DOUBLE_FLD && "
0458 "T_STRING_FLD==T_STRING_FLD && T_CARRAY_FLD==T_CARRAY_FLD");
0459 assert_not_equal(tree, NULL);
0460
0461
0462 load_expr_test_data_1(p_ub);
0463 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0464 load_expr_test_data_2(p_ub);
0465 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0466 Btreefree(tree);
0467
0468
0469 tree=Bboolco ("T_STRING_FLD=='0'");
0470 assert_not_equal(tree, NULL);
0471
0472 while (Bpres(p_ub, T_STRING_FLD, 0))
0473 Bdel(p_ub, T_STRING_FLD, 0);
0474
0475 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0476
0477 Btreefree(tree);
0478
0479
0480 }
0481
0482
0483
0484
0485
0486 Ensure(test_expr_basic_unary)
0487 {
0488 char buf[1024];
0489 UBFH *p_ub = (UBFH *)buf;
0490 char *tree = NULL;
0491 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0492 long test_long;
0493 load_field_table();
0494
0495
0496
0497 load_expr_test_data_1(p_ub);
0498 tree=Bboolco ("-T_SHORT_FLD==0-102 && -T_LONG_FLD==0-10212312 && -T_CHAR_FLD==0 &&"
0499 "-T_FLOAT_FLD<-126.001 && -T_DOUBLE_FLD==0-12312312.1112 && "
0500 "-T_STRING_FLD==0 && -T_CARRAY_FLD==0 && -1==0-1 && -1.0==0-1");
0501 assert_not_equal(tree, NULL);
0502 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0503 load_expr_test_data_2(p_ub);
0504 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0505 Btreefree(tree);
0506
0507
0508 load_expr_test_data_1(p_ub);
0509 tree=Bboolco ("+T_SHORT_FLD==+102 && +T_LONG_FLD==10212312 && +T_CHAR_FLD==0 &&"
0510 "+T_FLOAT_FLD>=126.001 && T_FLOAT_2_FLD==12127 && +T_DOUBLE_FLD==+12312312.1112 && "
0511 "+T_STRING_FLD==0 && +T_CARRAY_FLD==0");
0512 assert_not_equal(tree, NULL);
0513 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0514 load_expr_test_data_2(p_ub);
0515 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0516 Btreefree(tree);
0517
0518
0519 load_expr_test_data_1(p_ub);
0520
0521 delete_fb_test_data(p_ub);
0522 tree=Bboolco ("!T_SHORT_FLD && !T_LONG_FLD && !T_CHAR_FLD &&"
0523 "!T_FLOAT_FLD && !T_DOUBLE_FLD && "
0524 "!T_STRING_FLD && !T_CARRAY_FLD && !0 && !(!'0') && !0.0");
0525 assert_not_equal(tree, NULL);
0526 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0527
0528 load_expr_test_data_1(p_ub);
0529 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0530 Btreefree(tree);
0531
0532
0533 load_expr_test_data_1(p_ub);
0534 tree=Bboolco ("~T_SHORT_FLD==-2 && ~T_LONG_FLD==-2 && ~T_CHAR_FLD==-2 &&"
0535 "~T_FLOAT_FLD==-2 && ~T_DOUBLE_FLD==-2 && "
0536 "~T_STRING_FLD==-2 && ~T_CARRAY_FLD==-2 && ~0==-1 && ~'0'==-2 && ~0.0==-1");
0537 assert_not_equal(tree, NULL);
0538 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0539
0540 test_long = 0;
0541 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&test_long, 0, BFLD_LONG), EXSUCCEED);
0542 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0543 Btreefree(tree);
0544 }
0545
0546
0547
0548 Ensure(test_expr_basic_additive)
0549 {
0550 char buf[1024];
0551 UBFH *p_ub = (UBFH *)buf;
0552 char *tree = NULL;
0553 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0554 double d = 2312.2;
0555 int big_test;
0556 load_field_table();
0557
0558
0559
0560
0561
0562
0563
0564
0565
0566
0567
0568 tree=Bboolco ("100+100==200 && 100.51+100.49==201 && '123'+'123'==246 &&"
0569 "T_SHORT_FLD+50==152 && T_SHORT_FLD+50==152.0 && "
0570 "T_SHORT_FLD+50.1==152.1 && T_LONG_FLD+1==10212313 &&"
0571 "T_LONG_FLD+1.1==10212313+0.1 && T_FLOAT_2_FLD+3==12130 &&"
0572 "T_CHAR_FLD+1==9 && T_CHAR_FLD+0.1==8.1 && "
0573 "T_CHAR_FLD+'1'==9 && T_CHAR_FLD+'0.1'==8+0.1 &&"
0574 "T_CHAR_FLD+'1'=='5'+'4' &&"
0575 "T_FLOAT_2_FLD+3.0==12130 && T_FLOAT_2_FLD+'3.0'==12130 && "
0576 "T_FLOAT_2_FLD+'3'==12130 && T_FLOAT_2_FLD+'4'==12130.0+1 &&"
0577 "T_DOUBLE_FLD+1==2313.2 && T_DOUBLE_FLD+'1'==2313.2 &&"
0578 "T_DOUBLE_FLD+1.0=='2313.2'+0.1-0.1 &&"
0579 "T_STRING_FLD+1==145 && T_STRING_FLD+0.1==144.1 && "
0580 "T_STRING_FLD+'1'==145 && T_STRING_FLD+'0.1'==144+0.1 &&"
0581 "T_STRING_FLD+'1'=='100'+'45' &&"
0582 "T_CARRAY_FLD+1==245 && T_CARRAY_FLD+0.1==244.1 && "
0583 "T_CARRAY_FLD+'1'==245 && T_CARRAY_FLD+'0.1'==244+0.1 &&"
0584 "T_CARRAY_FLD+'1'=='200'+'45'");
0585 assert_not_equal(tree, NULL);
0586 #if UBF_BIG_TEST
0587 for (big_test=0; big_test<50; big_test++)
0588 {
0589 #endif
0590 load_expr_test_data_1(p_ub);
0591
0592 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0593 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"144", 0), EXSUCCEED);
0594 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"244", 3, BFLD_STRING), EXSUCCEED);
0595 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"8", 3, BFLD_STRING), EXSUCCEED);
0596
0597 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0598 load_expr_test_data_2(p_ub);
0599 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0600 #if UBF_BIG_TEST
0601 }
0602 #endif
0603 Btreefree(tree);
0604
0605
0606 load_expr_test_data_1(p_ub);
0607
0608 assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0609 assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"144", 0), EXSUCCEED);
0610 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"-244", 3, BFLD_STRING), EXSUCCEED);
0611 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"8", 3, BFLD_STRING), EXSUCCEED);
0612
0613
0614
0615
0616
0617
0618
0619
0620
0621 tree=Bboolco ("100-100==0 && 100.51-100.49==0.02 && '123'-'126'==-3 && "
0622 "50-T_SHORT_FLD==-52 && 50-T_SHORT_FLD==-52.0 && "
0623 "T_SHORT_FLD-50.1==51.9 && 1-T_LONG_FLD==-10212311 &&"
0624 "-T_LONG_FLD+1.1==-10212310.9 && T_LONG_FLD-1==10212311 &&"
0625 "1-T_CHAR_FLD==-7 && T_CHAR_FLD-0.1==7.9 && "
0626 "T_CHAR_FLD-'1'==7 && T_CHAR_FLD-'0.1'==8-0.1 &&"
0627 "T_CHAR_FLD-'1'=='5'+'5'-3 && T_FLOAT_2_FLD-2==12125 &&"
0628 "T_FLOAT_2_FLD-3.0==12124 && -T_FLOAT_2_FLD-'3.0'==-12130 && "
0629 "T_FLOAT_2_FLD-'3'==12124 && T_FLOAT_2_FLD-'4'==12123+1-1 &&"
0630 "T_DOUBLE_FLD-1==2311.2 && T_DOUBLE_FLD-'1'==2311.2 &&"
0631 "T_DOUBLE_FLD-1.2=='2311'+0.1-0.1 &&"
0632 "T_STRING_FLD-3==141 && 0.3-T_STRING_FLD==-143.7 && "
0633 "T_STRING_FLD-'3'==141 && T_STRING_FLD-'0.3'==143.7 &&"
0634 "T_STRING_FLD-'3'=='141'+4-'4' &&"
0635 "T_CARRAY_FLD-5==-249 && T_CARRAY_FLD-0.5==-244.5 && "
0636 "-T_CARRAY_FLD+'5'==+249 && T_CARRAY_FLD-'0.5'==-244-0.5 &&"
0637 "T_CARRAY_FLD-'5'=='-244'-'5'");
0638
0639 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0640 load_expr_test_data_2(p_ub);
0641 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0642 Btreefree(tree);
0643 }
0644
0645
0646
0647
0648 Ensure(test_expr_basic_multiplicative)
0649 {
0650 char buf[1024];
0651 UBFH *p_ub = (UBFH *)buf;
0652 char *tree = NULL;
0653 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0654 double d = 2312.2;
0655 int big_test;
0656 load_field_table();
0657
0658
0659
0660
0661
0662
0663
0664
0665
0666
0667 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"257", 3, BFLD_STRING), EXSUCCEED);
0668 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-8941", 3, BFLD_STRING), EXSUCCEED);
0669 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
0670 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
0671 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"887441", 3, BFLD_STRING), EXSUCCEED);
0672 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"448.33", 3, BFLD_STRING), EXSUCCEED);
0673 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"55412.11", 3, BFLD_STRING), EXSUCCEED);
0674
0675 tree=Bboolco ("100*100==10000 && 100.51*1.49==149.7599 && '123'*'13'==1599 && -1*-1==1 &&"
0676 "1285==T_SHORT_FLD*5 && 1310.7==T_SHORT_FLD*5.1 && "
0677 "'1.1'*T_SHORT_FLD==282.7 && T_LONG_FLD*3==-26823 &&"
0678 "-T_LONG_FLD*'1.1'==8941*1.1 && T_LONG_FLD*1.1==-8941*1.1 && "
0679 "T_FLOAT_2_FLD*23==-4.6 &&"
0680 "T_CHAR_FLD*2==4 && T_CHAR_FLD*0.3==0.6 && "
0681 "T_CHAR_FLD*'4'==8 && T_CHAR_FLD*'0.3'==2*0.3 &&"
0682 "T_CHAR_FLD*'3'==2+'4' &&"
0683 "T_FLOAT_2_FLD*3.0==-0.6 && -T_FLOAT_2_FLD*'3.0'==0.6 && "
0684 "T_FLOAT_2_FLD*'3'==-0.6 && T_FLOAT_2_FLD*'4'==-0.8 &&"
0685 "T_DOUBLE_FLD*3==2662323 && T_DOUBLE_FLD*'2'==1774882 &&"
0686 "T_DOUBLE_FLD*1.5=='1331161.5'+0 &&"
0687 "T_STRING_FLD*3==1344.99 && T_STRING_FLD*0.3==134.499 && "
0688 "T_STRING_FLD*'3'==1344.99 && T_STRING_FLD*'0.7'==313.831 &&"
0689 "T_STRING_FLD*'3'==1344 + 0.99 &&"
0690 "T_CARRAY_FLD*0.7==38788.477 && T_CARRAY_FLD*0.7==38788.477 && "
0691 "T_CARRAY_FLD*'0.7'==38788.477 && 38788.477==T_CARRAY_FLD*'0.7' &&"
0692 "T_CARRAY_FLD*'0.7'==('38788.477'/0.7)*0.7 &&"
0693 "T_SHORT_FLD %% '257.*'");
0694 assert_not_equal(tree, NULL);
0695 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0696 load_expr_test_data_2(p_ub);
0697
0698 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0699 Btreefree(tree);
0700
0701
0702 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
0703 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
0704 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
0705 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
0706 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
0707 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
0708 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"80.4", 3, BFLD_STRING), EXSUCCEED);
0709
0710 tree=Bboolco ("100/100==1 && 100.10/2==50.05 "
0711 "&& '122'/'2'==61 "
0712 "&& -3/-3==1"
0713 "&& T_SHORT_FLD/2==252/2"
0714 "&& 63==T_SHORT_FLD/4"
0715 "&& '504'/T_SHORT_FLD==2.0 "
0716
0717 "&& T_LONG_FLD/5==-2980/5"
0718 "&& -T_LONG_FLD/-2980==-1"
0719 "&& T_LONG_FLD/4.0==-745"
0720
0721 "&& T_CHAR_FLD/2==1 "
0722 "&& T_CHAR_FLD/2==1.0"
0723 "&& T_CHAR_FLD/'1'=='2.0'-0"
0724 "&& T_CHAR_FLD/'0.2'==10"
0725 "&& T_CHAR_FLD/'2'==0+1"
0726
0727 "&& T_FLOAT_2_FLD/2.0==-0.1 "
0728 "&& '4.0'/-T_FLOAT_2_FLD==20"
0729 "&& '0.4'/T_FLOAT_2_FLD==-2 "
0730 "&& T_FLOAT_2_FLD/'4'==-0.05"
0731
0732 "&& T_DOUBLE_FLD/2==21 "
0733 "&& T_DOUBLE_FLD/'1'==42"
0734 "&& T_DOUBLE_FLD/1.5=='28'+0"
0735
0736 "&& T_STRING_FLD/3==22 "
0737 "&& 220==T_STRING_FLD/0.3"
0738 "&& T_STRING_FLD/'3'==22.00"
0739 "&& T_STRING_FLD/'0.5'==132"
0740 "&& T_STRING_FLD/'3'==21.5 + 0.5"
0741
0742 "&& T_CARRAY_FLD/0.2==402"
0743 "&& T_CARRAY_FLD/0.2==402.00"
0744 "&& T_CARRAY_FLD/'2'==40.2"
0745 "&& 16.08==T_CARRAY_FLD/'5'"
0746 "&& T_CARRAY_FLD/'4'==20.1000"
0747 );
0748 assert_not_equal(tree, NULL);
0749 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0750 load_expr_test_data_2(p_ub);
0751 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0752 Btreefree(tree);
0753
0754 tree=Bboolco ("100/0==0");
0755 assert_not_equal(tree, NULL);
0756 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0757 Btreefree(tree);
0758
0759
0760
0761 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
0762 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
0763 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"7", 3, BFLD_STRING), EXSUCCEED);
0764 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"14", 3, BFLD_STRING), EXSUCCEED);
0765 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
0766 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
0767 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"80.4", 3, BFLD_STRING), EXSUCCEED);
0768
0769 tree=Bboolco ("100 % 97==3"
0770 "&& 10 % 3==1 "
0771 "&& 2.9%'3.0'==2"
0772 "&& '8' % '7'==1 "
0773 "&& -2 %-3==-2"
0774 "&& T_SHORT_FLD%200==52"
0775 "&& 52.00==T_SHORT_FLD%200"
0776 "&& '504'%T_SHORT_FLD==0"
0777
0778 "&& T_LONG_FLD % 5 ==-2980%5"
0779 "&& T_LONG_FLD % -3000 == -2980"
0780 "&& T_LONG_FLD % 1== 0"
0781
0782 "&& T_CHAR_FLD%2==1 "
0783 "&& T_CHAR_FLD%5==2.0"
0784 "&& T_CHAR_FLD%'5'=='2.0'-0"
0785 "&& T_CHAR_FLD%'0.2'==7"
0786 "&& T_CHAR_FLD%'2'==0+1"
0787
0788 "&& T_FLOAT_2_FLD%2.0==0.0 "
0789 "&& '4.0'%-T_FLOAT_2_FLD==4"
0790 "&& '0.4'%T_FLOAT_2_FLD==0"
0791 "&& T_FLOAT_2_FLD%'4'==2.00"
0792
0793 "&& T_DOUBLE_FLD%5.5==2"
0794 "&& T_DOUBLE_FLD%'1'==0"
0795 "&& T_DOUBLE_FLD%1.5=='0'+0"
0796
0797 "&& T_STRING_FLD%3==0"
0798 "&& 66==T_STRING_FLD%0.3"
0799 "&& T_STRING_FLD%'3'==0"
0800 "&& T_STRING_FLD%'0.5'==66"
0801 "&& T_STRING_FLD%'8'==2"
0802
0803 "&& T_CARRAY_FLD%8==0"
0804 "&& T_CARRAY_FLD%4.2==0.00"
0805 "&& T_CARRAY_FLD%'7'==3"
0806 "&& 8.00==T_CARRAY_FLD%'12'"
0807 "&& T_CARRAY_FLD%'100'==80"
0808 );
0809 assert_not_equal(tree, NULL);
0810 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0811 load_expr_test_data_2(p_ub);
0812 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0813 Btreefree(tree);
0814 }
0815
0816
0817
0818
0819 Ensure(test_expr_basic_floatev)
0820 {
0821 char buf[1024];
0822 UBFH *p_ub = (UBFH *)buf;
0823 char *tree = NULL;
0824 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0825 load_field_table();
0826
0827
0828 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
0829 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
0830 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"7", 3, BFLD_STRING), EXSUCCEED);
0831 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"14", 3, BFLD_STRING), EXSUCCEED);
0832 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
0833 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"abc", 3, BFLD_STRING), EXSUCCEED);
0834 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"80.4", 3, BFLD_STRING), EXSUCCEED);
0835
0836 tree=Bboolco ("100 % 97");
0837 assert_not_equal(tree, NULL);
0838 assert_equal(Bfloatev(p_ub, tree), 3.0);
0839 Btreefree(tree);
0840
0841 tree=Bboolco ("10/3");
0842 assert_not_equal(tree, NULL);
0843 assert_true(Bfloatev(p_ub, tree)>1.3);
0844 Btreefree(tree);
0845
0846 tree=Bboolco ("10*3");
0847 assert_not_equal(tree, NULL);
0848 assert_equal(Bfloatev(p_ub, tree), 30);
0849 Btreefree(tree);
0850
0851 tree=Bboolco ("0.9+19.1");
0852 assert_not_equal(tree, NULL);
0853 assert_equal(Bfloatev(p_ub, tree), 20);
0854 Btreefree(tree);
0855
0856 tree=Bboolco ("'9'-'a'");
0857 assert_not_equal(tree, NULL);
0858 assert_equal(Bfloatev(p_ub, tree), 9);
0859 Btreefree(tree);
0860
0861 tree=Bboolco ("'9'-'4'");
0862 assert_not_equal(tree, NULL);
0863 assert_equal(Bfloatev(p_ub, tree), 5);
0864 Btreefree(tree);
0865
0866 tree=Bboolco ("T_CARRAY_FLD-0.4");
0867 assert_not_equal(tree, NULL);
0868 assert_equal(Bfloatev(p_ub, tree), 80);
0869 Btreefree(tree);
0870
0871 tree=Bboolco ("T_CARRAY_FLD");
0872 assert_not_equal(tree, NULL);
0873 assert_equal(Bfloatev(p_ub, tree), 80.4);
0874 Btreefree(tree);
0875
0876 tree=Bboolco ("!T_CARRAY_FLD");
0877 assert_not_equal(tree, NULL);
0878 assert_equal(Bfloatev(p_ub, tree), 0);
0879 Btreefree(tree);
0880
0881 tree=Bboolco ("!(!T_CARRAY_FLD)");
0882 assert_not_equal(tree, NULL);
0883 assert_equal(Bfloatev(p_ub, tree), 1);
0884 Btreefree(tree);
0885
0886 tree=Bboolco ("T_STRING_FLD");
0887 assert_not_equal(tree, NULL);
0888 assert_equal(Bfloatev(p_ub, tree), 0);
0889 Btreefree(tree);
0890
0891 tree=Bboolco ("T_STRING_FLD=='abc'");
0892 assert_not_equal(tree, NULL);
0893 assert_equal(Bfloatev(p_ub, tree), 1);
0894 Btreefree(tree);
0895
0896 tree=Bboolco ("T_DOUBLE_FLD");
0897 assert_not_equal(tree, NULL);
0898 assert_double_equal(Bfloatev(p_ub, tree), 42);
0899 Btreefree(tree);
0900
0901 tree=Bboolco ("T_LONG_FLD");
0902 assert_not_equal(tree, NULL);
0903 assert_double_equal(Bfloatev(p_ub, tree), -2980);
0904 Btreefree(tree);
0905
0906 }
0907
0908
0909
0910
0911 Ensure(test_expr_basic_relational)
0912 {
0913 char buf[1024];
0914 UBFH *p_ub = (UBFH *)buf;
0915 char *tree = NULL;
0916 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0917 double d = 2312.2;
0918 int big_test;
0919 load_field_table();
0920
0921
0922 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
0923 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
0924 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
0925 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
0926 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
0927 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
0928 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"80.4", 3, BFLD_STRING), EXSUCCEED);
0929
0930 tree=Bboolco ("10<100 "
0931 "&& 100.10/2<51.05 "
0932 "&& '2'<'322' "
0933 "&& -3<3"
0934 "&& '1'<'a'"
0935
0936 "&& T_SHORT_FLD<300"
0937 "&& T_SHORT_FLD<300.01"
0938 "&& T_SHORT_FLD<'252'+1"
0939 "&& !(T_SHORT_FLD<50) "
0940
0941 "&& T_LONG_FLD<'-4000'"
0942 "&& 100 < -T_LONG_FLD"
0943 "&& T_LONG_FLD<'123'"
0944
0945 "&& !(T_CHAR_FLD<1) "
0946 "&& T_CHAR_FLD<'a'"
0947 "&& T_CHAR_FLD<2.5"
0948 "&& T_CHAR_FLD<'a'+3"
0949
0950 "&& T_FLOAT_2_FLD < 12"
0951 "&& -0.2 < -T_FLOAT_2_FLD"
0952 "&& !(T_FLOAT_2_FLD < -12.121)"
0953 "&& -0.4 < T_FLOAT_2_FLD"
0954
0955 "&& T_DOUBLE_FLD < 50"
0956 "&& 30.1< T_DOUBLE_FLD"
0957 "&& T_DOUBLE_FLD < 'abc'"
0958
0959 "&& T_STRING_FLD < 77"
0960 "&& 40.01 < T_STRING_FLD"
0961 "&& T_STRING_FLD < 'abc'"
0962 "&& '0667' < T_STRING_FLD"
0963 "&& T_STRING_FLD < 100-40+55.6"
0964
0965 "&& T_CARRAY_FLD < 100"
0966 "&& !(80.45 < T_CARRAY_FLD)"
0967 "&& T_CARRAY_FLD < 'abc'"
0968 "&& '00008000.40' < T_CARRAY_FLD"
0969 "&& T_CARRAY_FLD < 80.4445"
0970 );
0971 assert_not_equal(tree, NULL);
0972 assert_equal(Bboolev(p_ub, tree), EXTRUE);
0973 load_expr_test_data_2(p_ub);
0974 assert_equal(Bboolev(p_ub, tree), EXFALSE);
0975 Btreefree(tree);
0976
0977
0978
0979 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
0980 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
0981 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
0982 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
0983 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
0984 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
0985 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"80.4", 3, BFLD_STRING), EXSUCCEED);
0986
0987 tree=Bboolco ("100>10 "
0988 "&& 51.05>100.10/2 "
0989 "&& '322'>'2' "
0990 "&& 3>-3"
0991 "&& 'a'>'1'"
0992
0993 "&& 300>T_SHORT_FLD"
0994 "&& 300.01>T_SHORT_FLD"
0995 "&& '252'+1>T_SHORT_FLD"
0996 "&& !(50>T_SHORT_FLD) "
0997
0998 "&& '-4000'>T_LONG_FLD"
0999 "&& -T_LONG_FLD>100 "
1000 "&& '123'>T_LONG_FLD"
1001
1002 "&& !(1>T_CHAR_FLD) "
1003 "&& 'a'>T_CHAR_FLD"
1004 "&& 2.5>T_CHAR_FLD"
1005 "&& 'a'+3>T_CHAR_FLD"
1006
1007 "&& !(-0.3>T_FLOAT_2_FLD)"
1008 "&& -T_FLOAT_2_FLD > -0.2"
1009 "&& 12.121 > T_FLOAT_2_FLD"
1010 "&& T_FLOAT_2_FLD > -0.4"
1011
1012 "&& 50 > T_DOUBLE_FLD"
1013 "&& !(T_DOUBLE_FLD > 50.1)"
1014 "&& 'abc' > T_DOUBLE_FLD"
1015
1016 "&& 77 > T_STRING_FLD"
1017 "&& !(T_STRING_FLD > 75.01)"
1018 "&& 'abc' > T_STRING_FLD"
1019 "&& 'T_STRING_FLD > 0667'"
1020 "&& 100-40+55.6 > T_STRING_FLD"
1021
1022 "&& 100 > T_CARRAY_FLD"
1023 "&& !(T_CARRAY_FLD > 80.445)"
1024 "&& 'abc' > T_CARRAY_FLD"
1025 "&& T_CARRAY_FLD>'00008000.40'"
1026 "&& 80.4445>T_CARRAY_FLD"
1027 );
1028 assert_not_equal(tree, NULL);
1029 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1030 load_expr_test_data_2(p_ub);
1031 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1032 Btreefree(tree);
1033
1034
1035
1036
1037 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
1038 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
1039 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
1040 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
1041 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
1042 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
1043 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"abc", 3, BFLD_STRING), EXSUCCEED);
1044
1045 tree=Bboolco ("100<=100 "
1046 "&& 100.10/2<=51.05 "
1047 "&& '321'<='322' "
1048 "&& -3<=3"
1049 "&& 'a'<='a'"
1050
1051 "&& T_SHORT_FLD<=252"
1052 "&& T_SHORT_FLD<=252.1"
1053 "&& T_SHORT_FLD<='251'+1"
1054 "&& !(T_SHORT_FLD<=251) "
1055
1056 "&& T_LONG_FLD<='-2980'"
1057 "&& 100 <= -T_LONG_FLD"
1058 "&& T_LONG_FLD<='123'"
1059
1060 "&& !(T_CHAR_FLD<=1) "
1061 "&& T_CHAR_FLD<='a'"
1062 "&& T_CHAR_FLD<=2.5"
1063 "&& T_CHAR_FLD<='a'+2"
1064
1065 "&& T_FLOAT_2_FLD <= -0.2"
1066 "&& 0.2 <= -T_FLOAT_2_FLD"
1067 "&& !(T_FLOAT_2_FLD <= -12.121)"
1068 "&& -0.4 <= T_FLOAT_2_FLD"
1069
1070 "&& T_DOUBLE_FLD <= '42.0000000000000'"
1071 "&& !(42.1<= T_DOUBLE_FLD)"
1072 "&& T_DOUBLE_FLD <= 'abc'"
1073
1074 "&& T_STRING_FLD <= 66"
1075 "&& 40.01 <= T_STRING_FLD"
1076 "&& !(667 <= T_STRING_FLD)"
1077 "&& '0667' <= T_STRING_FLD"
1078 "&& T_STRING_FLD <= 100-40+55.6"
1079
1080 "&& T_CARRAY_FLD <= 0"
1081 "&& !(10 <= T_CARRAY_FLD)"
1082 "&& T_CARRAY_FLD <= 'abc'"
1083 "&& -0.1 <= T_CARRAY_FLD"
1084 "&& T_CARRAY_FLD <= 3"
1085 );
1086 assert_not_equal(tree, NULL);
1087 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1088 load_expr_test_data_2(p_ub);
1089 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1090 Btreefree(tree);
1091
1092
1093 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"252", 3, BFLD_STRING), EXSUCCEED);
1094 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"-2980", 3, BFLD_STRING), EXSUCCEED);
1095 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"2", 3, BFLD_STRING), EXSUCCEED);
1096 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-0.2", 3, BFLD_STRING), EXSUCCEED);
1097 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"42", 3, BFLD_STRING), EXSUCCEED);
1098 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"66", 3, BFLD_STRING), EXSUCCEED);
1099 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"abc", 3, BFLD_STRING), EXSUCCEED);
1100
1101 tree=Bboolco ("100>=100 "
1102 "&& 51.05>=100.10/2 "
1103 "&& '322'>='321'"
1104 "&& 3>=-3"
1105 "&& 'a'>='a'"
1106
1107 "&& 252>=T_SHORT_FLD"
1108 "&& 252.1>=T_SHORT_FLD"
1109 "&& '251'+1>=T_SHORT_FLD"
1110 "&& !(251>=T_SHORT_FLD) "
1111
1112 "&& '-2980'>=T_LONG_FLD"
1113 "&& -T_LONG_FLD>=100"
1114 "&& '123'>=T_LONG_FLD"
1115
1116 "&& !(1>=T_CHAR_FLD) "
1117 "&& 'a'>=T_CHAR_FLD"
1118 "&& 2.5>=T_CHAR_FLD"
1119 "&& 'a'+2>=T_CHAR_FLD"
1120
1121 "&& -0.2>=T_FLOAT_2_FLD"
1122 "&& -T_FLOAT_2_FLD>=0.2"
1123 "&& !(-12.121>=T_FLOAT_2_FLD)"
1124 "&& T_FLOAT_2_FLD>=-0.4"
1125
1126 "&& '42.0000000000000'>=T_DOUBLE_FLD"
1127 "&& !(T_DOUBLE_FLD>=42.1)"
1128 "&& 'abc'>=T_DOUBLE_FLD"
1129
1130 "&& 66>=T_STRING_FLD"
1131 "&& T_STRING_FLD>=40.01"
1132 "&& !(T_STRING_FLD>=667)"
1133 "&& T_STRING_FLD>='0667'"
1134 "&& 100-40+55.6>=T_STRING_FLD"
1135
1136 "&& 0>=T_CARRAY_FLD"
1137 "&& !(T_CARRAY_FLD>=10)"
1138 "&& 'abc'>=T_CARRAY_FLD"
1139 "&& T_CARRAY_FLD>=-0.1"
1140 "&& 3>=T_CARRAY_FLD"
1141 );
1142 assert_not_equal(tree, NULL);
1143 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1144 load_expr_test_data_2(p_ub);
1145 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1146 Btreefree(tree);
1147
1148
1149 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"12311", 3, BFLD_STRING), EXSUCCEED);
1150 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"558211", 3, BFLD_STRING), EXSUCCEED);
1151 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"6", 3, BFLD_STRING), EXSUCCEED);
1152 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-10", 3, BFLD_STRING), EXSUCCEED);
1153 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"12.5", 3, BFLD_STRING), EXSUCCEED);
1154 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"7721", 3, BFLD_STRING), EXSUCCEED);
1155 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"12a", 3, BFLD_STRING), EXSUCCEED);
1156
1157 tree=Bboolco ("100==100 "
1158 "&& !(51.05==100.10/2) "
1159 "&& '322'=='322'"
1160 "&& !(3==-3)"
1161 "&& 'a'=='a'"
1162 "&& 155.12==155.12-0.12+0.12"
1163
1164 "&& T_SHORT_FLD==T_SHORT_FLD"
1165 "&& 12311==T_SHORT_FLD"
1166 "&& !(12312==T_SHORT_FLD)"
1167 "&& '12311'==T_SHORT_FLD"
1168 "&& !(1231==T_SHORT_FLD) "
1169
1170 "&& '-558211'==-T_LONG_FLD"
1171 "&& !(-T_LONG_FLD==100)"
1172 "&& 558211==T_LONG_FLD"
1173 "&& T_LONG_FLD==T_LONG_FLD"
1174
1175 "&& T_CHAR_FLD==T_CHAR_FLD"
1176 "&& T_CHAR_FLD+T_CHAR_FLD==T_CHAR_FLD*2"
1177 "&& !(5==T_CHAR_FLD)"
1178 "&& '6'==T_CHAR_FLD"
1179 "&& 6.0==T_CHAR_FLD"
1180 "&& 6==T_CHAR_FLD"
1181
1182 "&& T_FLOAT_2_FLD==T_FLOAT_2_FLD"
1183 "&& -10==T_FLOAT_2_FLD"
1184 "&& !(-T_FLOAT_2_FLD==-0.1)"
1185 "&& !(-12.121==T_FLOAT_2_FLD)"
1186 "&& T_FLOAT_2_FLD=='-10.0000000000000'"
1187
1188 "&& T_DOUBLE_FLD==T_DOUBLE_FLD"
1189 "&& '12.5000000000000'==T_DOUBLE_FLD"
1190 "&& !(T_DOUBLE_FLD==42.1)"
1191 "&& !('abc'==T_DOUBLE_FLD)"
1192
1193 "&& T_STRING_FLD==T_STRING_FLD"
1194 "&& 7721==T_STRING_FLD"
1195 "&& T_STRING_FLD=='7721'"
1196 "&& !(T_STRING_FLD==667)"
1197 "&& T_STRING_FLD==7721.000"
1198 "&& !(0.2+0.2==T_STRING_FLD)"
1199
1200 "&& T_CARRAY_FLD==T_CARRAY_FLD"
1201 "&& !(T_CARRAY_FLD==10)"
1202 "&& '12a'==T_CARRAY_FLD"
1203 "&& T_CARRAY_FLD==12.0"
1204 "&& 12==T_CARRAY_FLD"
1205 "&& 12325.5==T_CARRAY_FLD+T_FLOAT_2_FLD+T_SHORT_FLD+T_DOUBLE_FLD"
1206 );
1207 assert_not_equal(tree, NULL);
1208 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1209 load_expr_test_data_2(p_ub);
1210 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1211 Btreefree(tree);
1212
1213
1214
1215 assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)"12311", 3, BFLD_STRING), EXSUCCEED);
1216 assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)"558211", 3, BFLD_STRING), EXSUCCEED);
1217 assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)"6", 3, BFLD_STRING), EXSUCCEED);
1218 assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, (char *)"-10", 3, BFLD_STRING), EXSUCCEED);
1219 assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)"12.5", 3, BFLD_STRING), EXSUCCEED);
1220 assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)"7721", 3, BFLD_STRING), EXSUCCEED);
1221 assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)"12a", 3, BFLD_STRING), EXSUCCEED);
1222
1223 tree=Bboolco ("!(100!=100) "
1224 "&& 51.05!=100.10/2 "
1225 "&& !('322'!='322')"
1226 "&& 3!=-3"
1227 "&& !('a'!='a')"
1228 "&& 155.0!=155.12-0.12+0.12"
1229
1230 "&& !(T_SHORT_FLD!=T_SHORT_FLD)"
1231 "&& !(12311!=T_SHORT_FLD)"
1232 "&& 12312!=T_SHORT_FLD"
1233 "&& !('12311'!=T_SHORT_FLD)"
1234 "&& 1231!=T_SHORT_FLD "
1235
1236 "&& !('-558211'!=-T_LONG_FLD)"
1237 "&& -T_LONG_FLD!=100"
1238 "&& !(558211!=T_LONG_FLD)"
1239 "&& !(T_LONG_FLD!=T_LONG_FLD)"
1240
1241 "&& !(T_CHAR_FLD!=T_CHAR_FLD)"
1242 "&& !(T_CHAR_FLD+T_CHAR_FLD!=T_CHAR_FLD*2)"
1243 "&& 5!=T_CHAR_FLD"
1244 "&& !('6'!=T_CHAR_FLD)"
1245 "&& !(6.0!=T_CHAR_FLD)"
1246 "&& !(6!=T_CHAR_FLD)"
1247
1248 "&& !(T_FLOAT_2_FLD!=T_FLOAT_2_FLD)"
1249 "&& !(-10!=T_FLOAT_2_FLD)"
1250 "&& -T_FLOAT_2_FLD!=-0.1"
1251 "&& -12.121!=T_FLOAT_2_FLD"
1252 "&& !(T_FLOAT_2_FLD!='-10.0000000000000')"
1253
1254 "&& !(T_DOUBLE_FLD!=T_DOUBLE_FLD)"
1255 "&& !('12.5000000000000'!=T_DOUBLE_FLD)"
1256 "&& T_DOUBLE_FLD!=42.1"
1257 "&& 'abc'!=T_DOUBLE_FLD"
1258
1259 "&& !(T_STRING_FLD!=T_STRING_FLD)"
1260 "&& !(7721!=T_STRING_FLD)"
1261 "&& !(T_STRING_FLD!='7721')"
1262 "&& T_STRING_FLD!=667"
1263 "&& !(T_STRING_FLD!=7721.000)"
1264 "&& 0.2+0.2!=T_STRING_FLD"
1265
1266 "&& !(T_CARRAY_FLD!=T_CARRAY_FLD)"
1267 "&& T_CARRAY_FLD!=10"
1268 "&& !('12a'!=T_CARRAY_FLD)"
1269 "&& !(T_CARRAY_FLD!=12.0)"
1270 "&& !(12!=T_CARRAY_FLD)"
1271 );
1272 assert_not_equal(tree, NULL);
1273 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1274 load_expr_test_data_2(p_ub);
1275 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1276 Btreefree(tree);
1277 }
1278
1279 Ensure(test_expr_basic_scopes)
1280 {
1281 char buf[1024];
1282 UBFH *p_ub = (UBFH *)buf;
1283 char *tree = NULL;
1284 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1285 double d = 2312.2;
1286 load_field_table();
1287
1288
1289 tree=Bboolco ("2*(5+6)==22"
1290 "&& 190==(10*(5.0+2*(3+4)))");
1291 assert_not_equal(tree, NULL);
1292 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1293 Btreefree(tree);
1294 }
1295
1296
1297
1298 Ensure(test_expr_short)
1299 {
1300 char buf[2048];
1301 UBFH *p_ub = (UBFH *)buf;
1302 char *tree = NULL;
1303 short short_val;
1304 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1305 set_up_dummy_data(p_ub);
1306 load_field_table();
1307
1308
1309
1310 short_val = 137;
1311 assert_equal(Badd(p_ub, T_SHORT_FLD, (char *)&short_val, 0), EXSUCCEED);
1312 tree=Bboolco ("T_SHORT_FLD==50*2+(30/2)*2+5+2");
1313 assert_not_equal(tree, NULL);
1314 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1315
1316 short_val = -137;
1317 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&short_val, 0), EXSUCCEED);
1318 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1319
1320 short_val = 137;
1321 assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&short_val, 0), EXSUCCEED);
1322 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1323
1324 Btreefree(tree);
1325
1326
1327 short_val = 4112;
1328 assert_equal(Badd(p_ub, T_SHORT_FLD, (char *)&short_val, 0), EXSUCCEED);
1329 tree=Bboolco ("T_SHORT_FLD[1] %% '4..2'");
1330 assert_not_equal(tree, NULL);
1331 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1332
1333 short_val = 4442;
1334 assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&short_val, 0), EXSUCCEED);
1335 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1336
1337 short_val = 1442;
1338 assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&short_val, 0), EXSUCCEED);
1339 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1340
1341
1342 Btreefree(tree);
1343
1344
1345
1346
1347 short_val = -4112;
1348 assert_equal(Bchg(p_ub, T_SHORT_FLD, 5, (char *)&short_val, 0), EXSUCCEED);
1349 tree=Bboolco ("-T_SHORT_FLD[5] == 4110+0.8+1.2 && 0.0==-1+1");
1350 assert_not_equal(tree, NULL);
1351 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1352
1353 Btreefree(tree);
1354
1355
1356 }
1357
1358
1359
1360
1361 Ensure(test_bboolpr)
1362 {
1363 char *tree;
1364 char buf[2048];
1365 UBFH *p_ub = (UBFH *)buf;
1366 char testbuf[2048];
1367 int read;
1368 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1369
1370 open_test_temp("w");
1371 assert_not_equal((tree=Bboolco ("2 * ( 4 + 5 ) || 5 && 'abc' %% '..b' && 2/2*4==5")), NULL);
1372 Bboolpr(tree, M_test_temp_file);
1373 close_test_temp();
1374 open_test_temp_for_read("r");
1375 assert_not_equal((read=fread (testbuf, 1, sizeof(testbuf), M_test_temp_file)),0);
1376 testbuf[read-1]=EXEOS;
1377 close_test_temp();
1378 remove_test_temp();
1379 assert_string_equal(testbuf,"((2*(4+5)) || ((5 && ('abc' %% '..b')) && (((2/2)*4) == 5)))");
1380
1381 Btreefree(tree);
1382
1383
1384
1385 open_test_temp("w");
1386 assert_not_equal((tree=Bboolco ("!( 'a'!='b' ) || !( 'c'&&'b' )")), NULL);
1387 Bboolpr(tree, M_test_temp_file);
1388 close_test_temp();
1389 open_test_temp_for_read("r");
1390 assert_not_equal((read=fread (testbuf, 1, sizeof(testbuf), M_test_temp_file)),0);
1391 testbuf[read-1]=EXEOS;
1392 close_test_temp();
1393 remove_test_temp();
1394 assert_string_equal(testbuf, "((!('a' != 'b')) || (!('c' && 'b')))");
1395 Btreefree(tree);
1396
1397
1398 open_test_temp("w");
1399 assert_not_equal((tree=Bboolco ("1<1 && 2>1 && 2>=1 && 1<=~2 && 2^1")), NULL);
1400 Bboolpr(tree, M_test_temp_file);
1401 close_test_temp();
1402 open_test_temp_for_read("r");
1403 assert_not_equal((read=fread (testbuf, 1, sizeof(testbuf), M_test_temp_file)),0);
1404 testbuf[read-1]=EXEOS;
1405 close_test_temp();
1406 remove_test_temp();
1407 assert_string_equal(testbuf, "(((((1 < 1) && (2 > 1)) && (2 >= 1)) && (1 <= (~2))) && (2 ^ 1))");
1408 Btreefree(tree);
1409 }
1410
1411
1412
1413
1414
1415
1416
1417 exprivate int bboolprcb_callback(char *buffer, long datalen, void *dataptr1)
1418 {
1419 assert_equal(datalen, strlen(buffer)+1);
1420 strcat((char *)dataptr1, buffer);
1421 return EXSUCCEED;
1422 }
1423
1424
1425
1426
1427 Ensure(test_bboolprcb)
1428 {
1429 char *tree;
1430 char buf[2048];
1431 UBFH *p_ub = (UBFH *)buf;
1432 char testbuf[2048];
1433
1434 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1435
1436 assert_not_equal((tree=Bboolco ("2 * ( 4 + 5 ) || 5 && 'abc' %% '..b' && 2/2*4==5")), NULL);
1437 testbuf[0] = EXEOS;
1438 Bboolprcb(tree, bboolprcb_callback, testbuf);
1439
1440
1441
1442
1443 ndrx_str_strip(testbuf, " \n");
1444 assert_string_equal(testbuf,"((2*(4+5))||((5&&('abc'%%'..b'))&&(((2/2)*4)==5)))");
1445
1446 Btreefree(tree);
1447
1448
1449 assert_not_equal((tree=Bboolco ("!( 'a'!='b' ) || !( 'c'&&'b' )")), NULL);
1450 testbuf[0] = EXEOS;
1451 Bboolprcb(tree, bboolprcb_callback, testbuf);
1452 ndrx_str_strip(testbuf, " \n");
1453 assert_string_equal(testbuf, "((!('a'!='b'))||(!('c'&&'b')))");
1454 Btreefree(tree);
1455
1456
1457 assert_not_equal((tree=Bboolco ("1<1&&2>1&&2>=1&&1<=~2&&2^1")), NULL);
1458 testbuf[0] = EXEOS;
1459 Bboolprcb(tree, bboolprcb_callback, testbuf);
1460 ndrx_str_strip(testbuf, " \n");
1461 assert_string_equal(testbuf, "(((((1<1)&&(2>1))&&(2>=1))&&(1<=(~2)))&&(2^1))");
1462 Btreefree(tree);
1463 }
1464
1465
1466 long callback_function_true(UBFH *p_ub, char *funcname)
1467 {
1468 assert_string_equal(funcname, "callback_function_true");
1469 return 1;
1470 }
1471
1472 long callback_function_false(UBFH *p_ub, char *funcname)
1473 {
1474 assert_string_equal(funcname, "callback_function_false");
1475 UBF_LOG(log_debug, "callback_function_false() called!");
1476 return 0;
1477 }
1478
1479 long callback_function_cond(UBFH *p_ub, char *funcname)
1480 {
1481 long ret;
1482 short short_val;
1483
1484 assert_string_equal(funcname, "callback_function_cond");
1485 assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&short_val, 0L), EXSUCCEED);
1486
1487 if (137 == short_val)
1488 ret=EXTRUE;
1489 else
1490 ret=EXFALSE;
1491
1492 return ret;
1493 }
1494
1495 long callback_function_value(UBFH *p_ub, char *funcname)
1496 {
1497 assert_string_equal(funcname, "callback_function_value");
1498 long ret;
1499
1500 ret = 177788;
1501
1502 return ret;
1503 }
1504
1505
1506 long callback_w_args_HELLO(UBFH *p_ub, char *funcname, char *arg1)
1507 {
1508 assert_string_equal(funcname, "callback_w_args_HELLO");
1509
1510 assert_equal(Bisubf(p_ub), EXTRUE);
1511 assert_string_equal(arg1, "HELLO WORLD");
1512
1513 return 1;
1514 }
1515
1516 long callback_w_args_empty(UBFH *p_ub, char *funcname, char *arg1)
1517 {
1518 assert_string_equal(funcname, "callback_w_args_empty");
1519
1520 assert_equal(Bisubf(p_ub), EXTRUE);
1521 assert_string_equal(arg1, "");
1522
1523 return 1;
1524 }
1525
1526 long callback_w_args_pars(UBFH *p_ub, char *funcname, char *arg1)
1527 {
1528 assert_equal(Bisubf(p_ub), EXTRUE);
1529
1530 return atol(arg1);
1531 }
1532
1533
1534
1535
1536
1537 Ensure(test_cbfunc)
1538 {
1539 char buf[2048];
1540 UBFH *p_ub = (UBFH *)buf;
1541 char *tree = NULL;
1542 short short_val;
1543 long long_val;
1544 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1545 set_up_dummy_data(p_ub);
1546 load_field_table();
1547
1548 assert_equal(Bboolsetcbf ("callback_function_true", callback_function_true), EXSUCCEED);
1549 assert_equal(Bboolsetcbf ("callback_function_false", callback_function_false), EXSUCCEED);
1550 assert_equal(Bboolsetcbf ("callback_function_cond", callback_function_cond), EXSUCCEED);
1551 assert_equal(Bboolsetcbf ("callback_function_value", callback_function_value), EXSUCCEED);
1552 assert_equal(Bboolsetcbf2 ("callback_w_args_HELLO", callback_w_args_HELLO), EXSUCCEED);
1553 assert_equal(Bboolsetcbf2 ("callback_w_args_empty", callback_w_args_empty), EXSUCCEED);
1554 assert_equal(Bboolsetcbf2 ("callback_w_args_pars", callback_w_args_pars), EXSUCCEED);
1555 assert_equal(Bboolsetcbf2 ("e", callback_w_args_pars), EXSUCCEED);
1556
1557
1558 short_val = 137;
1559 assert_equal(Badd(p_ub, T_SHORT_FLD, (char *)&short_val, 0), EXSUCCEED);
1560 long_val = 177788;
1561 assert_equal(Badd(p_ub, T_LONG_FLD, (char *)&long_val, 0), EXSUCCEED);
1562
1563
1564
1565 tree=Bboolco ("callback_function_true()");
1566 assert_not_equal(tree, NULL);
1567 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1568 Btreefree(tree);
1569
1570
1571 tree=Bboolco ("callback_function_false()");
1572 assert_not_equal(tree, NULL);
1573 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1574 Btreefree(tree);
1575
1576
1577 tree=Bboolco ("callback_function_cond()");
1578 assert_not_equal(tree, NULL);
1579 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1580 Btreefree(tree);
1581
1582
1583 tree=Bboolco ("callback_function_value()==177788");
1584 assert_not_equal(tree, NULL);
1585 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1586 Btreefree(tree);
1587
1588
1589 tree=Bboolco ("callback_function_value()==177787");
1590 assert_not_equal(tree, NULL);
1591 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1592 Btreefree(tree);
1593
1594
1595 tree=Bboolco ("callback_function_value()");
1596 assert_not_equal(tree, NULL);
1597 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1598 Btreefree(tree);
1599
1600
1601 tree=Bboolco ("callback_function_true()+callback_function_true()==2");
1602 assert_not_equal(tree, NULL);
1603 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1604 Btreefree(tree);
1605
1606
1607 tree=Bboolco ("callback_function_true()-callback_function_true()");
1608 assert_not_equal(tree, NULL);
1609 assert_equal(Bboolev(p_ub, tree), EXFALSE);
1610 Btreefree(tree);
1611
1612
1613 tree=Bboolco ("callback_function_value()==T_LONG_FLD");
1614 assert_not_equal(tree, NULL);
1615 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1616 Btreefree(tree);
1617
1618
1619 tree=Bboolco ("callback_function_value()=='177788'");
1620 assert_not_equal(tree, NULL);
1621 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1622 Btreefree(tree);
1623
1624
1625 tree=Bboolco ("callback_function_none()");
1626 assert_equal(tree, NULL);
1627 assert_not_equal(Berror, BBADNAME);
1628 Btreefree(tree);
1629
1630
1631 tree=Bboolco ("callback_function_value() %% '177788'");
1632 assert_equal(tree, NULL);
1633 assert_equal(Berror, BSYNTAX);
1634 Btreefree(tree);
1635
1636
1637 tree=Bboolco ("T_SHORT_FLD || callback_function_false()");
1638 assert_not_equal(tree, NULL);
1639 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1640 Btreefree(tree);
1641
1642
1643 assert_equal(Bboolsetcbf ("callback_function_value", NULL), EXSUCCEED);
1644 tree=Bboolco ("callback_function_value()=='177788'");
1645 assert_equal(tree, NULL);
1646 Btreefree(tree);
1647
1648
1649
1650 tree=Bboolco ("callback_w_args_HELLO('HELLO WORLD')==1");
1651 assert_not_equal(tree, NULL);
1652 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1653 Btreefree(tree);
1654
1655
1656 tree=Bboolco ("callback_w_args_empty('')==1");
1657 assert_not_equal(tree, NULL);
1658 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1659 Btreefree(tree);
1660
1661
1662 tree=Bboolco ("callback_w_args_pars('998871')==998871");
1663 assert_not_equal(tree, NULL);
1664 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1665 Btreefree(tree);
1666
1667 tree=Bboolco ("e('777')==777");
1668 assert_not_equal(tree, NULL);
1669 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1670 Btreefree(tree);
1671
1672
1673
1674 tree=Bboolco ("callback_w_args_empty('HELLO==1");
1675 assert_equal(tree, NULL);
1676 assert_equal(Berror, BSYNTAX);
1677
1678 tree=Bboolco ("callback_w_args_empty(''");
1679 assert_equal(tree, NULL);
1680 assert_equal(Berror, BSYNTAX);
1681
1682 tree=Bboolco ("callback_w_args_empty(ABC)");
1683 assert_equal(tree, NULL);
1684 assert_equal(Berror, BSYNTAX);
1685
1686
1687 tree=Bboolco ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaffzz('ABC')");
1688 assert_equal(tree, NULL);
1689 assert_equal(Berror, BSYNTAX);
1690
1691
1692
1693 tree=Bboolco ("zz('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1694 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1695 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1696 "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1697 "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1698 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1699 "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')");
1700 assert_equal(tree, NULL);
1701 assert_equal(Berror, BSYNTAX);
1702
1703 }
1704
1705
1706
1707
1708
1709 Ensure(test_expr_argsval)
1710 {
1711 char buf[2048];
1712 UBFH *p_ub = (UBFH *)buf;
1713 char *tree = NULL;
1714
1715 memset(buf, 0, sizeof(buf));
1716
1717
1718 tree=Bboolco ("1==1");
1719 assert_not_equal(tree, NULL);
1720
1721 assert_equal(Bboolev(p_ub, tree), EXFAIL);
1722 assert_equal(Berror, BNOTFLD);
1723
1724 assert_double_equal(Bfloatev(p_ub, tree), -1);
1725 assert_equal(Berror, BNOTFLD);
1726
1727 Btreefree(tree);
1728 tree = NULL;
1729
1730 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1731
1732 assert_equal(Bboolev(p_ub, tree), EXFAIL);
1733 assert_equal(Berror, BEINVAL);
1734
1735 assert_double_equal(Bfloatev(p_ub, tree), -1);
1736 assert_equal(Berror, BEINVAL);
1737
1738 }
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748 #define EXPR_TEST(UB, EXP, ERRNOCOMP, ERRNOEVAL, RES) do {\
1749 tree=Bboolco (EXP);\
1750 if (0 < ERRNOCOMP)\
1751 {\
1752 assert_equal(tree, NULL);\
1753 assert_equal(Berror, ERRNOCOMP);\
1754 }\
1755 else\
1756 {\
1757 assert_not_equal(tree, NULL);\
1758 assert_equal(Bboolev(UB, tree), RES);\
1759 if (0 < ERRNOEVAL)\
1760 {\
1761 assert_equal(Berror, ERRNOEVAL);\
1762 }\
1763 Btreefree(tree);\
1764 }\
1765 } while (0)
1766
1767
1768 Ensure(test_expr_recursiv_idpars)
1769 {
1770
1771 ndrx_ubf_rfldid_t rfldid;
1772 Berror=0;
1773 assert_equal(ndrx_ubf_rfldid_parse("T_UBF_FLD[1]..T_STRING_10_FLD[0]", &rfldid), EXFAIL);
1774 assert_equal(Berror, BSYNTAX);
1775
1776 Berror=0;
1777 assert_equal(ndrx_ubf_rfldid_parse(".", &rfldid), EXFAIL);
1778 assert_equal(Berror, BSYNTAX);
1779
1780 Berror=0;
1781 assert_equal(ndrx_ubf_rfldid_parse("[0]ABC", &rfldid), EXFAIL);
1782 assert_equal(Berror, BSYNTAX);
1783
1784 Berror=0;
1785 assert_equal(ndrx_ubf_rfldid_parse("T_UBF_FLD[0][1]", &rfldid), EXFAIL);
1786 assert_equal(Berror, BSYNTAX);
1787
1788
1789
1790 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD", &rfldid), EXSUCCEED);
1791 ndrx_ubf_rfldid_free(&rfldid);
1792
1793 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD.hello", &rfldid), EXSUCCEED);
1794 assert_equal(rfldid.cname_occ, 0);
1795 assert_string_equal(rfldid.cname, "hello");
1796 ndrx_ubf_rfldid_free(&rfldid);
1797
1798 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD[1].hello", &rfldid), EXSUCCEED);
1799 assert_equal(rfldid.cname_occ, 0);
1800 assert_string_equal(rfldid.cname, "hello");
1801 ndrx_ubf_rfldid_free(&rfldid);
1802
1803 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD.hello[5]", &rfldid), EXSUCCEED);
1804 assert_equal(rfldid.cname_occ, 5);
1805 assert_string_equal(rfldid.cname, "hello");
1806 ndrx_ubf_rfldid_free(&rfldid);
1807
1808 Berror=0;
1809 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD.hello.zero", &rfldid), EXFAIL);
1810 assert_equal(Berror, BEBADOP);
1811
1812 Berror=0;
1813 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD.hello[0].zero", &rfldid), EXFAIL);
1814 assert_equal(Berror, BEBADOP);
1815
1816 Berror=0;
1817 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD[0].hello.zero", &rfldid), EXFAIL);
1818 assert_equal(Berror, BEBADOP);
1819
1820 Berror=0;
1821 assert_equal(ndrx_ubf_rfldid_parse("T_VIEW_FLD[0].hello.zero[0]", &rfldid), EXFAIL);
1822 assert_equal(Berror, BEBADOP);
1823
1824 Berror=0;
1825 assert_equal(ndrx_ubf_rfldid_parse("", &rfldid), EXFAIL);
1826 assert_equal(Berror, BSYNTAX);
1827
1828 }
1829
1830
1831
1832
1833 Ensure(test_expr_recursiv_ubf)
1834 {
1835 char buf[56000];
1836 char *tree;
1837 UBFH *p_ub = (UBFH *)buf;
1838
1839 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1840
1841 load_recursive_data(p_ub);
1842
1843 EXPR_TEST(p_ub, "T_UBF_FLD.T_STRING_10_FLD=='HELLO WORLD5'", 0, 0, EXTRUE);
1844 EXPR_TEST(p_ub, "T_UBF_FLD[0].T_STRING_10_FLD[0]=='HELLO WORLD5'", 0, 0, EXTRUE);
1845
1846 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD[0].T_STRING_9_FLD[2]==31", 0, 0, EXTRUE);
1847
1848 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD[0].T_STRING_9_FLD[2]==32", 0, 0, EXFALSE);
1849 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD[0].T_STRING_9_FLD[2]", 0, 0, EXTRUE);
1850 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD[99].T_STRING_9_FLD[2]", 0, 0, EXFALSE);
1851
1852
1853
1854 EXPR_TEST(p_ub, "T_UBF_FLD[X].T_STRING_10_FLD[0]=='HELLO WORLD5'", BEBADOP, EXFAIL, EXFAIL);
1855 EXPR_TEST(p_ub, "T_UBF_FLD[1]..T_STRING_10_FLD[0]=='HELLO WORLD5'", BEBADOP, EXFAIL, EXFAIL);
1856 EXPR_TEST(p_ub, "T_UBF_FLD..T_STRING_10_FLD=='HELLO WORLD5'", BEBADOP, EXFAIL, EXFAIL);
1857 EXPR_TEST(p_ub, "T_UBF_FLD.T_STRING_10_FLD.T_STRING_10_FLD=='HELLO WORLD5'", BEBADOP, EXFAIL, EXFAIL);
1858 EXPR_TEST(p_ub, "T_UBF_FLD.", BEBADOP, EXFAIL, EXFAIL);
1859
1860 EXPR_TEST(p_ub, "1==1 && T_STRING_10_FLD==T_STRING_10_FLD && T_UBF_FLD==T_UBF_FLD", BEBADOP, EXFAIL, EXFAIL);
1861
1862
1863 }
1864
1865
1866
1867
1868 Ensure(test_expr_recursiv_view)
1869 {
1870 char buf[56000];
1871 char *tree;
1872 UBFH *p_ub = (UBFH *)buf;
1873
1874 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1875
1876 load_recursive_data(p_ub);
1877
1878 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD.T_VIEW_3_FLD[4].tfloat1==400", 0, 0, EXTRUE);
1879
1880
1881 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD.T_VIEW_3_FLD[4]==400", BEBADOP, EXFAIL, EXFAIL);
1882
1883
1884 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_UBF_2_FLD.T_VIEW_3_FLD[4].tfloat1", 0, 0, EXTRUE);
1885
1886 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_VIEW_FLD[1].tcarray3[8]", 0, 0, EXTRUE);
1887
1888
1889 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_VIEW_FLD[1].tcarray3[9]", 0, 0, EXFALSE);
1890
1891
1892 EXPR_TEST(p_ub, "T_UBF_2_FLD[1].T_UBF_FLD.T_VIEW_FLD[1].tcarray3[10]", 0, 0, EXFAIL);
1893
1894 }
1895
1896
1897
1898
1899 Ensure(test_expr_longstr)
1900 {
1901 char buf[2048];
1902 char val[1024];
1903 UBFH *p_ub = (UBFH *)buf;
1904 char *tree = NULL;
1905
1906 memset(val, ' ', sizeof(val));
1907
1908 val[sizeof(val)-1]=EXEOS;
1909
1910
1911 assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
1912
1913 assert_equal(Bchg(p_ub, T_STRING_10_FLD, 0, val, 0L), EXSUCCEED);
1914
1915 tree=Bboolco ("T_STRING_10_FLD");
1916 assert_not_equal(tree, NULL);
1917 assert_equal(Bboolev(p_ub, tree), EXTRUE);
1918 assert_equal(Berror, 0);
1919
1920 Btreefree(tree);
1921 tree = NULL;
1922
1923 }
1924
1925 TestSuite *ubf_expr_tests(void)
1926 {
1927 TestSuite *suite = create_test_suite();
1928
1929 std_basic_setup();
1930 add_test(suite, test_expr_basic);
1931 add_test(suite, test_expr_basic_logic);
1932 add_test(suite, test_expr_basic_equality);
1933 add_test(suite, test_expr_basic_unary);
1934 add_test(suite, test_expr_basic_additive);
1935 add_test(suite, test_expr_basic_multiplicative);
1936 add_test(suite, test_expr_basic_relational);
1937 add_test(suite, test_expr_basic_scopes);
1938 add_test(suite, test_bboolpr);
1939 add_test(suite, test_bboolprcb);
1940
1941
1942 add_test(suite, test_expr_basic_floatev);
1943
1944
1945 add_test(suite, test_expr_short);
1946
1947
1948 add_test(suite, test_cbfunc);
1949
1950
1951 add_test(suite, test_expr_argsval);
1952
1953 add_test(suite, test_expr_recursiv_idpars);
1954 add_test(suite, test_expr_recursiv_ubf);
1955 add_test(suite, test_expr_recursiv_view);
1956
1957
1958 add_test(suite, test_expr_longstr);
1959
1960 return suite;
1961 }
1962
1963