source/ubftest/test_print.c

0001 /**
0002  *
0003  * @file test_print.c
0004  */
0005 /* -----------------------------------------------------------------------------
0006  * Enduro/X Middleware Platform for Distributed Transaction Processing
0007  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0008  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0009  * This software is released under one of the following licenses:
0010  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0011  * See LICENSE file for full text.
0012  * -----------------------------------------------------------------------------
0013  * AGPL license:
0014  *
0015  * This program is free software; you can redistribute it and/or modify it under
0016  * the terms of the GNU Affero General Public License, version 3 as published
0017  * by the Free Software Foundation;
0018  *
0019  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0020  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0021  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0022  * for more details.
0023  *
0024  * You should have received a copy of the GNU Affero General Public License along
0025  * with this program; if not, write to the Free Software Foundation, Inc.,
0026  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0027  *
0028  * -----------------------------------------------------------------------------
0029  * A commercial use license is available from Mavimax, Ltd
0030  * contact@mavimax.com
0031  * -----------------------------------------------------------------------------
0032  */
0033
0034 #include <stdio.h>
0035 #include <stdlib.h>
0036 #include <cgreen/cgreen.h>
0037 #include <ubf.h>
0038 #include <ndrstandard.h>
0039 #include <string.h>
0040 #include <unistd.h>
0041 #include "test.fd.h"
0042 #include "ubfunit1.h"
0043 #include "ndebug.h"
0044 #include "atmi_int.h"
0045
0046 /**
0047  * Reference output that should be printed to log file.
0048  */
0049 char *ref_print[]= {
0050 "T_SHORT_FLD\t88\n",
0051 "T_SHORT_FLD\t-1\n",
0052 "T_SHORT_2_FLD\t0\n",
0053 "T_SHORT_2_FLD\t212\n",
0054 "T_LONG_FLD\t-1021\n",
0055 "T_LONG_FLD\t-2\n",
0056 "T_LONG_FLD\t0\n",
0057 "T_LONG_FLD\t0\n",
0058 "T_LONG_FLD\t-4\n",
0059 "T_LONG_2_FLD\t0\n",
0060 "T_LONG_2_FLD\t0\n",
0061 "T_LONG_2_FLD\t212\n",
0062 "T_CHAR_FLD\t\\0a\n",
0063 "T_CHAR_FLD\t.\n",
0064 "T_CHAR_2_FLD\t\\00\n",
0065 "T_CHAR_2_FLD\t\\00\n",
0066 "T_CHAR_2_FLD\t\\00\n",
0067 "T_CHAR_2_FLD\tb\n",
0068 "T_FLOAT_FLD\t17.31000\n",
0069 "T_FLOAT_FLD\t1.31000\n",
0070 "T_FLOAT_2_FLD\t0.00000\n",
0071 "T_FLOAT_2_FLD\t0.00000\n",
0072 "T_FLOAT_2_FLD\t0.00000\n",
0073 "T_FLOAT_2_FLD\t0.00000\n",
0074 "T_FLOAT_2_FLD\t1227.00000\n",
0075 "T_DOUBLE_FLD\t12312.111100\n",
0076 "T_DOUBLE_FLD\t112.110000\n",
0077 "T_DOUBLE_2_FLD\t0.000000\n",
0078 "T_DOUBLE_2_FLD\t0.000000\n",
0079 "T_DOUBLE_2_FLD\t0.000000\n",
0080 "T_DOUBLE_2_FLD\t0.000000\n",
0081 "T_DOUBLE_2_FLD\t0.000000\n",
0082 "T_DOUBLE_2_FLD\t1232.100000\n",
0083 "T_STRING_FLD\tTEST STR VAL\n",
0084 "T_STRING_FLD\tTEST STRING ARRAY2\n",
0085 "T_STRING_2_FLD\t\n",
0086 "T_STRING_2_FLD\t\n",
0087 "T_STRING_2_FLD\t\n",
0088 "T_STRING_2_FLD\t\n",
0089 "T_STRING_2_FLD\t\n",
0090 "T_STRING_2_FLD\t\n",
0091 "T_STRING_2_FLD\tMEGA STR\\\\ING \\0a \\09 \\0d\n",
0092 "T_CARRAY_FLD\t\n",
0093 "T_CARRAY_FLD\tY\\01\\02\\03AY1 TEST \\\\STRING DATA\n",
0094 "T_CARRAY_2_FLD\t\n",
0095 "T_CARRAY_2_FLD\t\n",
0096 "T_CARRAY_2_FLD\t\n",
0097 "T_CARRAY_2_FLD\t\n",
0098 "T_CARRAY_2_FLD\t\n",
0099 "T_CARRAY_2_FLD\t\n",
0100 "T_CARRAY_2_FLD\t\n",
0101 "T_CARRAY_2_FLD\t\\00\\01\\02\\03AY1 TEST \\\\STRING DATA\n",
0102 "T_PTR_FLD\t0x2329\n",
0103 "T_PTR_FLD\t0x232a\n",
0104 "T_PTR_FLD\t0x0\n",
0105 "T_PTR_FLD\t0x0\n",
0106 "T_PTR_FLD\t0x0\n",
0107 "T_PTR_FLD\t0x0\n",
0108 "T_PTR_FLD\t0x0\n",
0109 "T_PTR_FLD\t0x232b\n",
0110 "T_UBF_FLD\t\n",
0111 "\tT_STRING_2_FLD\tT\n",
0112 "T_UBF_FLD\t\n",
0113 "\tT_STRING_3_FLD\tU\n",
0114 "T_UBF_FLD\t\n",
0115 "T_UBF_FLD\t\n",
0116 "T_UBF_FLD\t\n",
0117 "T_UBF_FLD\t\n",
0118 "T_UBF_FLD\t\n",
0119 "T_UBF_FLD\t\n",
0120 "T_UBF_FLD\t\n",
0121 "\tT_STRING_4_FLD\tV\n",
0122 "T_VIEW_FLD\tUBTESTVIEW2\n",
0123 "\ttshort1\t2\n",
0124 "\ttlong1\t3\n",
0125 "\ttchar1\t4\n",
0126 "\ttfloat1\t5.00000\n",
0127 "\ttdouble1\t6.000000\n",
0128 "\ttstring1\tB\n",
0129 "\ttcarray1\tD\\00\\09\\09\\09\\09\\09\\09\\09\\09\n",
0130 "T_VIEW_FLD\tUBTESTVIEW2\n",
0131 "\ttshort1\t3\n",
0132 "\ttlong1\t4\n",
0133 "\ttchar1\t5\n",
0134 "\ttfloat1\t6.00000\n",
0135 "\ttdouble1\t7.000000\n",
0136 "\ttstring1\tC\n",
0137 "\ttcarray1\tE\\00\\09\\09\\09\\09\\09\\09\\09\\09\n",
0138 "T_VIEW_FLD\t\n",
0139 "T_VIEW_FLD\t\n",
0140 "T_VIEW_FLD\t\n",
0141 "T_VIEW_FLD\t\n",
0142 "T_VIEW_FLD\t\n",
0143 "T_VIEW_FLD\t\n",
0144 "T_VIEW_FLD\t\n",
0145 "T_VIEW_FLD\tUBTESTVIEW2\n",
0146 "\ttshort1\t4\n",
0147 "\ttlong1\t5\n",
0148 "\ttchar1\t6\n",
0149 "\ttfloat1\t7.00000\n",
0150 "\ttdouble1\t8.000000\n",
0151 "\ttstring1\tD\n",
0152 "\ttcarray1\tF\\00\\09\\09\\09\\09\\09\\09\\09\\09\n",
0153 NULL
0154 };
0155
0156 /**
0157  * Prepare test data for print test.
0158  * @param p_ub
0159  */
0160 void load_print_test_data(UBFH *p_ub)
0161 {
0162     short s = 88;
0163     long l = -1021;
0164     char c = '\n';
0165     float f = 17.31;
0166     double d = 12312.1111;
0167     char carr[] = "CARRAY1 TEST \\STRING DATA";
0168     char string2[] = "MEGA STR\\ING \n \t \r";
0169     carr[0] = 0;
0170     carr[1] = 1;
0171     carr[2] = 2;
0172     carr[3] = 3;
0173     BFLDLEN len = strlen(carr);
0174
0175     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0176     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0177     assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0178     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0179     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0180     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0181     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0182
0183     gen_load_ptr(p_ub, 0, 1, 0);
0184     gen_load_ubf(p_ub, 0, 1, 0);
0185     gen_load_view(p_ub, 0, 1, 0);
0186
0187     /* Make second copy of field data (another for not equal test)*/
0188     s = -1;
0189     l = -2;
0190     c = '.';
0191     f = 1.31;
0192     d = 112.11;
0193     carr[0] = 'Y';
0194     len = strlen(carr);
0195
0196     assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&s, 0), EXSUCCEED);
0197     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0198     assert_equal(Bchg(p_ub, T_CHAR_FLD, 1, (char *)&c, 0), EXSUCCEED);
0199     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 1, (char *)&f, 0), EXSUCCEED);
0200     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 1, (char *)&d, 0), EXSUCCEED);
0201     assert_equal(Bchg(p_ub, T_STRING_FLD, 1, (char *)"TEST STRING ARRAY2", 0), EXSUCCEED);
0202     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 1, (char *)carr, len), EXSUCCEED);
0203
0204     gen_load_ptr(p_ub, 1, 2, 0);
0205     gen_load_ubf(p_ub, 1, 2, 0);
0206     gen_load_view(p_ub, 1, 2, 0);
0207
0208     l = -4;
0209     assert_equal(Bchg(p_ub, T_LONG_FLD, 4, (char *)&l, 0), EXSUCCEED);
0210
0211     s = 212;
0212     l = 212;
0213     c = 'b';
0214     f = 1227;
0215     d = 1232.1;
0216     carr[0] = 0;
0217     assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 1, (char *)&s, 0), EXSUCCEED);
0218     assert_equal(Bchg(p_ub, T_LONG_2_FLD, 2, (char *)&l, 0), EXSUCCEED);
0219     assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 3, (char *)&c, 0), EXSUCCEED);
0220     assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 4, (char *)&f, 0), EXSUCCEED);
0221     assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 5, (char *)&d, 0), EXSUCCEED);
0222     assert_equal(Bchg(p_ub, T_STRING_2_FLD, 6, (char *)string2, 0), EXSUCCEED);
0223     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 7, (char *)carr, len), EXSUCCEED);
0224
0225     gen_load_ptr(p_ub, 7, 3, 0);
0226     gen_load_ubf(p_ub, 8, 3, 0);
0227     gen_load_view(p_ub, 9, 3, 0);
0228
0229 }
0230
0231 /**
0232  * Bfprint testing.
0233  * @return
0234  */
0235 Ensure(test_bfprint)
0236 {
0237     char fb[4096];
0238     UBFH *p_ub = (UBFH *)fb;
0239     BFLDLEN len=0;
0240     FILE *f=NULL;
0241     char filename[]="/tmp/ubf-test-XXXXXX";
0242     char readbuf[1024];
0243     int line_counter=0;
0244     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0245
0246     load_print_test_data(p_ub);
0247     load_field_table();
0248     assert_not_equal(mkstemp(filename), EXFAIL);
0249     assert_not_equal((f=fopen(filename, "w")), NULL);
0250     assert_equal(Bfprint(p_ub, f), EXSUCCEED);
0251     fclose(f);
0252
0253     /* Re-open file in read mode end re-compare the buffer. */
0254     assert_not_equal((f=fopen(filename, "r")), NULL);
0255
0256     /* compare the buffers */
0257     while(NULL!=fgets(readbuf, sizeof(readbuf), f))
0258     {
0259         if (NULL==ref_print[line_counter])
0260         {
0261             /* reached end of our knowledge of the test data */
0262             assert_equal_with_message(0, 1, "output file too big!");
0263             break;
0264         }
0265         assert_string_equal(ref_print[line_counter], readbuf);
0266         line_counter++;
0267     }
0268     fclose(f);
0269
0270     /* remove the file */
0271     assert_equal(unlink(filename), EXSUCCEED);
0272
0273     /* cannot print on null file */
0274     assert_equal(Bfprint(p_ub, NULL), EXFAIL);
0275     assert_equal(Berror, BEINVAL);
0276
0277 }
0278
0279 /**
0280  * Test data holder for bfprintcb_data
0281  */
0282 typedef struct bfprintcb_data bfprintcb_data_t;
0283 struct bfprintcb_data
0284 {
0285     int nrlines;
0286     char lines[1024][100];
0287 };
0288
0289 /**
0290  * Write callback, this will fill in passed array
0291  * @param buffer, we may realloc
0292  * @param datalen output data len
0293  * @param dataptr1 custom pointer
0294  * @param do_write shall the Enduro/X wirte to output log..
0295  * @param outf output stream currencly used
0296  * @param fid field it processing
0297  * @return
0298  */
0299 exprivate int test_bfprintcb_writef(char **buffer, long datalen, void *dataptr1,
0300         int *do_write, FILE *outf, BFLDID fid)
0301 {
0302     bfprintcb_data_t *data = (bfprintcb_data_t *)dataptr1;
0303
0304     assert_equal(strlen(*buffer)+1, datalen);
0305
0306     NDRX_STRCPY_SAFE(data->lines[data->nrlines], *buffer);
0307     data->nrlines++;
0308     return EXSUCCEED;
0309 }
0310
0311 /**
0312  * Bfprintcb testing (i.e. callback testing...)
0313  * @return
0314  */
0315 Ensure(test_bfprintcb)
0316 {
0317     char fb[4096];
0318     UBFH *p_ub = (UBFH *)fb;
0319     bfprintcb_data_t data;
0320     int line_counter=0;
0321     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0322
0323     memset(&data, 0, sizeof(data));
0324     load_print_test_data(p_ub);
0325     load_field_table();
0326
0327     assert_equal(Bfprintcb(p_ub, test_bfprintcb_writef, (void *)&data), EXSUCCEED);
0328     UBF_LOG(log_error, "Bfprintcb: %s", Bstrerror(Berror));
0329
0330     /* compare the buffers */
0331     for (line_counter=0; line_counter<N_DIM(ref_print)-1; line_counter++)
0332     {
0333         UBF_LOG(log_debug, "Got line [%s]", data.lines[line_counter]);
0334         assert_string_equal(data.lines[line_counter], ref_print[line_counter]);
0335         line_counter++;
0336     }
0337
0338     assert_equal(data.nrlines, N_DIM(ref_print)-1);
0339
0340     /* cannot print on null file */
0341     assert_equal(Bfprintcb(p_ub, NULL, NULL), EXFAIL);
0342     assert_equal(Berror, BEINVAL);
0343
0344 }
0345
0346 /**
0347  * Test bprint
0348  * There is special note for this!
0349  * If running in single test mode, then STDOUT will be lost!
0350  */
0351 Ensure(test_bprint)
0352 {
0353     char fb[4096];
0354     UBFH *p_ub = (UBFH *)fb;
0355     char fb2[4096];
0356     UBFH *p_ub2 = (UBFH *)fb2;
0357     BFLDLEN len=0;
0358     FILE *f;
0359     double double_val=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0360     float float_val=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0361     int fstdout;
0362     char filename[]="/tmp/ubf-test-XXXXXX";
0363
0364     /* Test float & double overflow */
0365     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0366     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&float_val, 0), EXSUCCEED);
0367     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&double_val, 0), EXSUCCEED);
0368     assert_equal(Bprint(p_ub), 0);
0369
0370
0371     assert_not_equal(mkstemp(filename), EXFAIL);
0372     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0373     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
0374
0375     load_print_test_data(p_ub);
0376     /* nothing much to test here... */
0377     close(1); /* close stdout */
0378     assert_not_equal((f=fopen(filename, "w")), NULL);
0379     fstdout = dup2(fileno(f), 1); /* make file appear as stdout */
0380     assert_equal(Bprint(p_ub), 0);
0381     fclose(f);
0382
0383     /* OK, if we have that output, try to extread it! */
0384     assert_not_equal((f=fopen(filename, "r")), NULL);
0385
0386     assert_equal(Bextread(p_ub2, f), EXSUCCEED);
0387     /* compare read buffer */
0388     assert_equal(Bcmp(p_ub, p_ub2), 0);
0389     /* Remove test file */
0390     assert_equal(unlink(filename), EXSUCCEED);
0391
0392 }
0393
0394 /**
0395  * Test function for Bextread, using field IDs (not present in table)
0396  */
0397 Ensure(test_bextread_bfldid)
0398 {
0399     char fb[4096];
0400     UBFH *p_ub = (UBFH *)fb;
0401     char fb2[4096];
0402     UBFH *p_ub2 = (UBFH *)fb2;
0403
0404     BFLDLEN len=0;
0405     FILE *f;
0406     char filename[]="/tmp/ubf-test-XXXXXX";
0407
0408     memset(fb, 6, sizeof(fb));
0409     memset(fb2, 6, sizeof(fb2));
0410
0411     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0412     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
0413
0414     UBF_LOG(log_debug, "****** load_print_test_data ******");
0415     load_print_test_data(p_ub);
0416     UBF_LOG(log_debug, "****** set_up_dummy_data ******");
0417     set_up_dummy_data(p_ub);
0418
0419     assert_not_equal(mkstemp(filename), EXFAIL);
0420
0421     assert_not_equal((f=fopen(filename, "w")), NULL);
0422
0423     UBF_LOG(log_debug, "****** Bfprint ******");
0424     assert_equal(Bfprint(p_ub, f), EXSUCCEED);
0425     fclose(f);
0426
0427     /* read stuff form file */
0428     assert_not_equal((f=fopen(filename, "r")), NULL);
0429     UBF_LOG(log_debug, "****** Bextread ******");
0430     assert_equal(Bextread(p_ub2, f), EXSUCCEED);
0431     fclose(f);
0432
0433
0434     /* compare readed buffer */
0435     UBF_LOG(log_debug, "****** Bcmp ******");
0436     assert_equal(Bcmp(p_ub2, p_ub2), 0);
0437     assert_equal(Bcmp(p_ub, p_ub), 0);
0438     assert_equal(Bcmp(p_ub, p_ub2), 0);
0439     /* Remove test file */
0440     assert_equal(unlink(filename), EXSUCCEED);
0441 }
0442
0443 /**
0444  * Test function for Bextread, using field names
0445  */
0446 Ensure(test_bextread_fldnm)
0447 {
0448     char fb[4096];
0449     UBFH *p_ub = (UBFH *)fb;
0450     char fb2[4096];
0451     UBFH *p_ub2 = (UBFH *)fb2;
0452
0453     BFLDLEN len=0;
0454     FILE *f;
0455     char filename[]="/tmp/ubf-test-XXXXXX";
0456
0457     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0458     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
0459
0460     load_print_test_data(p_ub);
0461     set_up_dummy_data(p_ub);
0462     load_field_table();
0463
0464     assert_not_equal(mkstemp(filename), EXFAIL);
0465     assert_not_equal((f=fopen(filename, "w")), NULL);
0466     assert_equal(Bfprint(p_ub, f), EXSUCCEED);
0467     fclose(f);
0468
0469     /* read stuff form file */
0470     assert_not_equal((f=fopen(filename, "r")), NULL);
0471     assert_equal(Bextread(p_ub2, f), EXSUCCEED);
0472     fclose(f);
0473
0474     /* compare readed buffer */
0475     assert_equal(Bcmp(p_ub, p_ub2), 0);
0476     /* Remove test file */
0477     assert_equal(unlink(filename), EXSUCCEED);
0478 }
0479
0480 /**
0481  * Return the buffer line
0482  * @param buffer buffer to put in the result. Note that is should go line by line
0483  * @param bufsz buffer size
0484  * @param dataptr1 user data ptr
0485  * @return number of bytes written to buffer
0486  */
0487 exprivate long bextreadcb_readf(char *buffer, long bufsz, void *dataptr1)
0488 {
0489     int *idx = (int *)dataptr1;
0490
0491     char *data_buffers[]= {
0492         "T_SHORT_FLD\t88\n",
0493         "T_SHORT_FLD\t-1\n",
0494         "T_SHORT_2_FLD\t0\n",
0495         "T_SHORT_2_FLD\t212\n",
0496         "T_LONG_FLD\t-1021\n",
0497         "T_LONG_FLD\t-2\n",
0498         "T_LONG_FLD\t0\n",
0499         "T_LONG_FLD\t0\n", /* <<< error line */
0500         NULL
0501     };
0502
0503     if (NULL!=data_buffers[*idx])
0504     {
0505         NDRX_STRCPY_SAFE_DST(buffer, data_buffers[*idx], bufsz);
0506
0507         (*idx)++;
0508         return strlen(buffer)+1;
0509     }
0510     else
0511     {
0512         return 0;
0513     }
0514 }
0515
0516 /**
0517  * Test extread with callbacks
0518  */
0519 Ensure(test_bextreadcb)
0520 {
0521     char fb[2048];
0522     UBFH *p_ub = (UBFH *)fb;
0523     int idx = 0;
0524     char *tree;
0525
0526     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0527     assert_equal(Bextreadcb(p_ub, bextreadcb_readf, (void *)&idx), EXSUCCEED);
0528
0529     /* test with boolean expression */
0530     tree = Bboolco("T_SHORT_FLD == 88 && T_SHORT_FLD[1] == -1 && T_SHORT_2_FLD==0 "
0531             "&& T_SHORT_2_FLD[1]==212 && T_LONG_FLD==-1021 && T_LONG_FLD[1]==-2 "
0532             "&& T_LONG_FLD[2]==0 && T_LONG_FLD[3]==0");
0533
0534     assert_not_equal(tree, NULL);
0535
0536     assert_equal(Bboolev(p_ub, tree), EXTRUE);
0537
0538     Btreefree(tree);
0539
0540 }
0541
0542 /**
0543  * Testing extread for errors
0544  */
0545 Ensure(test_bextread_chk_errors)
0546 {
0547     char fb[2048];
0548     UBFH *p_ub = (UBFH *)fb;
0549
0550     char *missing_new_line_at_end[]= {
0551         "T_SHORT_FLD\t88\n",
0552         "T_SHORT_FLD\t-1\n",
0553         "T_SHORT_2_FLD\t0\n",
0554         "T_SHORT_2_FLD\t212\n",
0555         "T_LONG_FLD\t-1021\n",
0556         "T_LONG_FLD\t-2\n",
0557         "T_LONG_FLD\t0\n",
0558         "T_LONG_FLD\t0", /* <<< error line */
0559         NULL
0560     };
0561
0562     char *no_field_name[]= {
0563         "T_SHORT_FLD\t-1\n",
0564         "\t0\n", /* <<< error line */
0565         "T_SHORT_2_FLD\t212\n",
0566         "T_LONG_FLD\t-1021\n",
0567         "T_LONG_FLD\t-2\n",
0568         "T_LONG_FLD\t0\n",
0569         "T_LONG_FLD\t0\n",
0570         NULL
0571     };
0572
0573     char *no_value_seperator[]= {
0574         "T_SHORT_FLD\t-1\n",
0575         "T_SHORT_2_FLD\t212\n",
0576         "T_LONG_FLD\t-1021\n",
0577         "T_LONG_FLD -2\n",/* <<< error line */
0578         "T_LONG_FLD\t0\n",
0579         "T_LONG_FLD\t0\n",
0580         NULL
0581     };
0582
0583     char *prefix_error_hex[]= {
0584         "T_SHORT_FLD\t-1\n",
0585         "T_SHORT_2_FLD\t212\n",
0586         "T_LONG_FLD\t-1021\n",
0587         "T_LONG_FLD\t0\n",
0588         "T_LONG_FLD\t0\n",
0589         "T_STRING_FLD\t\\\n", /* <<< error on this line, strange prefixing.*/
0590         NULL
0591     };
0592
0593     char *invalid_hex_number[]= {
0594         "T_SHORT_FLD\t-1\n",
0595         "T_SHORT_2_FLD\t212\n",
0596         "T_LONG_FLD\t-1021\n",
0597         "T_LONG_FLD\t0\n",
0598         "T_LONG_FLD\t0\n",
0599         "T_STRING_FLD\tabc\\yu123\n", /* <<< error on this line, strange prefixing.*/
0600         NULL
0601     };
0602
0603     char *empty_line_error[]= {
0604         "\n", /* <<< fail on empty line */
0605         NULL
0606     };
0607
0608     char *invalid_field_id[]= {
0609         "T_SHORT_FLD\t-1\n",
0610         "IVALID_FIELD_NAME\t212\n", /* <<< error on this line */
0611         NULL
0612     };
0613
0614     char *invalid_field_id_syntax[]= {
0615         "T_SHORT_FLD\t-1\n",
0616         "((BFLDID32)4294967295)\t212\n", /* <<< error on this line */
0617         NULL
0618     };
0619
0620     /* Check view does not exists */
0621     char *invalid_view[]= {
0622         "T_VIEW_FLD\tNO_SUCH_VIEW\n",
0623         NULL
0624     };
0625
0626     /* Check subfield for non-non ubf type */
0627     char *invalid_sub_buffer[]= {
0628         "T_STRING_FLD\t\n",
0629         "\tT_STRING_FLD\tXXX\n",
0630         "\tT_STRING_FLD\tYYY\n",
0631         NULL
0632     };
0633
0634     /* load field table */
0635     load_field_table();
0636
0637     /*--------------------------------------------------------*/
0638     /* test the newline is missing at the end */
0639     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0640     open_test_temp("w");
0641     write_to_temp(missing_new_line_at_end);
0642     close_test_temp();
0643
0644     /* file not opened - unix error - might cause double free!?!? */
0645     /*M_test_temp_file=NULL;
0646     assert_equal(Bextread(p_ub, M_test_temp_file), FAIL);
0647     assert_equal(Berror, BEUNIX);
0648      */
0649
0650     /* syntax error should fail */
0651     open_test_temp_for_read("r");
0652     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0653     assert_equal(Berror, BSYNTAX);
0654     close_test_temp();
0655
0656     /* now open the file */
0657     remove_test_temp();
0658     /*--------------------------------------------------------*/
0659     /* test the newline is missing at the end */
0660     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0661     open_test_temp("w");
0662     write_to_temp(no_field_name);
0663     close_test_temp();
0664
0665     /* syntax error should fail */
0666     open_test_temp_for_read("r");
0667     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0668     assert_equal(Berror, BSYNTAX);
0669     close_test_temp();
0670
0671     /* now open the file */
0672     remove_test_temp();
0673     /*--------------------------------------------------------*/
0674     /* test the newline is missing at the end */
0675     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0676     open_test_temp("w");
0677     write_to_temp(no_value_seperator);
0678     close_test_temp();
0679
0680     /* syntax error should fail */
0681     open_test_temp_for_read("r");
0682     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0683     assert_equal(Berror, BSYNTAX);
0684     close_test_temp();
0685
0686     /* now open the file */
0687     remove_test_temp();
0688     /*--------------------------------------------------------*/
0689     /* test bad prefixing */
0690     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0691     open_test_temp("w");
0692     write_to_temp(prefix_error_hex);
0693     close_test_temp();
0694
0695     /* syntax error should fail */
0696     open_test_temp_for_read("r");
0697     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0698     assert_equal(Berror, BSYNTAX);
0699     close_test_temp();
0700
0701     /* now open the file */
0702     remove_test_temp();
0703     /*--------------------------------------------------------*/
0704     /* invalid hex number provided */
0705     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0706     open_test_temp("w");
0707     write_to_temp(invalid_hex_number);
0708     close_test_temp();
0709
0710     /* syntax error should fail */
0711     open_test_temp_for_read("r");
0712     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0713     assert_equal(Berror, BSYNTAX);
0714     close_test_temp();
0715
0716     /* now open the file */
0717     remove_test_temp();
0718     /*--------------------------------------------------------*/
0719     /* Empty line also is not supported */
0720     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0721     open_test_temp("w");
0722     write_to_temp(empty_line_error);
0723     close_test_temp();
0724
0725     /* syntax error should fail */
0726     /* to be backwards compatible we just ignore this stuff... */
0727     open_test_temp_for_read("r");
0728     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
0729     /* assert_equal(Berror, BSYNTAX); */
0730     close_test_temp();
0731     /* now open the file */
0732     remove_test_temp();
0733     /*--------------------------------------------------------*/
0734     /* Field id not found */
0735     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0736     open_test_temp("w");
0737     write_to_temp(invalid_field_id);
0738     close_test_temp();
0739
0740     /* syntax error should fail */
0741     open_test_temp_for_read("r");
0742     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0743     assert_equal(Berror, BBADNAME);
0744     close_test_temp();
0745     /* now open the file */
0746     remove_test_temp();
0747     /*--------------------------------------------------------*/
0748     /* Invalid bfldid syntax */
0749     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0750     open_test_temp("w");
0751     write_to_temp(invalid_field_id_syntax);
0752     close_test_temp();
0753
0754     /* syntax error should fail */
0755     open_test_temp_for_read("r");
0756     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0757     assert_equal(Berror, BBADFLD);
0758     close_test_temp();
0759     /* now open the file */
0760     remove_test_temp();
0761
0762     /*--------------------------------------------------------*/
0763     /* Invalid view */
0764     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0765     open_test_temp("w");
0766     write_to_temp(invalid_view);
0767     close_test_temp();
0768
0769     /* syntax error should fail */
0770     open_test_temp_for_read("r");
0771     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0772     assert_equal(Berror, BBADVIEW);
0773     close_test_temp();
0774     /* now open the file */
0775     remove_test_temp();
0776
0777
0778     /*--------------------------------------------------------*/
0779     /* Invalid sub-buffer */
0780     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0781     open_test_temp("w");
0782     write_to_temp(invalid_sub_buffer);
0783     close_test_temp();
0784
0785     /* syntax error should fail */
0786     open_test_temp_for_read("r");
0787     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
0788     assert_equal(Berror, BSYNTAX);
0789     close_test_temp();
0790     /* now open the file */
0791     remove_test_temp();
0792
0793
0794 }
0795
0796 /**
0797  * Testing extread for errors
0798  */
0799 Ensure(test_bextread_comments)
0800 {
0801     char fb[2048];
0802     UBFH *p_ub = (UBFH *)fb;
0803     short s;
0804     long l;
0805
0806     char *comment_test[]= {
0807         "T_SHORT_FLD\t88\n",
0808         "#T_SHORT_2_FLD\t212\n",
0809         "#T_STRING_FLD\t-1021\n",
0810         "#T_STRING_FLD\t-2\n",
0811         "T_LONG_FLD\t-1\n",
0812         NULL
0813     };
0814
0815     /* load field table */
0816     load_field_table();
0817
0818     /*--------------------------------------------------------*/
0819     /* Testing comment. */
0820     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0821     open_test_temp("w");
0822     write_to_temp(comment_test);
0823     close_test_temp();
0824
0825     open_test_temp_for_read("r");
0826     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
0827
0828     /* Ensure that fields are missing */
0829     assert_equal(Bpres(p_ub, T_SHORT_2_FLD, 0), EXFALSE);
0830     assert_equal(Bpres(p_ub, T_STRING_FLD, 0), EXFALSE);
0831     assert_equal(Bpres(p_ub, T_STRING_FLD, 1), EXFALSE);
0832
0833     /* Ensure that we have what we expect */
0834     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0835     assert_equal(s, 88);
0836     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0837     assert_equal(l, -1);
0838     close_test_temp();
0839
0840     /* now open the file */
0841     remove_test_temp();
0842 }
0843
0844 /**
0845  * Test - flag for buffer delete
0846  */
0847 Ensure(test_bextread_minus)
0848 {
0849     char fb[2048];
0850     UBFH *p_ub = (UBFH *)fb;
0851     char fb2[2048];
0852     UBFH *p_ub2 = (UBFH *)fb2;
0853     short s;
0854     long l;
0855
0856     char *test_minus[]= {
0857         "T_SHORT_FLD\t123\n",
0858         "T_DOUBLE_FLD\t0.1\n",
0859         "T_CARRAY_FLD\tABCDE\n",
0860         "T_STRING_FLD\tTEST_STRING\n",
0861         "T_FLOAT_FLD\t1\n",
0862         "T_PTR_FLD\t0x1111\n",
0863         "T_UBF_FLD\t\n",
0864         "\tT_STRING_FLD\tHELLO\n",
0865         "T_VIEW_FLD\t\n",
0866         "- T_CARRAY_FLD\tABCDE\n",
0867         "- T_STRING_FLD\tTEST_STRING\n",
0868         "- T_PTR_FLD\t0x0\n",
0869         "- T_UBF_FLD\t\n",
0870         "- T_VIEW_FLD\t\n",
0871         NULL
0872     };
0873
0874     /* load field table */
0875     load_field_table();
0876
0877     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0878     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
0879     open_test_temp("w");
0880     write_to_temp(test_minus);
0881     close_test_temp();
0882
0883     open_test_temp_for_read("r");
0884     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
0885     close_test_temp();
0886
0887     /* now open the file */
0888     remove_test_temp();
0889
0890     /* Load reference data into buffer 2 */
0891     assert_equal(CBchg(p_ub2, T_SHORT_FLD, 0, "123", 0, BFLD_STRING), EXSUCCEED);
0892     assert_equal(CBchg(p_ub2, T_DOUBLE_FLD, 0, "0.1", 0, BFLD_STRING), EXSUCCEED);
0893     assert_equal(CBchg(p_ub2, T_FLOAT_FLD, 0, "1", 0, BFLD_STRING), EXSUCCEED);
0894
0895     /* Compare buffers now should be equal */
0896     assert_equal(Bcmp(p_ub, p_ub2), 0);
0897 }
0898
0899 /**
0900  * Test - flag for buffer delete
0901  */
0902 Ensure(test_bextread_plus)
0903 {
0904     char fb[2048];
0905     UBFH *p_ub = (UBFH *)fb;
0906     char fb2[2048];
0907     UBFH *p_ub2 = (UBFH *)fb2;
0908     short s;
0909     long l;
0910
0911     /* Check with sub-fields */
0912     char *test_plus[]= {
0913         "T_SHORT_FLD\t999\n",
0914         "T_DOUBLE_FLD\t888\n",
0915         "T_FLOAT_FLD\t777.11\n",
0916         "T_STRING_FLD\tABC\n",
0917         "T_PTR_FLD\t0x0\n",
0918         "T_UBF_FLD\t\n",
0919         "T_VIEW_FLD\t\n",
0920         "+ T_SHORT_FLD\t123\n",
0921         "+ T_DOUBLE_FLD\t0.1\n",
0922         "+ T_FLOAT_FLD\t1\n",
0923         "+ T_STRING_FLD\tCDE\n",
0924         "+ T_PTR_FLD\t0x2329\n",
0925         /* Set empty, override with real values */
0926         "+ T_UBF_FLD\t\n",
0927     "\tT_STRING_2_FLD\tZ\n",
0928         "\t+ T_STRING_2_FLD\tT\n", /* so root level shall get U */
0929         "+ T_VIEW_FLD\tUBTESTVIEW2\n",
0930         "\ttshort1\t1\n",
0931     "\ttlong1\t2\n",
0932     "\ttchar1\t3\n",
0933     "\ttfloat1\t4.00000\n",
0934     "\ttdouble1\t5.000000\n",
0935     "\ttstring1\tg\n",
0936     "\ttcarray1\tg\\00\\00\\00\\00\\00\\00\\00\\00\\00\n",
0937     "\t+ tshort1\t2\n",
0938     "\t+ tlong1\t3\n",
0939     "\t+ tchar1\t4\n",
0940     "\t+ tfloat1\t5.00000\n",
0941     "\t+ tdouble1\t6.000000\n",
0942     "\t+ tstring1\tB\n",
0943     "\t+ tcarray1\tD\\00\\09\\09\\09\\09\\09\\09\\09\\09\n",
0944         NULL
0945     };
0946
0947     /* load field table */
0948     load_field_table();
0949
0950     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0951     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
0952     open_test_temp("w");
0953     write_to_temp(test_plus);
0954     close_test_temp();
0955
0956     open_test_temp_for_read("r");
0957     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
0958     close_test_temp();
0959     /* now open the file */
0960     remove_test_temp();
0961
0962     /* Load reference data into buffer 2 */
0963     assert_equal(CBchg(p_ub2, T_SHORT_FLD, 0, "123", 0, BFLD_STRING), EXSUCCEED);
0964     assert_equal(CBchg(p_ub2, T_DOUBLE_FLD, 0, "0.1", 0, BFLD_STRING), EXSUCCEED);
0965     assert_equal(CBchg(p_ub2, T_FLOAT_FLD, 0, "1", 0, BFLD_STRING), EXSUCCEED);
0966     assert_equal(CBchg(p_ub2, T_STRING_FLD, 0, "CDE", 0, BFLD_STRING), EXSUCCEED);
0967
0968     /* load occ1 ptr/ubf/view */
0969     gen_load_ptr(p_ub2, 0, 1, 0);
0970     gen_load_ubf(p_ub2, 0, 1, 0);
0971     gen_load_view(p_ub2, 0, 1, 0);
0972
0973     /* Compare buffers now should be equal */
0974     assert_equal(Bcmp(p_ub, p_ub2), 0);
0975 }
0976
0977
0978 /**
0979  * Test - Test buffer EQ op
0980  */
0981 Ensure(test_bextread_eq)
0982 {
0983     char fb[2048];
0984     UBFH *p_ub = (UBFH *)fb;
0985     char fb2[2048];
0986     UBFH *p_ub2 = (UBFH *)fb2;
0987     short s;
0988     long l;
0989
0990     /* TODO: CHeck with sub-fields */
0991     char *test_eq[]= {
0992         "T_SHORT_FLD\t999\n",
0993         "T_LONG_FLD\t124545\n",
0994         "T_CHAR_FLD\ta\n",
0995         "T_DOUBLE_FLD\t888\n",
0996         "T_FLOAT_FLD\t777.11\n",
0997         "T_STRING_FLD\tABC\n",
0998         "T_CARRAY_FLD\tEFGH\n",
0999         "T_PTR_FLD\t0x2329\n",
1000         "T_UBF_FLD\t\n",
1001         "\tT_STRING_2_FLD\tT\n",
1002         "T_VIEW_FLD\tUBTESTVIEW2\n",
1003         "\ttshort1\t2\n",
1004         "\ttlong1\t3\n",
1005         "\ttchar1\t4\n",
1006         "\ttfloat1\t5.00000\n",
1007         "\ttdouble1\t6.000000\n",
1008         "\ttstring1\tB\n",
1009         "\ttcarray1\tD\\00\\09\\09\\09\\09\\09\\09\\09\\09\n",
1010         /* Value will be copied to FLD2 */
1011         "= T_SHORT_2_FLD\tT_SHORT_FLD\n",
1012         "= T_LONG_2_FLD\tT_LONG_FLD\n",
1013         "= T_CHAR_2_FLD\tT_CHAR_FLD\n",
1014         "= T_DOUBLE_2_FLD\tT_DOUBLE_FLD\n",
1015         "= T_FLOAT_2_FLD\tT_FLOAT_FLD\n",
1016         "= T_STRING_2_FLD\tT_STRING_FLD\n",
1017         "= T_CARRAY_2_FLD\tT_CARRAY_FLD\n",
1018         "= T_PTR_2_FLD\tT_PTR_FLD\n",
1019         /* well in this case we shall not search for view, but just take value of  */
1020         "= T_VIEW_2_FLD\tT_VIEW_FLD\n",
1021         "= T_UBF_2_FLD\tT_UBF_FLD\n",
1022         NULL
1023     };
1024
1025     /* load field table */
1026     load_field_table();
1027
1028     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
1029     assert_equal(Binit(p_ub2, sizeof(fb2)), EXSUCCEED);
1030     open_test_temp("w");
1031     write_to_temp(test_eq);
1032     close_test_temp();
1033
1034     open_test_temp_for_read("r");
1035     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
1036     close_test_temp();
1037     /* now open the file */
1038     remove_test_temp();
1039
1040     /* Load reference data into buffer 2 */
1041     assert_equal(CBchg(p_ub2, T_SHORT_FLD, 0, "999", 0, BFLD_STRING), EXSUCCEED);
1042     assert_equal(CBchg(p_ub2, T_LONG_FLD, 0, "124545", 0, BFLD_STRING), EXSUCCEED);
1043     assert_equal(CBchg(p_ub2, T_CHAR_FLD, 0, "a", 0, BFLD_STRING), EXSUCCEED);
1044     assert_equal(CBchg(p_ub2, T_FLOAT_FLD, 0, "777.11", 0, BFLD_STRING), EXSUCCEED);
1045     assert_equal(CBchg(p_ub2, T_DOUBLE_FLD, 0, "888", 0, BFLD_STRING), EXSUCCEED);
1046     assert_equal(CBchg(p_ub2, T_STRING_FLD, 0, "ABC", 0, BFLD_STRING), EXSUCCEED);
1047     assert_equal(CBchg(p_ub2, T_CARRAY_FLD, 0, "EFGH", 0, BFLD_STRING), EXSUCCEED);
1048
1049     assert_equal(CBchg(p_ub2, T_SHORT_2_FLD, 0, "999", 0, BFLD_STRING), EXSUCCEED);
1050     assert_equal(CBchg(p_ub2, T_LONG_2_FLD, 0, "124545", 0, BFLD_STRING), EXSUCCEED);
1051     assert_equal(CBchg(p_ub2, T_CHAR_2_FLD, 0, "a", 0, BFLD_STRING), EXSUCCEED);
1052     assert_equal(CBchg(p_ub2, T_FLOAT_2_FLD, 0, "777.11", 0, BFLD_STRING), EXSUCCEED);
1053     assert_equal(CBchg(p_ub2, T_DOUBLE_2_FLD, 0, "888", 0, BFLD_STRING), EXSUCCEED);
1054     assert_equal(CBchg(p_ub2, T_STRING_2_FLD, 0, "ABC", 0, BFLD_STRING), EXSUCCEED);
1055     assert_equal(CBchg(p_ub2, T_CARRAY_2_FLD, 0, "EFGH", 0, BFLD_STRING), EXSUCCEED);
1056
1057     /* prepare data */
1058     gen_load_ptr(p_ub2, 0, 1, 0);
1059     gen_load_ubf(p_ub2, 0, 1, 0);
1060     gen_load_view(p_ub2, 0, 1, 0);
1061
1062     gen_load_ptr(p_ub2, 0, 1, 1);
1063     gen_load_ubf(p_ub2, 0, 1, 1);
1064     gen_load_view(p_ub2, 0, 1, 1);
1065
1066     assert_equal(Bcmp(p_ub, p_ub2), 0);
1067
1068 }
1069
1070 /**
1071  * Test - Test buffer EQ failure
1072  */
1073 Ensure(test_bextread_eq_err)
1074 {
1075     char fb[2048];
1076     UBFH *p_ub = (UBFH *)fb;
1077     short s;
1078     long l;
1079
1080     /* TODO: CHeck with sub-fields ? + PTR */
1081     char *test_eq_err[]= {
1082         "T_SHORT_FLD\t999\n",
1083         "T_LONG_FLD\t124545\n",
1084         "T_CHAR_FLD\ta\n",
1085         "T_DOUBLE_FLD\t888\n",
1086         "T_FLOAT_FLD\t777.11\n",
1087         "T_STRING_FLD\tABC\n",
1088         "T_CARRAY_FLD\tEFGH\n",
1089         /* Value will be copied to FLD2 */
1090         "= T_SHORT_2_FLD\tT_SHORT_FLD\n",
1091         "= T_LONG_2_FLD\tT_LONG_FLD\n",
1092         "= T_CHAR_2_FLD\tT_CHAR_FLD\n",
1093         "= T_DOUBLE_2_FLD\tT_DOUBLE_FLD\n",
1094         "= T_FLOAT_2_FLD\tT_FLOAT_FLD\n",
1095         "= T_STRING_2_FLD\tFIELD_NOT_PRESENT\n", /* <<< error on this lines */
1096         "= T_CARRAY_2_FLD\tT_CARRAY_FLD\n",
1097         NULL
1098     };
1099     /* load field table */
1100     load_field_table();
1101     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
1102     open_test_temp("w");
1103     write_to_temp(test_eq_err);
1104     close_test_temp();
1105
1106     open_test_temp_for_read("r");
1107     assert_equal(Bextread(p_ub, M_test_temp_file), EXFAIL);
1108     assert_equal(Berror, BBADNAME);
1109     close_test_temp();
1110     /* now open the file */
1111     remove_test_temp();
1112 }
1113
1114 /**
1115  * Check that by default, pointers are not read
1116  */
1117 Ensure(test_bextread_no_ptr)
1118 {
1119     char fb[2048];
1120     UBFH *p_ub = (UBFH *)fb;
1121     char buf[128];
1122     BFLDLEN len;
1123
1124     char *test_ptr[]= {
1125         "T_STRING_FLD\tABC\n",
1126         "T_PTR_FLD\t111\n",
1127         NULL
1128     };
1129
1130     /* remove settings... */
1131     unsetenv("NDRX_APIFLAGS");
1132
1133     /* load field table */
1134     load_field_table();
1135     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
1136     open_test_temp("w");
1137     write_to_temp(test_ptr);
1138     close_test_temp();
1139
1140     open_test_temp_for_read("r");
1141     assert_equal(Bextread(p_ub, M_test_temp_file), EXSUCCEED);
1142
1143     /* check buffer... */
1144     len = sizeof(buf);
1145     assert_equal(Bget(p_ub, T_STRING_FLD, 0, buf, &len), EXSUCCEED);
1146     assert_string_equal(buf, "ABC");
1147
1148     assert_equal(CBget(p_ub, T_PTR_FLD, 0, buf, &len, BFLD_STRING), EXFAIL);
1149     assert_equal(Berror, BNOTPRES);
1150
1151     close_test_temp();
1152     /* now open the file */
1153     remove_test_temp();
1154 }
1155
1156 TestSuite *ubf_print_tests(void)
1157 {
1158     TestSuite *suite = create_test_suite();
1159
1160     std_basic_setup();
1161
1162     add_test(suite, test_bfprintcb);
1163
1164     add_test(suite, test_bprint);
1165     add_test(suite, test_bfprint);
1166
1167     add_test(suite, test_bextread_bfldid);
1168     add_test(suite, test_bextread_fldnm);
1169     add_test(suite, test_bextread_chk_errors);
1170     add_test(suite, test_bextread_comments);
1171     add_test(suite, test_bextread_minus);
1172     add_test(suite, test_bextread_plus);
1173     add_test(suite, test_bextread_eq);
1174     add_test(suite, test_bextread_eq_err);
1175     add_test(suite, test_bextreadcb);
1176     add_test(suite, test_bextread_no_ptr);
1177
1178     return suite;
1179 }
1180 /* vim: set ts=4 sw=4 et smartindent: */