source/ubftest/test_find.c

0001 /**
0002  * @brief Contains routines for testing find kind functions
0003  *
0004  * @file test_find.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 <cgreen/cgreen.h>
0038 #include <ubf.h>
0039 #include <ndrstandard.h>
0040 #include <string.h>
0041 #include "test.fd.h"
0042 #include "ubfunit1.h"
0043
0044
0045 void load_find_test_data(UBFH *p_ub)
0046 {
0047     short s = 88;
0048     long l = -1021;
0049     char c = 'c';
0050     float f = 17.31;
0051     double d = 12312.1111;
0052     char carr[] = "CARRAY1 TEST STRING DATA";
0053     BFLDLEN len = strlen(carr);
0054
0055     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0056     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0057     assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0058     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0059     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0060     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0061     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0062
0063     gen_load_ubf(p_ub, 0, 0, 0);
0064     gen_load_view(p_ub, 0, 0, 0);
0065     gen_load_ptr(p_ub, 0, 0, 0);
0066
0067
0068     /* Make second copy of field data (another for not equal test)*/
0069     s = 88;
0070     l = -1021;
0071     c = '.';
0072     f = 17.31;
0073     d = 12312.1111;
0074     carr[0] = 'Y';
0075     len = strlen(carr);
0076
0077     assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&s, 0), EXSUCCEED);
0078     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0079     assert_equal(Bchg(p_ub, T_CHAR_FLD, 1, (char *)&c, 0), EXSUCCEED);
0080     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 1, (char *)&f, 0), EXSUCCEED);
0081     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 1, (char *)&d, 0), EXSUCCEED);
0082     assert_equal(Bchg(p_ub, T_STRING_FLD, 1, (char *)"TEST STRING ARRAY2", 0), EXSUCCEED);
0083     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 1, (char *)carr, len), EXSUCCEED);
0084
0085     gen_load_ubf(p_ub, 1, 1, 0);
0086     gen_load_view(p_ub, 1, 1, 0);
0087     gen_load_ptr(p_ub, 1, 1, 0);
0088
0089
0090     l = 888;
0091     assert_equal(Bchg(p_ub, T_LONG_FLD, 4, (char *)&l, 0), EXSUCCEED);
0092
0093     s = 212;
0094     l = 212;
0095     c = 'b';
0096     f = 12127;
0097     d = 1231232.1;
0098     carr[0] = 'X';
0099     assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 0, (char *)&s, 0), EXSUCCEED);
0100     assert_equal(Bchg(p_ub, T_LONG_2_FLD, 0, (char *)&l, 0), EXSUCCEED);
0101     assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 0, (char *)&c, 0), EXSUCCEED);
0102     assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 0, (char *)&f, 0), EXSUCCEED);
0103     assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 0, (char *)&d, 0), EXSUCCEED);
0104     assert_equal(Bchg(p_ub, T_STRING_2_FLD, 0, (char *)"XTEST STR VAL", 0), EXSUCCEED);
0105     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 0, (char *)carr, len), EXSUCCEED);
0106
0107     gen_load_ubf(p_ub, 0, 2, 1);
0108     gen_load_view(p_ub, 0, 2, 1);
0109     gen_load_ptr(p_ub, 0, 2, 1);
0110 }
0111
0112 /**
0113  * Test data used for CBfindocc
0114  * @param p_ub
0115  */
0116 void load_bfindocc_test_data(UBFH *p_ub)
0117 {
0118     short s = 881;
0119     long l = -1011;
0120     char c = 'a';
0121     float f = 1.31;
0122     double d = 1312.1111;
0123     char carr[] = "ZARRAY1 TEST STRING DATA";
0124     BFLDLEN len = strlen(carr);
0125
0126     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0127     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0128     assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0129     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0130     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0131     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0132     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0133
0134     gen_load_ubf(p_ub, 0, 3, 0);
0135     gen_load_view(p_ub, 0, 3, 0);
0136     gen_load_ptr(p_ub, 0, 3, 0);
0137
0138     /* Make second copy of field data (another for not equal test)*/
0139     s = 88;
0140     l = -1021;
0141     c = '.';
0142     f = 17.31;
0143     d = 12312.1111;
0144     carr[0] = '\0';
0145     len = 24;
0146
0147     assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&s, 0), EXSUCCEED);
0148     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0149     assert_equal(Bchg(p_ub, T_CHAR_FLD, 1, (char *)&c, 0), EXSUCCEED);
0150     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 1, (char *)&f, 0), EXSUCCEED);
0151     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 1, (char *)&d, 0), EXSUCCEED);
0152     assert_equal(Bchg(p_ub, T_STRING_FLD, 1, (char *)"TEST STRING ARRAY2", 0), EXSUCCEED);
0153     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 1, (char *)carr, len), EXSUCCEED);
0154
0155     gen_load_ubf(p_ub, 1, 4, 0);
0156     gen_load_view(p_ub, 1, 4, 0);
0157     gen_load_ptr(p_ub, 1, 4, 0);
0158
0159     l = 888;
0160     assert_equal(Bchg(p_ub, T_LONG_FLD, 4, (char *)&l, 0), EXSUCCEED);
0161
0162     s = 212;
0163     l = 212;
0164     c = 'b';
0165     f = 12127;
0166     d = 1231232.1;
0167     carr[0] = 'X';
0168     assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 0, (char *)&s, 0), EXSUCCEED);
0169     assert_equal(Bchg(p_ub, T_LONG_2_FLD, 0, (char *)&l, 0), EXSUCCEED);
0170     assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 0, (char *)&c, 0), EXSUCCEED);
0171     assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 0, (char *)&f, 0), EXSUCCEED);
0172     assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 0, (char *)&d, 0), EXSUCCEED);
0173     assert_equal(Bchg(p_ub, T_STRING_2_FLD, 0, (char *)"XTEST STR VAL", 0), EXSUCCEED);
0174     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 0, (char *)carr, len), EXSUCCEED);
0175
0176     gen_load_ubf(p_ub, 0, 5, 1);
0177     gen_load_view(p_ub, 0, 5, 1);
0178     gen_load_ptr(p_ub, 0, 5, 1);
0179
0180 }
0181
0182
0183 /**
0184  * Test data used for Bfindlast
0185  * @param p_ub
0186  */
0187 void load_bfindlast_test_data(UBFH *p_ub)
0188 {
0189     short s = 88;
0190     long l = -1021;
0191     char c = 'c';
0192     float f = 17.31;
0193     double d = 12312.1111;
0194     char carr[] = "CARRAY1 TEST STRING DATA";
0195     BFLDLEN len = strlen(carr);
0196
0197     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0198     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0199     assert_equal(Bchg(p_ub, T_CHAR_FLD, 2, (char *)&c, 0), EXSUCCEED);
0200     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 3, (char *)&f, 0), EXSUCCEED);
0201     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 4, (char *)&d, 0), EXSUCCEED);
0202     assert_equal(Bchg(p_ub, T_STRING_FLD, 5, (char *)"TEST STR VAL", 0), EXSUCCEED);
0203     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 6, (char *)carr, len), EXSUCCEED);
0204
0205     gen_load_ptr(p_ub, 7, 6, 0);
0206     gen_load_ubf(p_ub, 8, 6, 0);
0207     gen_load_view(p_ub, 9, 6, 0);
0208
0209 }
0210
0211 /* dded tests for Bfind */
0212 Ensure(test_bfind)
0213 {
0214     char fb[2048];
0215     UBFH *p_ub = (UBFH *)fb;
0216     BFLDLEN len=0;
0217     char *p;
0218
0219     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0220     load_find_test_data(p_ub);
0221
0222     assert_equal(*((short*)Bfind(p_ub, T_SHORT_FLD, 0, &len)), 88);
0223     assert_equal(len, sizeof(short));
0224
0225     assert_equal(*((long*)Bfind(p_ub, T_LONG_FLD, 0, &len)), -1021);
0226     assert_equal(len, sizeof(long));
0227
0228     assert_equal(*((char*)Bfind(p_ub, T_CHAR_FLD, 0, &len)), 'c');
0229     assert_equal(len, sizeof(char));
0230
0231     assert_double_equal(*((float*)Bfind(p_ub, T_FLOAT_FLD, 0, &len)), 17.31);
0232     assert_equal(len, sizeof(float));
0233
0234     assert_string_equal(Bfind(p_ub, T_STRING_FLD, 0, &len), "TEST STR VAL");
0235     assert_equal(len, strlen("TEST STR VAL")+1);
0236
0237     p=Bfind(p_ub, T_CARRAY_FLD, 0, &len);
0238     assert_not_equal(p, NULL);
0239     assert_equal(memcmp(p, "CARRAY1 TEST STRING DATA", 24), 0);
0240     assert_equal(len, 24);
0241
0242     p=Bfind(p_ub, T_PTR_FLD, 0, &len);
0243     assert_not_equal(p, NULL);
0244     gen_test_ptr_val_dbg(__FILE__, __LINE__, *((ndrx_longptr_t *)p), 0, &len);
0245
0246     p=Bfind(p_ub, T_VIEW_FLD, 0, &len);
0247     assert_not_equal(p, NULL);
0248     gen_test_view_val_dbg(__FILE__, __LINE__, (BVIEWFLD *)p, 0, &len);
0249
0250     /* test ubf... */
0251     p=Bfind(p_ub, T_UBF_FLD, 0, &len);
0252     assert_not_equal(p, NULL);
0253     gen_test_ubf_val_dbg(__FILE__, __LINE__, (UBFH *)p, 0, &len);
0254
0255     p=Bfind(p_ub, BBADFLDID, 0, &len);
0256     assert_equal(p, NULL);
0257     assert_equal(Berror, BBADFLD);
0258
0259 }
0260
0261 /**
0262  * This simply reads all field and adds them to another buffer, then do compare
0263  */
0264 Ensure(test_cbfind)
0265 {
0266     char fb[2048];
0267     UBFH *p_ub = (UBFH *)fb;
0268     short *s;
0269     long *l;
0270     char *c;
0271     float *f;
0272     double *d;
0273     char *str;
0274     char *carr;
0275     BFLDLEN len=0;
0276
0277     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0278     load_find_test_data(p_ub);
0279
0280     /* Test as short */
0281     assert_equal(*(s=(short *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_SHORT)), 88);
0282     assert_equal(*(s=(short *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_SHORT)), -1021);
0283     assert_equal(*(s=(short *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_SHORT)), 99);
0284     assert_equal(*(s=(short *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_SHORT)), 17);
0285     assert_equal(*(s=(short *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_SHORT)), 12312);
0286     assert_equal(*(s=(short *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_SHORT)), 0);
0287     assert_equal(*(s=(short *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_SHORT)), 0);
0288
0289     assert_equal(*(s=(short *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_SHORT)), 9000);
0290
0291     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_SHORT), NULL);
0292     assert_equal(Berror, BEBADOP);
0293     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_SHORT), NULL);
0294     assert_equal(Berror, BEBADOP);
0295
0296
0297     len=0;
0298     assert_equal(*(s=(short *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_SHORT)), 88);
0299     assert_equal(len, sizeof(short));
0300
0301     len=0;
0302     assert_equal(*(s=(short *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_SHORT)), -1021);
0303     assert_equal(len, sizeof(short));
0304
0305     len=0;
0306     assert_equal(*(s=(short *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_SHORT)), 99);
0307     assert_equal(len, sizeof(short));
0308
0309     len=0;
0310     assert_equal(*(s=(short *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_SHORT)), 17);
0311     assert_equal(len, sizeof(short));
0312
0313     len=0;
0314     assert_equal(*(s=(short *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_SHORT)), 12312);
0315     assert_equal(len, sizeof(short));
0316
0317     len=0;
0318     assert_equal(*(s=(short *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_SHORT)), 0);
0319     assert_equal(len, sizeof(short));
0320
0321     len=0;
0322     assert_equal(*(s=(short *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_SHORT)), 0);
0323     assert_equal(len, sizeof(short));
0324
0325
0326     len=0;
0327     assert_equal(*(s=(short *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_SHORT)), 9000);
0328     assert_equal(len, sizeof(short));
0329
0330     len=0;
0331     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, &len, BFLD_SHORT), NULL);
0332     assert_equal(Berror, BEBADOP);
0333
0334     len=0;
0335     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, &len, BFLD_SHORT), NULL);
0336     assert_equal(Berror, BEBADOP);
0337
0338
0339     /* Test as long */
0340     assert_equal(*(l=(long *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_LONG)), 88);
0341     assert_equal(*(l=(long *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_LONG)), -1021);
0342     assert_equal(*(l=(long *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_LONG)), 99);
0343     assert_equal(*(l=(long *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_LONG)), 17);
0344     assert_equal(*(l=(long *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_LONG)), 12312);
0345     assert_equal(*(l=(long *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_LONG)), 0);
0346     assert_equal(*(l=(long *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_LONG)), 0);
0347
0348     assert_equal(*(l=(long *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_LONG)), 9000);
0349     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_LONG), NULL);
0350     assert_equal(Berror, BEBADOP);
0351     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_LONG), NULL);
0352     assert_equal(Berror, BEBADOP);
0353
0354
0355     len=0;
0356     assert_equal(*(l=(long *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_LONG)), 88);
0357     assert_equal(len, sizeof(long));
0358
0359     len=0;
0360     assert_equal(*(l=(long *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_LONG)), -1021);
0361     assert_equal(len, sizeof(long));
0362
0363     len=0;
0364     assert_equal(*(l=(long *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_LONG)), 99);
0365     assert_equal(len, sizeof(long));
0366
0367     len=0;
0368     assert_equal(*(l=(long *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_LONG)), 17);
0369     assert_equal(len, sizeof(long));
0370
0371     len=0;
0372     assert_equal(*(l=(long *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_LONG)), 12312);
0373     assert_equal(len, sizeof(long));
0374
0375     len=0;
0376     assert_equal(*(l=(long *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_LONG)), 0);
0377     assert_equal(len, sizeof(long));
0378
0379     len=0;
0380     assert_equal(*(l=(long *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_LONG)), 0);
0381     assert_equal(len, sizeof(long));
0382
0383     len=0;
0384     assert_equal(*(l=(long *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_LONG)), 9000);
0385     assert_equal(len, sizeof(long));
0386
0387     len=0;
0388     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, &len, BFLD_LONG), NULL);
0389     assert_equal(Berror, BEBADOP);
0390
0391     len=0;
0392     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, &len, BFLD_LONG), NULL);
0393     assert_equal(Berror, BEBADOP);
0394
0395
0396     /* Test as char */
0397     assert_equal(*(c=(char *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_CHAR)), 'X');
0398     assert_equal(*(c=(char *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_CHAR)), 3); /* may be incorrect due to data size*/
0399     assert_equal(*(c=(char *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_CHAR)), 'c');
0400     assert_equal(*(c=(char *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_CHAR)), 17);
0401     assert_equal(*(c=(char *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_CHAR)), 24); /* May be incorrect dute to data size*/
0402     assert_equal(*(c=(char *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_CHAR)), 'T');
0403     assert_equal(*(c=(char *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_CHAR)), 'C');
0404     assert_equal(*(c=(char *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_CHAR)), 40);
0405     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_CHAR), NULL);
0406     assert_equal(Berror, BEBADOP);
0407     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_CHAR), NULL);
0408     assert_equal(Berror, BEBADOP);
0409
0410     len=0;
0411     assert_equal(*(c=(char *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_CHAR)), 'X');
0412     assert_equal(len, sizeof(char));
0413
0414     len=0;
0415     assert_equal(*(c=(char *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_CHAR)), 3); /* may be incorrect due to data size*/
0416     assert_equal(len, sizeof(char));
0417
0418     len=0;
0419     assert_equal(*(c=(char *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_CHAR)), 'c');
0420     assert_equal(len, sizeof(char));
0421
0422     len=0;
0423     assert_equal(*(c=(char *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_CHAR)), 17);
0424     assert_equal(len, sizeof(char));
0425
0426     len=0;
0427     assert_equal(*(c=(char *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_CHAR)), 24); /* May be incorrect dute to data size*/
0428     assert_equal(len, sizeof(char));
0429
0430     len=0;
0431     assert_equal(*(c=(char *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_CHAR)), 'T');
0432     assert_equal(len, sizeof(char));
0433
0434     len=0;
0435     assert_equal(*(c=(char *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_CHAR)), 'C');
0436     assert_equal(len, sizeof(char));
0437
0438     len=0;
0439     assert_equal(*(c=(char *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_CHAR)), 40);
0440     assert_equal(len, sizeof(char));
0441
0442
0443     /* Test as float */
0444     assert_double_equal(*(f=(float *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_FLOAT)), 88);
0445     assert_double_equal(*(f=(float *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_FLOAT)), -1021);
0446     assert_double_equal(*(f=(float *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_FLOAT)), 99);
0447     assert_double_equal(*(f=(float *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_FLOAT)), 17.31);
0448     assert_double_equal(*(f=(float *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_FLOAT)), 12312.1111);
0449     assert_double_equal(*(f=(float *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_FLOAT)), 0);
0450     assert_double_equal(*(f=(float *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_FLOAT)), 0);
0451
0452     assert_double_equal(*(f=(float *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_FLOAT)), 9000);
0453     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_FLOAT), NULL);
0454     assert_equal(Berror, BEBADOP);
0455     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_FLOAT), NULL);
0456     assert_equal(Berror, BEBADOP);
0457
0458     len=0;
0459     assert_double_equal(*(f=(float *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_FLOAT)), 88);
0460     assert_equal(len, sizeof(float));
0461
0462     len=0;
0463     assert_double_equal(*(f=(float *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_FLOAT)), -1021);
0464     assert_equal(len, sizeof(float));
0465
0466     len=0;
0467     assert_double_equal(*(f=(float *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_FLOAT)), 99);
0468     assert_equal(len, sizeof(float));
0469
0470     len=0;
0471     assert_double_equal(*(f=(float *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_FLOAT)), 17.31);
0472     assert_equal(len, sizeof(float));
0473
0474     len=0;
0475     assert_double_equal(*(f=(float *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_FLOAT)), 12312.1111);
0476     assert_equal(len, sizeof(float));
0477
0478     len=0;
0479     assert_double_equal(*(f=(float *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_FLOAT)), 0);
0480     assert_equal(len, sizeof(float));
0481
0482     len=0;
0483     assert_double_equal(*(f=(float *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_FLOAT)), 0);
0484     assert_equal(len, sizeof(float));
0485
0486     len=0;
0487     assert_double_equal(*(f=(float *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_FLOAT)), 9000);
0488     assert_equal(len, sizeof(float));
0489
0490     /* Test as double */
0491     assert_double_equal(*(d=(double *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_DOUBLE)), 88);
0492     assert_double_equal(*(d=(double *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_DOUBLE)), -1021);
0493     assert_double_equal(*(d=(double *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_DOUBLE)), 99);
0494     assert_double_equal(*(d=(double *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_DOUBLE)), 17.31);
0495     assert_double_equal(*(d=(double *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_DOUBLE)), 12312.1111);
0496     assert_double_equal(*(d=(double *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_DOUBLE)), 0);
0497     assert_double_equal(*(d=(double *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_DOUBLE)), 0);
0498     assert_double_equal(*(d=(double *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_DOUBLE)), 9000);
0499
0500     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_DOUBLE), NULL);
0501     assert_equal(Berror, BEBADOP);
0502     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_DOUBLE), NULL);
0503     assert_equal(Berror, BEBADOP);
0504
0505     len=0;
0506     assert_double_equal(*(d=(double *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_DOUBLE)), 88);
0507     assert_equal(len, sizeof(double));
0508
0509     len=0;
0510     assert_double_equal(*(d=(double *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_DOUBLE)), -1021);
0511     assert_equal(len, sizeof(double));
0512
0513     len=0;
0514     assert_double_equal(*(d=(double *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_DOUBLE)), 99);
0515     assert_equal(len, sizeof(double));
0516
0517     len=0;
0518     assert_double_equal(*(d=(double *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_DOUBLE)), 17.31);
0519     assert_equal(len, sizeof(double));
0520
0521     len=0;
0522     assert_double_equal(*(d=(double *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_DOUBLE)), 12312.1111);
0523     assert_equal(len, sizeof(double));
0524
0525     len=0;
0526     assert_double_equal(*(d=(double *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_DOUBLE)), 0);
0527     assert_equal(len, sizeof(double));
0528
0529     len=0;
0530     assert_double_equal(*(d=(double *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_DOUBLE)), 0);
0531     assert_equal(len, sizeof(double));
0532
0533     len=0;
0534     assert_double_equal(*(d=(double *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_DOUBLE)), 9000);
0535     assert_equal(len, sizeof(double));
0536
0537     /* no need for ubf/vew -> they will fail */
0538
0539     /* Test as string */
0540     assert_string_equal(CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_STRING), "88");
0541     assert_string_equal(CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_STRING), "-1021");
0542     assert_string_equal(CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_STRING), "c");
0543     assert_equal(strncmp(CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_STRING), "17.3", 4), 0);
0544     assert_equal(strncmp(CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_STRING), "12312.1111", 10), 0);
0545     assert_string_equal(CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_STRING), "TEST STR VAL");
0546     assert_string_equal(CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_STRING), "CARRAY1 TEST STRING DATA");
0547     /* hex value */
0548     assert_string_equal(CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_STRING), "0x2328");
0549     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_STRING), NULL);
0550     assert_equal(Berror, BEBADOP);
0551     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_STRING), NULL);
0552     assert_equal(Berror, BEBADOP);
0553
0554     len=0;
0555     assert_string_equal(CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_STRING), "88");
0556     assert_equal(len, 3);
0557
0558     len=0;
0559     assert_string_equal(CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_STRING), "-1021");
0560     assert_equal(len, 6);
0561
0562     len=0;
0563     assert_string_equal(CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_STRING), "c");
0564     assert_equal(len, 2);
0565
0566     len=0;
0567     assert_equal(strncmp(CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_STRING), "17.3", 4), 0);
0568     assert_equal(len, 9);
0569
0570     len=0;
0571     assert_equal(strncmp(CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_STRING), "12312.1111", 10), 0);
0572     assert_equal(len, 13);
0573
0574
0575     len=0;
0576     assert_string_equal(CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_STRING), "TEST STR VAL");
0577     assert_equal(len, 13);
0578
0579     len=0;
0580     assert_string_equal(CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_STRING), "CARRAY1 TEST STRING DATA");
0581     assert_equal(len, 25);
0582
0583     len=0;
0584     assert_string_equal(CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_STRING), "0x2328");
0585     assert_equal(len, 7);
0586
0587
0588     /* Test as carray */
0589     assert_equal(strncmp(CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_CARRAY), "88", 2), 0);
0590     assert_equal(strncmp(CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_CARRAY), "-1021", 5), 0);
0591     assert_equal(strncmp(CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_CARRAY), "c", 1), 0);
0592     assert_equal(strncmp(CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_CARRAY), "17.3", 4), 0);
0593     assert_equal(strncmp(CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_CARRAY), "12312.1111", 10), 0);
0594     assert_equal(strncmp(CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_CARRAY), "TEST STR VAL", 12), 0);
0595     assert_equal(strncmp(CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_CARRAY), "CARRAY1 TEST STRING DATA", 24), 0);
0596
0597     assert_equal(strncmp(CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_CARRAY), "0x2328", 6), 0);
0598     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_CARRAY), NULL);
0599     assert_equal(Berror, BEBADOP);
0600     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_CARRAY), NULL);
0601     assert_equal(Berror, BEBADOP);
0602
0603     /* Bug #330 */
0604     len=0;
0605     assert_equal(strncmp(CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_CARRAY), "88", 2), 0);
0606     assert_equal(len, 2);
0607
0608     len=0;
0609     assert_equal(strncmp(CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_CARRAY), "-1021", 5), 0);
0610     assert_equal(len, 5);
0611
0612     len=0;
0613     assert_equal(strncmp(CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_CARRAY), "c", 1), 0);
0614     assert_equal(len, 1);
0615
0616     len=0;
0617     assert_equal(strncmp(CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_CARRAY), "17.3", 4), 0);
0618     /* This is due to 5 zeros... after dot */
0619     assert_equal(len, 8);
0620
0621     len=0;
0622     assert_equal(strncmp(CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_CARRAY), "12312.1111", 10), 0);
0623     /* this is due to 6 zeros after dot */
0624     assert_equal(len, 12);
0625
0626     len=0;
0627     assert_equal(strncmp(CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_CARRAY), "TEST STR VAL", 12), 0);
0628     assert_equal(len, 12);
0629
0630     len=0;
0631     assert_equal(strncmp(CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_CARRAY), "CARRAY1 TEST STRING DATA", 24), 0);
0632     assert_equal(len, 24);
0633
0634     assert_equal(CBfind(p_ub, T_CARRAY_3_FLD, 0, &len, BFLD_CARRAY), NULL);
0635     assert_equal(Berror, BNOTPRES);
0636
0637     len=0;
0638     assert_equal(strncmp(CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_CARRAY), "0x2328", 6), 0);
0639     assert_equal(len, 6);
0640
0641
0642     /* Test as ptr */
0643     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_SHORT_FLD, 0, 0, BFLD_PTR)), 88);
0644
0645     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_LONG_FLD, 0, 0, BFLD_PTR)), -1021);
0646     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_CHAR_FLD, 0, 0, BFLD_PTR)), 99);
0647     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_PTR)), 17);
0648     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_PTR)), 12312);
0649     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_STRING_FLD, 0, 0, BFLD_PTR)), 0);
0650     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_PTR)), 0);
0651
0652
0653     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_PTR_FLD, 0, 0, BFLD_PTR)), 9000);
0654     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, 0, BFLD_PTR), NULL);
0655     assert_equal(Berror, BEBADOP);
0656     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, 0, BFLD_PTR), NULL);
0657     assert_equal(Berror, BEBADOP);
0658
0659
0660     len=0;
0661     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_SHORT_FLD, 0, &len, BFLD_PTR)), 88);
0662     assert_equal(len, sizeof(ndrx_longptr_t));
0663
0664     len=0;
0665     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_LONG_FLD, 0, &len, BFLD_PTR)), -1021);
0666     assert_equal(len, sizeof(ndrx_longptr_t));
0667
0668     len=0;
0669     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_CHAR_FLD, 0, &len, BFLD_PTR)), 99);
0670     assert_equal(len, sizeof(ndrx_longptr_t));
0671
0672     len=0;
0673     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_FLOAT_FLD, 0, &len, BFLD_PTR)), 17);
0674     assert_equal(len, sizeof(ndrx_longptr_t));
0675
0676     len=0;
0677     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_DOUBLE_FLD, 0, &len, BFLD_PTR)), 12312);
0678     assert_equal(len, sizeof(ndrx_longptr_t));
0679
0680     len=0;
0681     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_PTR)), 0);
0682     assert_equal(len, sizeof(ndrx_longptr_t));
0683
0684     len=0;
0685     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_CARRAY_FLD, 0, &len, BFLD_PTR)), 0);
0686     assert_equal(len, sizeof(ndrx_longptr_t));
0687
0688     len=0;
0689     assert_equal(*((ndrx_longptr_t *)CBfind(p_ub, T_PTR_FLD, 0, &len, BFLD_PTR)), 9000);
0690     assert_equal(len, sizeof(ndrx_longptr_t));
0691
0692     len=0;
0693     assert_equal(CBfind(p_ub, T_UBF_FLD, 0, &len, BFLD_PTR), NULL);
0694     assert_equal(Berror, BEBADOP);
0695
0696     len=0;
0697     assert_equal(CBfind(p_ub, T_VIEW_FLD, 0, &len, BFLD_PTR), NULL);
0698     assert_equal(Berror, BEBADOP);
0699
0700     len = 0;
0701
0702     /* Now test the thing that we have different pointers for each of the data type
0703      * also fields will corss match their types.
0704      */
0705     assert_not_equal((s=(short *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_SHORT)), NULL);
0706     assert_not_equal((l=(long *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_LONG)), NULL);
0707     assert_not_equal((c=(char *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_CHAR)), NULL);
0708     assert_not_equal((f=(float *)CBfind(p_ub, T_DOUBLE_FLD, 0, 0, BFLD_FLOAT)), NULL);
0709     assert_not_equal((d=(double *)CBfind(p_ub, T_FLOAT_FLD, 0, 0, BFLD_DOUBLE)), NULL);
0710     assert_not_equal((str=CBfind(p_ub, T_CARRAY_FLD, 0, 0, BFLD_STRING)), NULL);
0711     assert_not_equal((carr=CBfind(p_ub, T_STRING_FLD, 0, &len, BFLD_CARRAY)), NULL);
0712
0713     /* ? above is already tested.. */
0714
0715     /* Now compare the values */
0716     assert_equal(*s, 17);
0717     assert_equal(*l, 12312);
0718     assert_equal(*c, 17);
0719     assert_double_equal(*f, 12312.1111);
0720     assert_double_equal(*d, 17.31);
0721     assert_string_equal(str, "CARRAY1 TEST STRING DATA");
0722     assert_equal(len, 12);
0723     assert_equal(strncmp(carr, "TEST STR VAL", len), 0);
0724
0725     /* Now test the error case, when field is not found? */
0726     assert_equal(CBfind(p_ub, T_FLOAT_FLD, 10, 0, BFLD_SHORT), NULL);
0727     assert_equal(Berror, BNOTPRES);
0728
0729     /* try to get data from other occurrance */
0730     assert_double_equal(*(d=(double *)CBfind(p_ub, T_LONG_FLD, 4, 0, BFLD_DOUBLE)), 888);
0731
0732     /* Now play with big buffer data */
0733     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 4, BIG_TEST_STRING, strlen(BIG_TEST_STRING)),EXSUCCEED);
0734     /* now match the string */
0735     assert_string_equal((str=CBfind(p_ub, T_CARRAY_2_FLD, 4, 0, BFLD_STRING)), BIG_TEST_STRING);
0736
0737     assert_equal(CBfind(p_ub, BBADFLDID, 0, 0, BFLD_LONG), NULL);
0738     assert_equal(Berror,BBADFLD);
0739 }
0740
0741 /**
0742  * Get occurrence out from value.
0743  */
0744 Ensure(test_bfindocc)
0745 {
0746     char fb[2048];
0747     UBFH *p_ub = (UBFH *)fb;
0748     short s;
0749     long l;
0750     char c;
0751     float f;
0752     double d;
0753     char *str;
0754     char *carr;
0755     BFLDLEN len=0;
0756     ndrx_longptr_t ptr;
0757
0758     char buf_tmp[1024];
0759     UBFH *p_ub_tmp = (UBFH *)buf_tmp;
0760     BVIEWFLD vf;
0761
0762     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0763     load_bfindocc_test_data(p_ub);
0764
0765     s = 88;
0766     l = -1021;
0767     c = '.';
0768     f = 17.31;
0769     d = 12312.1111;
0770     str = "TEST STRING ARRAY2";
0771     carr = "\0ARRAY1 TEST STRING DATA";
0772     ptr = 9004;
0773     assert_equal(Bfindocc(p_ub, T_SHORT_FLD, (char*) &s, 0),1);
0774     assert_equal(Bfindocc(p_ub, T_LONG_FLD, (char*) &l, 0),1);
0775     assert_equal(Bfindocc(p_ub, T_CHAR_FLD, (char*) &c, 0),1);
0776     assert_equal(Bfindocc(p_ub, T_FLOAT_FLD, (char*) &f, 0),1);
0777     assert_equal(Bfindocc(p_ub, T_DOUBLE_FLD, (char*) &d, 0),1);
0778     assert_equal(Bfindocc(p_ub, T_STRING_FLD, (char*) str, 0),1);
0779     assert_equal(Bfindocc(p_ub, T_CARRAY_FLD, (char*) carr, 24),1);
0780
0781     /* test for PTR, VIEW, UBF */
0782     assert_equal(Bfindocc(p_ub, T_PTR_FLD, (char*) &ptr, 0),1);
0783
0784     assert_equal(Binit(p_ub_tmp, sizeof(buf_tmp)), EXSUCCEED);
0785     gen_set_ubf_dbg(__FILE__, __LINE__, p_ub_tmp, 4);
0786     assert_equal(Bfindocc(p_ub, T_UBF_FLD, (char*)p_ub_tmp, 0),1);
0787
0788     gen_set_view_dbg(__FILE__, __LINE__, &vf, 4);
0789     assert_equal(Bfindocc(p_ub, T_VIEW_FLD, (char*)&vf, 0),1);
0790
0791     /* Now test first occurrence */
0792     s = 881;
0793     l = -1011;
0794     c = 'a';
0795     f = 1.31;
0796     d = 1312.1111;
0797     str = "TEST STR VAL";
0798     carr = "ZARRAY1 TEST STRING DATA";
0799
0800     assert_equal(Bfindocc(p_ub, T_SHORT_FLD, (char*) &s, 0),0);
0801     assert_equal(Bfindocc(p_ub, T_LONG_FLD, (char*) &l, 0),0);
0802     assert_equal(Bfindocc(p_ub, T_CHAR_FLD, (char*) &c, 0),0);
0803     assert_equal(Bfindocc(p_ub, T_FLOAT_FLD, (char*) &f, 0),0);
0804     assert_equal(Bfindocc(p_ub, T_DOUBLE_FLD, (char*) &d, 0),0);
0805     assert_equal(Bfindocc(p_ub, T_STRING_FLD, (char*) str, 0),0);
0806     assert_equal(Bfindocc(p_ub, T_CARRAY_FLD, (char*) carr, 24),0);
0807
0808     /* test for PTR, VIEW, UBF */
0809     ptr = 9003;
0810     assert_equal(Bfindocc(p_ub, T_PTR_FLD, (char*) &ptr, 0),0);
0811
0812     assert_equal(Binit(p_ub_tmp, sizeof(buf_tmp)), EXSUCCEED);
0813     gen_set_ubf_dbg(__FILE__, __LINE__, p_ub_tmp, 3);
0814     assert_equal(Bfindocc(p_ub, T_UBF_FLD, (char*)p_ub_tmp, 0),0);
0815
0816     gen_set_view_dbg(__FILE__, __LINE__, &vf, 3);
0817     assert_equal(Bfindocc(p_ub, T_VIEW_FLD, (char*)&vf, 0),0);
0818
0819     /* Test regexp version */
0820     assert_equal(Bchg(p_ub, T_STRING_FLD, 10, "A", 0), EXSUCCEED);
0821     assert_equal(Bchg(p_ub, T_STRING_FLD, 11, "ABC", 0), EXSUCCEED);
0822     assert_equal(Bchg(p_ub, T_STRING_FLD, 20, "TESTEST", 0), EXSUCCEED);
0823     assert_equal(Bfindocc(p_ub, T_STRING_FLD, "B|A", 1), 10);
0824     assert_equal(Bfindocc(p_ub, T_STRING_FLD, "A.C", 1), 11);
0825     assert_equal(Bfindocc(p_ub, T_STRING_FLD, "TESTEST(|\\(|", 1), -1);
0826     assert_equal(Bfindocc(p_ub, T_STRING_FLD, "TES....", 1), 20);
0827
0828     assert_equal(Bfindocc(p_ub, BBADFLDID, (char*) carr, 24),-1);
0829     assert_equal(Berror, BBADFLD);
0830
0831 }
0832
0833 /**
0834  * Get occurrence out from value (from user converted value)
0835  */
0836 Ensure(test_cbfindocc)
0837 {
0838     char fb[8192];
0839     UBFH *p_ub = (UBFH *)fb;
0840     short s;
0841     long l;
0842     char c;
0843     float f;
0844     double d;
0845     char *str;
0846     char *carr;
0847     BFLDLEN len=0;
0848     ndrx_longptr_t ptr;
0849
0850     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0851     load_find_test_data(p_ub);
0852
0853     /* Override some values for common test */
0854     assert_equal(CBchg(p_ub, T_LONG_FLD, 100, "251", 0, BFLD_STRING), EXSUCCEED);
0855     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 12, "102", 0, BFLD_STRING), EXSUCCEED);
0856     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 13, "99", 0, BFLD_STRING), EXSUCCEED);
0857     assert_equal(CBchg(p_ub, T_STRING_FLD, 14, "55", 0, BFLD_STRING), EXSUCCEED);
0858     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 15, "66", 0, BFLD_STRING), EXSUCCEED);
0859     assert_equal(CBchg(p_ub, T_PTR_FLD, 16, "0x77", 0, BFLD_STRING), EXSUCCEED);
0860
0861     gen_load_ubf(p_ub, 17, 10, 2);
0862     gen_load_view(p_ub, 18, 10, 2);
0863
0864
0865     /* Test as short */
0866     s=88;
0867     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&s, 0, BFLD_SHORT), 0);
0868     s=251;
0869     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&s, 0, BFLD_SHORT), 100);
0870     s=99;
0871     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&s, 0, BFLD_SHORT), 0);
0872     s=102;
0873     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&s, 0, BFLD_SHORT), 12);
0874     s=99;
0875     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&s, 0, BFLD_SHORT), 13);
0876     s=55;
0877     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&s, 0, BFLD_SHORT), 14);
0878     s=66;
0879     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&s, 0, BFLD_SHORT), 15);
0880     s=0x77;
0881     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&s, 0, BFLD_SHORT), 16);
0882
0883     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&s, 0, BFLD_SHORT), -1);
0884     assert_equal(Berror, BEBADOP);
0885     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&s, 0, BFLD_SHORT), -1);
0886     assert_equal(Berror, BEBADOP);
0887
0888
0889     /* Test as long */
0890     l=88;
0891     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&l, 0, BFLD_LONG), 0);
0892     l=251;
0893     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&l, 0, BFLD_LONG), 100);
0894     l=99;
0895     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&l, 0, BFLD_LONG), 0);
0896     l=102;
0897     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&l, 0, BFLD_LONG), 12);
0898     l=99;
0899     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&l, 0, BFLD_LONG), 13);
0900     l=55;
0901     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&l, 0, BFLD_LONG), 14);
0902     l=66;
0903     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&l, 0, BFLD_LONG), 15);
0904     l=0x77;
0905     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&l, 0, BFLD_LONG), 16);
0906
0907     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&l, 0, BFLD_LONG), -1);
0908     assert_equal(Berror, BEBADOP);
0909     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&l, 0, BFLD_LONG), -1);
0910     assert_equal(Berror, BEBADOP);
0911
0912
0913     /* Test as char */
0914     c=88;
0915     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&c, 0, BFLD_CHAR), 0);
0916     c=(char)251;
0917     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&c, 0, BFLD_CHAR), 100);
0918     c=99;
0919     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&c, 0, BFLD_CHAR), 0);
0920     c=102;
0921     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&c, 0, BFLD_CHAR), 12);
0922     c=99;
0923     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&c, 0, BFLD_CHAR), 13);
0924
0925     assert_equal(CBchg(p_ub, T_STRING_FLD, 14, "7", 0, BFLD_STRING), EXSUCCEED);
0926     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 15, "A", 0, BFLD_STRING), EXSUCCEED);
0927
0928     c=55;
0929     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&c, 0, BFLD_CHAR), 14);
0930     c=65;
0931     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&c, 0, BFLD_CHAR), 15);
0932     c=0x77;
0933     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&c, 0, BFLD_CHAR), 16);
0934
0935     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&c, 0, BFLD_CHAR), -1);
0936     assert_equal(Berror, BEBADOP);
0937     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&c, 0, BFLD_CHAR), -1);
0938     assert_equal(Berror, BEBADOP);
0939
0940
0941     assert_equal(CBchg(p_ub, T_STRING_FLD, 14, "55", 0, BFLD_STRING), EXSUCCEED);
0942     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 15, "66", 0, BFLD_STRING), EXSUCCEED);
0943
0944     /* Test as float */
0945     f=88;
0946     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&f, 0, BFLD_FLOAT), 0);
0947     f=251;
0948     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&f, 0, BFLD_FLOAT), 100);
0949     f=99;
0950     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&f, 0, BFLD_FLOAT), 0);
0951     f=102;
0952     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&f, 0, BFLD_FLOAT), 12);
0953     f=99;
0954     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&f, 0, BFLD_FLOAT), 13);
0955
0956     /* Due to string as float value after the comma, we cannot find such values */
0957     f=55;
0958     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&f, 0, BFLD_FLOAT), -1);
0959     f=66;
0960     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&f, 0, BFLD_FLOAT), -1);
0961
0962     f=0x77;
0963     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&f, 0, BFLD_FLOAT), 16);
0964
0965     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&f, 0, BFLD_FLOAT), -1);
0966     assert_equal(Berror, BEBADOP);
0967     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&f, 0, BFLD_FLOAT), -1);
0968     assert_equal(Berror, BEBADOP);
0969
0970
0971     /* Test as double */
0972     d=88;
0973     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&d, 0, BFLD_DOUBLE), 0);
0974     d=251;
0975     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&d, 0, BFLD_DOUBLE), 100);
0976     d=99;
0977     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&d, 0, BFLD_DOUBLE), 0);
0978     d=102;
0979     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&d, 0, BFLD_DOUBLE), 12);
0980     d=99;
0981     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&d, 0, BFLD_DOUBLE), 13);
0982
0983     /* Due to string as float value after the comma, we cannot find such values */
0984     d=55;
0985     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&d, 0, BFLD_DOUBLE), -1);
0986     d=66;
0987     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&d, 0, BFLD_DOUBLE), -1);
0988
0989     d=0x77;
0990     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&d, 0, BFLD_DOUBLE), 16);
0991
0992     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&d, 0, BFLD_DOUBLE), -1);
0993     assert_equal(Berror, BEBADOP);
0994     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&d, 0, BFLD_DOUBLE), -1);
0995     assert_equal(Berror, BEBADOP);
0996
0997
0998     /* Test as string */
0999     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, "88", 0, BFLD_STRING), 0);
1000     assert_equal(CBfindocc(p_ub, T_LONG_FLD, "251", 0, BFLD_STRING), 100);
1001     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, "c", 0, BFLD_STRING), 0);
1002     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, "102", 0, BFLD_STRING), 12);
1003     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, "99", 0, BFLD_STRING), 13);
1004     assert_equal(CBfindocc(p_ub, T_STRING_FLD, "55", 0, BFLD_STRING), 14);
1005     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, "66", 0, BFLD_STRING), 15);
1006
1007     assert_equal(CBfindocc(p_ub, T_PTR_FLD, "0x77", 0, BFLD_STRING), 16);
1008
1009     assert_equal(CBfindocc(p_ub, T_UBF_FLD, "0x77", 0, BFLD_STRING), -1);
1010     assert_equal(Berror, BEBADOP);
1011     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, "0x77", 0, BFLD_STRING), -1);
1012     assert_equal(Berror, BEBADOP);
1013
1014     /* Test as carray */
1015     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, "88", 2, BFLD_CARRAY), 0);
1016     assert_equal(CBfindocc(p_ub, T_LONG_FLD, "251", 3, BFLD_CARRAY), 100);
1017     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, "c", 1, BFLD_CARRAY), 0);
1018     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, "102", 3, BFLD_CARRAY), 12);
1019     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, "99", 2, BFLD_CARRAY), 13);
1020     assert_equal(CBfindocc(p_ub, T_STRING_FLD, "55", 2, BFLD_CARRAY), 14);
1021     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, "66", 2, BFLD_CARRAY), 15);
1022
1023     assert_equal(CBfindocc(p_ub, T_PTR_FLD, "0x77", 4, BFLD_CARRAY), 16);
1024
1025     assert_equal(CBfindocc(p_ub, T_UBF_FLD, "0x77", 4, BFLD_CARRAY), -1);
1026     assert_equal(Berror, BEBADOP);
1027     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, "0x77", 4, BFLD_CARRAY), -1);
1028     assert_equal(Berror, BEBADOP);
1029
1030     /* Test as ptr */
1031     ptr=88;
1032     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&ptr, 0, BFLD_PTR), 0);
1033     ptr=251;
1034     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&ptr, 0, BFLD_PTR), 100);
1035     ptr=99;
1036     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&ptr, 0, BFLD_PTR), 0);
1037     ptr=102;
1038     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&ptr, 0, BFLD_PTR), 12);
1039     ptr=99;
1040     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&ptr, 0, BFLD_PTR), 13);
1041     ptr=55;
1042     /* not found as ptr is built as 0x... */
1043     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&ptr, 0, BFLD_PTR), -1);
1044     ptr=66;
1045     /* not found as ptr is built as 0x... */
1046     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&ptr, 0, BFLD_PTR), -1);
1047     ptr=0x77;
1048     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&ptr, 0, BFLD_PTR), 16);
1049
1050     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&ptr, 0, BFLD_PTR), -1);
1051     assert_equal(Berror, BEBADOP);
1052     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&ptr, 0, BFLD_PTR), -1);
1053     assert_equal(Berror, BEBADOP);
1054
1055     /* test as UBF (use some ptr on input data, as there will be error anyway) */
1056     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1057     assert_equal(Berror, BEBADOP);
1058     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1059     assert_equal(Berror, BEBADOP);
1060     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1061     assert_equal(Berror, BEBADOP);
1062     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1063     assert_equal(Berror, BEBADOP);
1064     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1065     assert_equal(Berror, BEBADOP);
1066     /* not found as ptr is built as 0x... */
1067     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1068     assert_equal(Berror, BEBADOP);
1069     /* not found as ptr is built as 0x... */
1070     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1071     assert_equal(Berror, BEBADOP);
1072     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1073     assert_equal(Berror, BEBADOP);
1074     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1075     assert_equal(Berror, BEBADOP);
1076     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&ptr, 0, BFLD_UBF), -1);
1077     assert_equal(Berror, BEBADOP);
1078
1079     /* test as view */
1080     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1081     assert_equal(Berror, BEBADOP);
1082     assert_equal(CBfindocc(p_ub, T_LONG_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1083     assert_equal(Berror, BEBADOP);
1084     assert_equal(CBfindocc(p_ub, T_CHAR_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1085     assert_equal(Berror, BEBADOP);
1086     assert_equal(CBfindocc(p_ub, T_FLOAT_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1087     assert_equal(Berror, BEBADOP);
1088     assert_equal(CBfindocc(p_ub, T_DOUBLE_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1089     assert_equal(Berror, BEBADOP);
1090     /* not found as ptr is built as 0x... */
1091     assert_equal(CBfindocc(p_ub, T_STRING_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1092     assert_equal(Berror, BEBADOP);
1093     /* not found as ptr is built as 0x... */
1094     assert_equal(CBfindocc(p_ub, T_CARRAY_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1095     assert_equal(Berror, BEBADOP);
1096     assert_equal(CBfindocc(p_ub, T_PTR_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1097     assert_equal(Berror, BEBADOP);
1098     assert_equal(CBfindocc(p_ub, T_UBF_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1099     assert_equal(Berror, BEBADOP);
1100     assert_equal(CBfindocc(p_ub, T_VIEW_FLD, (char *)&ptr, 0, BFLD_VIEW), -1);
1101     assert_equal(Berror, BEBADOP);
1102
1103     /* Now test invalid argument */
1104     assert_equal(CBfindocc(p_ub, T_SHORT_FLD, "88", 2, 100), -1);
1105     assert_equal(Berror, BTYPERR);
1106 }
1107
1108 /**
1109  * Test Bfindlast
1110  */
1111 Ensure(test_bfindlast)
1112 {
1113     char fb[2048];
1114     UBFH *p_ub = (UBFH *)fb;
1115     short *s1;
1116     long *l1;
1117     char *c1;
1118     float *f1;
1119     double *d1;
1120     char *str1;
1121     char *carr1;
1122     BFLDLEN len=0;
1123     BFLDOCC occ=-1;
1124     ndrx_longptr_t *ptr;
1125     UBFH *p_ub_tmp = NULL;
1126     BVIEWFLD *vf;
1127
1128     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
1129     load_bfindlast_test_data(p_ub);
1130
1131     /* Test as short */
1132     occ=-1;
1133     assert_not_equal((s1=(short *)Bfindlast(p_ub, T_SHORT_FLD, &occ, 0)), NULL);
1134     assert_equal(*s1, 88);
1135     assert_equal(occ, 0);
1136
1137     /* Test as long */
1138     occ=-1;
1139     assert_not_equal((l1=(long *)Bfindlast(p_ub, T_LONG_FLD, &occ, 0)), NULL);
1140     assert_equal(*l1, -1021);
1141     assert_equal(occ, 1);
1142
1143      /* Test as char */
1144     occ=-1;
1145     assert_not_equal((c1=(char *)Bfindlast(p_ub, T_CHAR_FLD, &occ, 0)), NULL);
1146     assert_equal(*c1, 'c');
1147     assert_equal(occ, 2);
1148
1149     /* Test as float */
1150     occ=-1;
1151     assert_not_equal((f1=(float *)Bfindlast(p_ub, T_FLOAT_FLD, &occ, 0)), NULL);
1152     assert_double_equal(*f1, 17.31);
1153     assert_equal(occ, 3);
1154
1155     /* Test as double */
1156     occ=-1;
1157     assert_not_equal((d1=(double *)Bfindlast(p_ub, T_DOUBLE_FLD, &occ, 0)), NULL);
1158     assert_double_equal(*d1, 12312.1111);
1159     assert_equal(occ, 4);
1160
1161     /* Test as string */
1162     occ=-1;
1163     assert_not_equal((str1=Bfindlast(p_ub, T_STRING_FLD, &occ, 0)), NULL);
1164     assert_string_equal(str1, "TEST STR VAL");
1165     assert_equal(occ, 5);
1166
1167     /* Test as carray */
1168     len = 1000;
1169     occ=-1;
1170     assert_not_equal((carr1=Bfindlast(p_ub, T_CARRAY_FLD, &occ, &len)), NULL);
1171     assert_equal(len, 24);
1172     assert_equal(strncmp(carr1, "CARRAY1 TEST STRING DATA", 24), 0);
1173     assert_equal(occ, 6);
1174
1175     /* Test as PTR */
1176     len = 1000;
1177     occ=-1;
1178     assert_not_equal((ptr=(ndrx_longptr_t*)Bfindlast(p_ub, T_PTR_FLD, &occ, &len)), NULL);
1179     assert_equal(len, sizeof(ndrx_longptr_t));
1180     assert_equal(occ, 7);
1181     assert_equal(*ptr, 0x232e);
1182
1183     /* Test as UBF */
1184     len = 1000;
1185     occ=-1;
1186     assert_not_equal((p_ub_tmp=(UBFH*)Bfindlast(p_ub, T_UBF_FLD, &occ, &len)), NULL);
1187     assert_equal(occ, 8);
1188     gen_test_ubf_val_dbg(__FILE__, __LINE__, p_ub_tmp, 6, &len);
1189
1190     /* Test as VIEW */
1191     len = 1000;
1192     occ=-1;
1193     assert_not_equal((vf=(BVIEWFLD*)Bfindlast(p_ub, T_VIEW_FLD, &occ, &len)), NULL);
1194     assert_equal(occ, 9);
1195     gen_test_view_val_dbg(__FILE__, __LINE__, vf, 6, &len);
1196
1197     /* Test the case when data is not found! */
1198     occ=-1;
1199     assert_equal((str1=Bfindlast(p_ub, T_STRING_2_FLD, &occ, 0)), NULL);
1200     assert_equal(Berror, BNOTPRES);
1201     assert_equal(occ, -1);
1202 }
1203
1204 TestSuite *ubf_find_tests(void)
1205 {
1206     TestSuite *suite = create_test_suite();
1207
1208
1209     add_test(suite, test_bfind);
1210     add_test(suite, test_cbfind);
1211     add_test(suite, test_bfindocc);
1212     add_test(suite, test_cbfindocc);
1213     add_test(suite, test_bfindlast);
1214
1215     return suite;
1216 }
1217 /* vim: set ts=4 sw=4 et smartindent: */