atmitest/test040_typedview/viewunit1.c

0001 /**
0002  * @brief View unit tests.
0003  *
0004  * @file viewunit1.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 <unistd.h>
0038 #include <cgreen/cgreen.h>
0039 #include <ubf.h>
0040 #include <ndrstandard.h>
0041 #include <string.h>
0042 #include "test.fd.h"
0043 #include "ndebug.h"
0044 #include <fdatatype.h>
0045
0046 #include "test040.h"
0047
0048 extern TestSuite *vacc_CBvget_tests(void);
0049 extern TestSuite *vacc_CBvchg_tests(void);
0050 extern TestSuite *vacc_util_tests(void);
0051
0052 /**
0053  * Basic preparation before the test
0054  */
0055 exprivate void basic_setup(void)
0056 {
0057
0058 }
0059
0060 exprivate void basic_teardown(void)
0061 {
0062
0063 }
0064
0065
0066 /**
0067  * Test NULL column
0068  */
0069 Ensure(test_Bvnull)
0070 {
0071     struct MYVIEW1 v;
0072     int i;
0073     char *spec_symbols = "\n\t\f\\\'\"\vHELLOWORLD\0";
0074     memset(&v, 0, sizeof(v));
0075
0076     /***************************** SHORT TESTS *******************************/
0077     /* These fields shall not be NULL as NULL defined */
0078
0079     /* if count is 0, then value is NULL too */
0080     assert_equal(Bvnull((char *)&v, "tshort2", 0, "MYVIEW1"), EXTRUE);
0081     assert_equal(Bvnull((char *)&v, "tshort2", 1, "MYVIEW1"), EXTRUE);
0082
0083     /* thus now not null */
0084     v.C_tshort2=2;
0085     assert_equal(Bvnull((char *)&v, "tshort2", 0, "MYVIEW1"), EXFALSE);
0086     assert_equal(Bvnull((char *)&v, "tshort2", 1, "MYVIEW1"), EXFALSE);
0087
0088     /* Set to NULL */
0089     v.tshort2[1]=2001;
0090     assert_equal(Bvnull((char *)&v, "tshort2", 0, "MYVIEW1"), EXFALSE);
0091     assert_equal(Bvnull((char *)&v, "tshort2", 1, "MYVIEW1"), EXTRUE);
0092
0093     /*  Set all to NULL */
0094     assert_equal(Bvselinit((char *)&v,"tshort2", "MYVIEW1"), EXSUCCEED);
0095     assert_equal(Bvnull((char *)&v, "tshort2", 0, "MYVIEW1"), EXTRUE);
0096     assert_equal(Bvnull((char *)&v, "tshort2", 1, "MYVIEW1"), EXTRUE);
0097
0098
0099     assert_equal(Bvnull((char *)&v, "tshort3", 0, "MYVIEW1"), EXTRUE);
0100     assert_equal(Bvnull((char *)&v, "tshort3", 1, "MYVIEW1"), EXTRUE);
0101     assert_equal(Bvnull((char *)&v, "tshort3", 2, "MYVIEW1"), EXTRUE);
0102
0103     v.tshort3[0] = 1;
0104     v.tshort3[2] = 2;
0105
0106     v.C_tshort3 = 3;
0107     assert_equal(Bvnull((char *)&v, "tshort3", 0, "MYVIEW1"), EXFALSE);
0108     assert_equal(Bvnull((char *)&v, "tshort3", 1, "MYVIEW1"), EXTRUE);
0109     assert_equal(Bvnull((char *)&v, "tshort3", 2, "MYVIEW1"), EXFALSE);
0110
0111     /* this is NONE, field set to 0, but as NONE is there it is not NULL */
0112     assert_equal(Bvnull((char *)&v, "tshort4", 0, "MYVIEW1"), EXFALSE);
0113
0114     /***************************** LONG TESTS *******************************/
0115
0116     assert_equal(Bvnull((char *)&v, "tlong1", 0, "MYVIEW1"), EXTRUE);
0117
0118     /***************************** INT TESTS ********************************/
0119
0120     assert_equal(Bvnull((char *)&v, "tint2", 0, "MYVIEW1"), EXTRUE);
0121     assert_equal(Bvnull((char *)&v, "tint2", 1, "MYVIEW1"), EXTRUE);
0122     assert_equal(Bvnull((char *)&v, "tint3", 0, "MYVIEW1"), EXFALSE);
0123     assert_equal(Bvselinit((char *)&v,"tint3", "MYVIEW1"), EXSUCCEED);
0124     assert_equal(Bvnull((char *)&v, "tint3", 0, "MYVIEW1"), EXTRUE);
0125
0126     assert_equal(v.tint3, -1);
0127
0128     assert_equal(Bvnull((char *)&v, "tint4", 0, "MYVIEW1"), EXFALSE);
0129     assert_equal(Bvnull((char *)&v, "tint4", 1, "MYVIEW1"), EXFALSE);
0130
0131     assert_equal(v.tint4[0], 0);
0132     assert_equal(v.tint4[1], 0);
0133
0134     assert_equal(Bvselinit((char *)&v,"tint4", "MYVIEW1"), EXSUCCEED);
0135
0136     assert_equal(Bvnull((char *)&v, "tint4", 0, "MYVIEW1"), EXTRUE);
0137     assert_equal(Bvnull((char *)&v, "tint4", 1, "MYVIEW1"), EXTRUE);
0138
0139     /***************************** CHAR TESTS ********************************/
0140
0141     UBF_LOG(log_debug, "tchar1=%x", v.tchar1);
0142     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW1"), EXFALSE);
0143
0144     v.tchar1 = '\n';
0145     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW1"), EXTRUE);
0146     v.tchar1 = 0;
0147     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW1"), EXFALSE);
0148     assert_equal(Bvselinit((char *)&v,"tchar1", "MYVIEW1"), EXSUCCEED);
0149
0150     UBF_LOG(log_debug, "tchar1=%x", v.tchar1);
0151     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW1"), EXTRUE);
0152
0153
0154     /* Here default is 'A' */
0155     v.C_tchar2=5;
0156     for (i=0;i<5;i++)
0157     {
0158         assert_equal(Bvnull((char *)&v, "tchar2", i, "MYVIEW1"), EXFALSE);
0159     }
0160
0161     assert_equal(Bvselinit((char *)&v,"tchar2", "MYVIEW1"), EXSUCCEED);
0162
0163     for (i=0;i<5;i++)
0164     {
0165         assert_equal(Bvnull((char *)&v, "tchar2", i, "MYVIEW1"), EXTRUE);
0166     }
0167
0168     for (i=0;i<5;i++)
0169     {
0170         assert_equal(v.tchar2[i], 'A');
0171     }
0172
0173     /* Here default is zero byte */
0174
0175     for (i=0;i<2;i++)
0176     {
0177         assert_equal(v.tchar3[i], 0);
0178     }
0179
0180     /***************************** FLOAT TESTS *******************************/
0181     for (i=0;i<4;i++)
0182     {
0183         assert_equal(Bvnull((char *)&v, "tfloat1", 0, "MYVIEW1"), EXFALSE);
0184     }
0185
0186     assert_equal(Bvselinit((char *)&v,"tfloat1", "MYVIEW1"), EXSUCCEED);
0187
0188     for (i=0;i<4;i++)
0189     {
0190         assert_equal(Bvnull((char *)&v, "tfloat1", i, "MYVIEW1"), EXTRUE);
0191     }
0192
0193     for (i=0;i<4;i++)
0194     {
0195         assert_equal(v.tfloat1[i], 1.1);
0196     }
0197
0198     /* occ: 0..3*/
0199     assert_equal(Bvnull((char *)&v, "tfloat1", 4, "MYVIEW1"), EXFAIL);
0200     assert_equal(Berror, BEINVAL);
0201
0202     /* Default set by memset... */
0203     for (i=0;i<2;i++)
0204     {
0205         assert_equal(Bvnull((char *)&v, "tfloat2", i, "MYVIEW1"), EXTRUE);
0206         assert_equal(Berror, 0);
0207     }
0208
0209     assert_equal(Bvnull((char *)&v, "tfloat3", 0, "MYVIEW1"), EXFALSE);
0210     assert_equal(v.tfloat3, 0);
0211
0212     assert_equal(Bvselinit((char *)&v,"tfloat3", "MYVIEW1"), EXSUCCEED);
0213     assert_equal(v.tfloat3, 9999.99);
0214     assert_equal(Bvnull((char *)&v, "tfloat3", 0, "MYVIEW1"), EXTRUE);
0215
0216
0217     /***************************** DOUBLE TESTS *******************************/
0218     for (i=0;i<2;i++)
0219     {
0220         assert_equal(Bvnull((char *)&v, "tdouble1", i, "MYVIEW1"), EXFALSE);
0221     }
0222
0223     assert_equal(Bvselinit((char *)&v,"tdouble1", "MYVIEW1"), EXSUCCEED);
0224
0225     for (i=0;i<2;i++)
0226     {
0227         assert_equal(Bvnull((char *)&v, "tdouble1", i, "MYVIEW1"), EXTRUE);
0228         assert_equal(v.tdouble1[i], 55555.99);
0229     }
0230
0231     assert_equal(Bvnull((char *)&v, "tdouble2", 0, "MYVIEW1"), EXFALSE);
0232     assert_equal(Bvselinit((char *)&v,"tdouble2", "MYVIEW1"), EXSUCCEED);
0233     assert_equal(Bvnull((char *)&v, "tdouble2", 0, "MYVIEW1"), EXTRUE);
0234     assert_equal(v.tdouble2, -999.123);
0235
0236     /***************************** STRING TESTS *******************************/
0237     /* Fill the string 1 in advance.. */
0238     assert_equal(Bvselinit((char *)&v,"tstring1", "MYVIEW1"), EXSUCCEED);
0239
0240     /* Test filler: */
0241     for (i=0;i<3;i++)
0242     {
0243         UBF_LOG(log_debug, "tstring1=[%s]", v.tstring1[i]);
0244
0245         assert_equal(Bvnull((char *)&v, "tstring1", i, "MYVIEW1"), EXTRUE);
0246     }
0247
0248     /* Test special symbols... */
0249     for (i=0;i<3;i++)
0250     {
0251         assert_equal(Bvnull((char *)&v, "tstring0", i, "MYVIEW1"), EXFALSE);
0252     }
0253
0254     assert_equal(Bvselinit((char *)&v,"tstring0", "MYVIEW1"), EXSUCCEED);
0255
0256     UBF_DUMP(log_debug, "Special symbols test...", spec_symbols, strlen(spec_symbols));
0257
0258     for (i=0;i<3;i++)
0259     {
0260         UBF_LOG(log_debug, "tstring0=[%s]", v.tstring0[i]);
0261
0262         UBF_DUMP(log_debug, "testing0", v.tstring0[i], strlen(v.tstring0[i]));
0263
0264         UBF_DUMP_DIFF(log_debug, "diff", spec_symbols, v.tstring0[i], strlen(spec_symbols));
0265
0266         assert_equal(Bvnull((char *)&v, "tstring0", i, "MYVIEW1"), EXTRUE);
0267     }
0268
0269     assert_string_equal(v.tstring0[0], spec_symbols);
0270
0271     /* Continue with filler... */
0272
0273     for (i=0;i<3;i++)
0274     {
0275         assert_string_equal(v.tstring1[i], "HELLO WORLDBBBBBBBB");
0276     }
0277
0278     for (i=0;i<3;i++)
0279     {
0280         assert_equal(Bvnull((char *)&v, "tstring2", i, "MYVIEW1"), EXTRUE);
0281     }
0282
0283     /* otherwise will be NULL as count set so. */
0284     v.C_tstring3=4;
0285     for (i=0;i<4;i++)
0286     {
0287         assert_equal(Bvnull((char *)&v, "tstring3", i, "MYVIEW1"), EXFALSE);
0288     }
0289
0290     assert_equal(Bvselinit((char *)&v,"tstring3", "MYVIEW1"), EXSUCCEED);
0291
0292     for (i=0;i<4;i++)
0293     {
0294         assert_equal(Bvnull((char *)&v, "tstring3", i, "MYVIEW1"), EXTRUE);
0295     }
0296
0297     for (i=0;i<4;i++)
0298     {
0299         assert_string_equal(v.tstring3[i], "TESTEST");
0300     }
0301
0302     assert_equal(Bvnull((char *)&v, "tstring4", 0, "MYVIEW1"), EXFALSE);
0303     assert_equal(Bvselinit((char *)&v,"tstring4", "MYVIEW1"), EXSUCCEED);
0304     assert_equal(Bvnull((char *)&v, "tstring4", 0, "MYVIEW1"), EXTRUE);
0305     assert_string_equal(v.tstring4, "HELLO TESTTTTT");
0306
0307
0308     /***************************** CARRAY TESTS *******************************/
0309
0310     assert_equal(Bvnull((char *)&v, "tcarray1", 0, "MYVIEW1"), EXFALSE);
0311     assert_equal(Bvselinit((char *)&v,"tcarray1", "MYVIEW1"), EXSUCCEED);
0312     assert_equal(Bvnull((char *)&v, "tcarray1", 0, "MYVIEW1"), EXTRUE);
0313     assert_equal(memcmp(v.tcarray1, "\0\n\t\f\\\'\"\vHELLOWORLD", 18), 0);
0314
0315     assert_equal(Bvnull((char *)&v, "tcarray2", 0, "MYVIEW1"), EXFALSE);
0316     assert_equal(Bvselinit((char *)&v,"tcarray2", "MYVIEW1"), EXSUCCEED);
0317     assert_equal(Bvnull((char *)&v, "tcarray2", 0, "MYVIEW1"), EXTRUE);
0318     assert_equal(memcmp(v.tcarray2, "\0\n\t\f\\\'\"\vHELLOWORL\n\n\n\n\n\n\n\n'", 25), 0);
0319
0320     for (i=0; i<10; i++)
0321     {
0322         assert_equal(v.tcarray3[i][0], 0);
0323     }
0324
0325     assert_equal(Bvselinit((char *)&v, "tcarray3", "MYVIEW1"), EXSUCCEED);
0326
0327     for (i=0; i<10; i++)
0328     {
0329         assert_equal(memcmp(v.tcarray3[i], "\0\\\nABC\t\f\'\vHELLOOOOOOOOOOOOOOOOOOO", 30), 0);
0330     }
0331
0332     assert_equal(Bvselinit((char *)&v, "tcarray4", "MYVIEW1"), EXSUCCEED);
0333     assert_equal(Bvnull((char *)&v, "tcarray4", 0, "MYVIEW1"), EXTRUE);
0334     assert_equal(memcmp(v.tcarray4, "ABC", 3), 0);
0335
0336
0337     assert_equal(Bvselinit((char *)&v, "tcarray5", "MYVIEW1"), EXSUCCEED);
0338     assert_equal(Bvnull((char *)&v, "tcarray5", 0, "MYVIEW1"), EXTRUE);
0339
0340     assert_equal(memcmp(v.tcarray5, "\0\0\0\0\0", 5), 0);
0341
0342 }
0343
0344 Ensure(test_Bvsinit)
0345 {
0346     struct MYVIEW2 v;
0347
0348     memset(&v, 0, sizeof(v));
0349     assert_equal(Bvsinit((char *)&v, "MYVIEW2"), EXSUCCEED);
0350
0351     assert_equal(Bvnull((char *)&v, "tshort1", 0, "MYVIEW2"), EXTRUE);
0352     assert_equal(Bvnull((char *)&v, "tlong1", 0, "MYVIEW2"), EXTRUE);
0353     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW2"), EXTRUE);
0354     assert_equal(Bvnull((char *)&v, "tfloat1", 0, "MYVIEW2"), EXTRUE);
0355     assert_equal(Bvnull((char *)&v, "tdouble1", 0, "MYVIEW2"), EXTRUE);
0356     assert_equal(Bvnull((char *)&v, "tstring1", 0, "MYVIEW2"), EXTRUE);
0357     assert_equal(Bvnull((char *)&v, "tcarray1", 0, "MYVIEW2"), EXTRUE);
0358 }
0359
0360 Ensure(test_Bvrefresh)
0361 {
0362     Bvrefresh();
0363 }
0364
0365 /**
0366  * Install structure to UBF
0367  */
0368 Ensure(test_Bvstof)
0369 {
0370     struct MYVIEW1 v;
0371     char buf[2048];
0372     BFLDID bfldid;
0373     BFLDOCC occ;
0374     int flds_got;
0375     UBFH *p_ub = (UBFH *)buf;
0376     char tmp[128];
0377     double dtemp;
0378     BFLDLEN len;
0379     int i, j;
0380     /***************************** TEST EMPTY STRUCT **************************/
0381     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0382
0383     /* Set to NULL */
0384     assert_equal(Bvsinit((char *)&v, "MYVIEW1"), EXSUCCEED);
0385
0386     /* transfer to UBF.. */
0387     assert_equal(Bvstof(p_ub, (char *)&v, BUPDATE, "MYVIEW1"), EXSUCCEED);
0388
0389     /* not fields must be transfered. */
0390     bfldid = BFIRSTFLDID;
0391     flds_got = 0;
0392     while(1==Bnext(p_ub, &bfldid, &occ, NULL, NULL))
0393     {
0394         flds_got++;
0395     }
0396
0397     assert_equal(flds_got, 0);
0398
0399
0400     /***************************** TEST FILLED UBF ****************************/
0401
0402     /* Load test value... */
0403     init_MYVIEW1(&v);
0404
0405     /* Having some issues with initialised data of these: */
0406     assert_equal(Bvnull((char *)&v, "tstring2", 0, "MYVIEW1"), EXFALSE);
0407     assert_equal(Bvnull((char *)&v, "tcarray5", 0, "MYVIEW1"), EXFALSE);
0408
0409     assert_equal(Bvstof(p_ub, (char *)&v, BUPDATE, "MYVIEW1"), EXSUCCEED);
0410
0411     bfldid = BFIRSTFLDID;
0412     while(1==Bnext(p_ub, &bfldid, &occ, NULL, NULL))
0413     {
0414         flds_got++;
0415     }
0416
0417     assert_not_equal(flds_got, 0);
0418
0419     /* Test values... */
0420
0421     /*
0422      * short
0423      */
0424     TEST_AS_STRING(T_SHORT_FLD, 0, "15556");
0425
0426     TEST_AS_STRING(T_SHORT_2_FLD, 0, "9999");
0427     TEST_AS_STRING(T_SHORT_2_FLD, 1, "8888");
0428
0429
0430     TEST_AS_STRING(T_SHORT_3_FLD, 0, "7777");
0431     TEST_AS_STRING(T_SHORT_3_FLD, 1, "-7777");
0432     assert_equal(Bpres(p_ub, T_SHORT_3_FLD, 2),  EXFALSE);
0433
0434     /*
0435      * long
0436      */
0437     TEST_AS_STRING(T_LONG_FLD, 0, "33333333");
0438
0439     /*
0440      * Int
0441      */
0442     TEST_AS_STRING(T_LONG_2_FLD, 0, "54545");
0443     TEST_AS_STRING(T_LONG_2_FLD, 1, "23232");
0444
0445     /*
0446      * Char
0447      */
0448     TEST_AS_STRING(T_CHAR_FLD, 0, "A");
0449     assert_equal(Bpres(p_ub, T_CHAR_2_FLD, 0),  EXFALSE);
0450     assert_equal(Bpres(p_ub, T_CHAR_3_FLD, 0),  EXFALSE);
0451
0452     /*
0453      * Float tests
0454      */
0455     TEST_AS_DOUBLE(T_FLOAT_FLD, 0, -0.11);
0456     TEST_AS_DOUBLE(T_FLOAT_FLD, 1, -0.22);
0457     TEST_AS_DOUBLE(T_FLOAT_FLD, 2, 0.33);
0458     TEST_AS_DOUBLE(T_FLOAT_FLD, 3, 0.44);
0459     assert_equal(Bpres(p_ub, T_FLOAT_2_FLD, 0),  EXFALSE);
0460
0461     /*
0462      * Double tests
0463      */
0464     TEST_AS_DOUBLE(T_DOUBLE_FLD, 0, 99999.111111);
0465     TEST_AS_DOUBLE(T_DOUBLE_FLD, 1, 11111.999999);
0466     assert_equal(Bpres(p_ub, T_DOUBLE_FLD, 2),  EXFALSE);
0467
0468     /* Not transfered due to default value NULL: */
0469     assert_equal(Bpres(p_ub, T_DOUBLE_2_FLD, 0),  EXFALSE);
0470
0471     /*
0472      * String
0473      */
0474     TEST_AS_STRING(T_STRING_FLD, 0, "Pack my box");
0475     TEST_AS_STRING(T_STRING_FLD, 1, "BOX MY PACK");
0476     TEST_AS_STRING(T_STRING_FLD, 2, "\nEnduro/X\n");
0477     assert_equal(Bpres(p_ub, T_STRING_FLD, 3),  EXFALSE);
0478
0479     TEST_AS_STRING(T_STRING_2_FLD, 0, "CCCCAAAADDDD");
0480     assert_equal(v.L_tstring2[0], 13);
0481
0482     TEST_AS_STRING(T_STRING_2_FLD, 1, "EEEFFFGGG");
0483     assert_equal(v.L_tstring2[1], 10);
0484
0485     assert_equal(Bpres(p_ub, T_STRING_2_FLD, 2),  EXFALSE);
0486
0487
0488     TEST_AS_STRING(T_STRING_3_FLD, 0, "LLLLLL");
0489     TEST_AS_STRING(T_STRING_3_FLD, 1, "MMMMMM");
0490     TEST_AS_STRING(T_STRING_3_FLD, 2, "");
0491     TEST_AS_STRING(T_STRING_3_FLD, 3, "NNNNNN");
0492
0493     assert_equal(Bpres(p_ub, T_STRING_3_FLD, 4),  EXFALSE);
0494
0495     /*
0496      * Carray test
0497      */
0498     GET_CARRAY_DOUBLE_TEST_LEN(T_CARRAY_FLD, 0, 30)
0499     for (i=0; i<30; i++)
0500     {
0501         assert_equal(v.tcarray1[i], i);
0502     }
0503
0504     GET_CARRAY_DOUBLE_TEST_LEN(T_CARRAY_FLD, 0, 30)
0505     for (i=0; i<30; i++)
0506     {
0507         assert_equal(tmp[i], i);
0508     }
0509
0510     GET_CARRAY_DOUBLE_TEST_LEN(T_CARRAY_2_FLD, 0, 5)
0511     for (i=0; i<5; i++)
0512     {
0513         assert_equal(tmp[i], i+1);
0514     }
0515
0516     for (j=0; j<9; j++)
0517     {
0518         UBF_LOG(log_debug, "Testing j=%d", j);
0519         GET_CARRAY_DOUBLE_TEST_LEN(T_CARRAY_3_FLD, j, j+1)
0520
0521         for (i=0; i<j; i++)
0522         {
0523             assert_equal(tmp[i], i+2);
0524         }
0525     }
0526     assert_equal(Bpres(p_ub, T_CARRAY_3_FLD, 9),  EXFALSE);
0527
0528 }
0529 /**
0530  * Transfer UBF buffer to C struct..
0531  * We will use previously initialised buffer by Bvstof
0532  */
0533 Ensure(test_Bvftos)
0534 {
0535     struct MYVIEW1 v;
0536     char buf[2048];
0537     BFLDID bfldid;
0538     BFLDOCC occ;
0539     int flds_got;
0540     UBFH *p_ub = (UBFH *)buf;
0541     char tmp[128];
0542     double dtemp;
0543     BFLDLEN len;
0544     int i, j;
0545     /***************************** TEST EMPTY STRUCT **************************/
0546     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0547
0548     /* Load test value... */
0549     init_MYVIEW1(&v);
0550
0551     /* transfer to UBF.. */
0552     assert_equal(Bvstof(p_ub, (char *)&v, BCONCAT, "MYVIEW1"), EXSUCCEED);
0553
0554     memset(&v, 0, sizeof(v));
0555
0556     /* First will go as NULL */
0557     assert_equal(CBchg(p_ub, T_CHAR_2_FLD, 0, "A", 0L, BFLD_STRING), EXSUCCEED);
0558     assert_equal(CBchg(p_ub, T_CHAR_2_FLD, 1, "B", 0L, BFLD_STRING), EXSUCCEED);
0559     assert_equal(CBchg(p_ub, T_CHAR_2_FLD, 2, "C", 0L, BFLD_STRING), EXSUCCEED);
0560     assert_equal(CBchg(p_ub, T_CHAR_2_FLD, 3, "D", 0L, BFLD_STRING), EXSUCCEED);
0561     assert_equal(CBchg(p_ub, T_CHAR_2_FLD, 4, "E", 0L, BFLD_STRING), EXSUCCEED);
0562
0563     assert_equal(CBchg(p_ub, T_CHAR_3_FLD, 0, "X", 0L, BFLD_STRING), EXSUCCEED);
0564     assert_equal(CBchg(p_ub, T_CHAR_3_FLD, 0, "Y", 0L, BFLD_STRING), EXSUCCEED);
0565
0566     assert_equal(CBchg(p_ub, T_FLOAT_2_FLD, 0, "44", 0L, BFLD_STRING), EXSUCCEED);
0567
0568     assert_equal(Bvftos(p_ub, (char *)&v, "MYVIEW1"), EXSUCCEED);
0569
0570     /* now in v either we have value from buffer of NULL for the field. */
0571
0572     /*
0573      * test short
0574      */
0575     assert_equal(v.tshort1, 15556);
0576
0577     assert_equal(v.C_tshort2, 2);
0578     assert_equal(v.tshort2[0], 9999);
0579     assert_equal(v.tshort2[1], 8888);
0580
0581     assert_equal(v.C_tshort3, 2);
0582     assert_equal(v.tshort3[0], 7777);
0583     assert_equal(v.tshort3[1], -7777);
0584
0585     UBF_LOG(log_debug, "tshort4=%hd", v.tshort4);
0586
0587     /* NULL set to NONE */
0588     assert_equal(Bvnull((char *)&v, "tshort4", 0, "MYVIEW1"), EXFALSE);
0589
0590     /*
0591      * Long tests
0592      */
0593     assert_equal(v.tlong1, 33333333);
0594
0595     /*
0596      * Int tests
0597      */
0598     assert_equal(v.tint2[0], 54545);
0599     assert_equal(v.tint2[1], 23232);
0600
0601     assert_equal(Bvnull((char *)&v, "tint3", 0, "MYVIEW1"), EXTRUE);
0602     assert_equal(Bvnull((char *)&v, "tint4", 0, "MYVIEW1"), EXTRUE);
0603
0604     /*
0605      * Char tests
0606      */
0607
0608     /* Field is F, no copy back to struct */
0609     assert_equal(Bvnull((char *)&v, "tchar1", 0, "MYVIEW1"), EXTRUE);
0610
0611     for (i=0; i<5; i++)
0612     {
0613         assert_equal(v.tchar2[i], 'A'+i);
0614
0615     }
0616
0617     assert_equal(Bvnull((char *)&v, "tchar2", 0, "MYVIEW1"), EXTRUE);
0618
0619     for (i=0; i<2; i++)
0620     {
0621         assert_equal(Bvnull((char *)&v, "tchar3", i, "MYVIEW1"), EXTRUE);
0622     }
0623
0624     /*
0625      * Float tests
0626      */
0627     assert_double_equal(v.tfloat1[0], -0.11);
0628     assert_double_equal(v.tfloat1[1], -0.22);
0629     assert_double_equal(v.tfloat1[2], 0.33);
0630     assert_double_equal(v.tfloat1[3], 0.44);
0631
0632     assert_double_equal(v.tfloat2[0], 44);
0633
0634     assert_equal(Bvnull((char *)&v, "tfloat2", 1, "MYVIEW1"), EXTRUE);
0635
0636     assert_equal(Bvnull((char *)&v, "tfloat3", 0, "MYVIEW1"), EXTRUE);
0637
0638     /*
0639      * Double tests
0640      */
0641     assert_double_equal(v.tdouble1[0], 99999.111111);
0642     assert_double_equal(v.tdouble1[1], 11111.999999);
0643     assert_equal(Bvnull((char *)&v, "tdouble2", 0, "MYVIEW1"), EXTRUE);
0644
0645
0646     /*
0647      * String tests
0648      */
0649     assert_equal(Bvnull((char *)&v, "tstring0", 0, "MYVIEW1"), EXTRUE);
0650
0651     assert_string_equal(v.tstring1[0], "Pack my box");
0652     assert_string_equal(v.tstring1[1], "BOX MY PACK");
0653     assert_string_equal(v.tstring1[2], "\nEnduro/X\n");
0654
0655     assert_equal(Bvnull((char *)&v, "tstring2", 0, "MYVIEW1"), EXTRUE);
0656     assert_equal(Bvnull((char *)&v, "tstring2", 1, "MYVIEW1"), EXTRUE);
0657     assert_equal(Bvnull((char *)&v, "tstring2", 2, "MYVIEW1"), EXTRUE);
0658
0659
0660     assert_equal(v.L_tstring3[0], 7);
0661     assert_string_equal(v.tstring3[0], "LLLLLL");
0662     assert_equal(v.L_tstring3[1], 7);
0663     assert_string_equal(v.tstring3[1], "MMMMMM");
0664
0665     assert_equal(v.L_tstring3[2], 1); /* EOS */
0666     assert_string_equal(v.tstring3[2], "");
0667
0668     assert_equal(v.L_tstring3[3], 7); /* EOS */
0669     assert_string_equal(v.tstring3[3], "NNNNNN");
0670
0671
0672     assert_equal(Bvnull((char *)&v, "tstring4", 0, "MYVIEW1"), EXTRUE);
0673
0674     /*
0675      * Carray tests
0676      */
0677
0678     for (i=0; i<30; i++)
0679     {
0680         assert_equal(v.tcarray1[i], i);
0681     }
0682
0683     assert_equal(v.L_tcarray2, 5);
0684
0685     for (i=0; i<5; i++)
0686     {
0687         assert_equal(v.tcarray2[i], i+1);
0688     }
0689
0690     assert_equal(v.C_tcarray3, 9);
0691
0692     for (j=0; j<9; j++)
0693     {
0694         assert_equal(v.L_tcarray3[j], j+1);
0695
0696         for (i=0; i<j+1; i++)
0697         {
0698             assert_equal(v.tcarray3[j][i], i+2);
0699         }
0700     }
0701
0702     assert_equal(Bvnull((char *)&v, "tcarray4", 0, "MYVIEW1"), EXTRUE);
0703
0704     assert_equal(Bvnull((char *)&v, "tcarray5", 0, "MYVIEW1"), EXTRUE);
0705 }
0706
0707 /**
0708  * Test Bvopt func
0709  */
0710 Ensure(test_Bvopt)
0711 {
0712     struct MYVIEW3 v;
0713     char buf[2048];
0714     UBFH *p_ub = (UBFH *)buf;
0715
0716     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0717
0718     init_MYVIEW3(&v);
0719
0720     /* Copy to UBF, must be empty, because of flag N */
0721
0722     /* transfer to UBF.. */
0723     assert_equal(Bvstof(p_ub, (char *)&v, BUPDATE, "MYVIEW3"), EXSUCCEED);
0724
0725     assert_equal(Bpres(p_ub, T_SHORT_FLD, 0), EXFALSE);
0726     assert_equal(Bpres(p_ub, T_SHORT_2_FLD, 0), EXFALSE);
0727     assert_equal(Bpres(p_ub, T_SHORT_3_FLD, 0), EXFALSE);
0728
0729     assert_equal(Bvopt("tshort1", B_STOF, "MYVIEW3"), EXSUCCEED);
0730     assert_equal(Bvopt("tshort3", B_BOTH, "MYVIEW3"), EXSUCCEED);
0731
0732     /* Now transfer, should have something... */
0733     assert_equal(Bvstof(p_ub, (char *)&v, BUPDATE, "MYVIEW3"), EXSUCCEED);
0734
0735     assert_equal(Bpres(p_ub, T_SHORT_FLD, 0), EXTRUE);
0736     assert_equal(Bpres(p_ub, T_SHORT_2_FLD, 0), EXFALSE);
0737     assert_equal(Bpres(p_ub, T_SHORT_3_FLD, 0), EXTRUE);
0738
0739     /* Now transfer back.. */
0740     memset(&v, 0, sizeof(v));
0741
0742     assert_equal(Bvftos(p_ub, (char *)&v, "MYVIEW3"), EXSUCCEED);
0743
0744     assert_equal(v.tshort1, 0);
0745     assert_equal(v.tshort2, 0);
0746     assert_equal(v.tshort3, 3);
0747
0748
0749     assert_equal(Bvopt("tshort1", B_FTOS, "MYVIEW3"), EXSUCCEED);
0750
0751     assert_equal(Bvftos(p_ub, (char *)&v, "MYVIEW3"), EXSUCCEED);
0752
0753     assert_equal(v.tshort1, 1);
0754     assert_equal(v.tshort2, 0);
0755     assert_equal(v.tshort3, 3);
0756
0757 }
0758
0759 /**
0760  * Test Bvcmp func
0761  */
0762 Ensure(test_Bvcmp)
0763 {
0764     struct MYVIEW1 v;
0765     struct MYVIEW1 v2;
0766
0767
0768     NDRX_LOG(log_debug, "test_Bvcmp start...");
0769
0770     assert_equal(Bvcmp(NULL, "MYVIEW2", (char *)&v, "MYVIEW2"), -2);
0771     assert_equal(Berror, BEINVAL);
0772
0773     assert_equal(Bvcmp((char *)&v, NULL, (char *)&v, "MYVIEW2"), -2);
0774     assert_equal(Berror, BEINVAL);
0775
0776     assert_equal(Bvcmp((char *)&v, "MYVIEW2", NULL, "MYVIEW2"), -2);
0777     assert_equal(Berror, BEINVAL);
0778
0779     assert_equal(Bvcmp((char *)&v, "MYVIEW2", (char *)&v, NULL), -2);
0780     assert_equal(Berror, BEINVAL);
0781
0782     assert_equal(Bvcmp((char *)&v, "HELLO", (char *)&v, "HELLO"), -2);
0783     assert_equal(Berror, BBADVIEW);
0784
0785     init_MYVIEW1(&v);
0786
0787     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v, "MYVIEW1"), 0);
0788     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v, "MYVIEW2"), -1);
0789
0790     /* check short type */
0791     init_MYVIEW1(&v2);
0792     v2.tshort1=15557;
0793     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0794     v2.tshort1=15555;
0795     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0796
0797     /* Check array len */
0798     v2.tshort1=15556;
0799     v2.C_tshort2=3;
0800     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0801
0802     v2.C_tshort2=1;
0803     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0804
0805     /* Check array eleme */
0806     v2.C_tshort2=2;
0807     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 0);
0808
0809     v2.tshort2[1]=7777;
0810     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0811
0812     /* do not check if data changed behind the indicators... */
0813     v2.C_tshort2=1;
0814     v.C_tshort2=1;
0815     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 0);
0816
0817     /* ok reset back... */
0818     init_MYVIEW1(&v);
0819     init_MYVIEW1(&v2);
0820
0821     /* check long */
0822     v2.tlong1=88;
0823     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0824
0825     /* check int */
0826     init_MYVIEW1(&v2);
0827     v2.tint2[1]=23233;
0828     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0829
0830     /* check char */
0831     init_MYVIEW1(&v2);
0832
0833     v2.tchar2[4]--;
0834     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0835
0836     /* check float */
0837     init_MYVIEW1(&v2);
0838
0839     v2.tfloat1[3]+=0.1;
0840     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0841
0842     /* check double */
0843     init_MYVIEW1(&v2);
0844
0845     v2.tdouble1[1]+=0.1;
0846     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0847
0848     /* check string */
0849     init_MYVIEW1(&v2);
0850
0851     /* goes over the count */
0852     NDRX_STRCPY_SAFE(v2.tstring2[2], "MM");
0853     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 0);
0854
0855     /* goes over the count */
0856     NDRX_STRCPY_SAFE(v2.tstring2[1], "ZZZZZZZZZ");
0857     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0858
0859     /* check carray */
0860     init_MYVIEW1(&v2);
0861     v2.L_tcarray2 = 4;
0862     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0863
0864     v2.L_tcarray2 = 5;
0865     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 0);
0866
0867     v2.tcarray2[0] = (char)255;
0868     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), -1);
0869
0870     init_MYVIEW1(&v2);
0871
0872     v2.tcarray5[0]=0;
0873     assert_equal(Bvcmp((char *)&v, "MYVIEW1", (char *)&v2, "MYVIEW1"), 1);
0874 }
0875
0876 /**
0877  * Very basic tests of the framework
0878  * @return
0879  */
0880 TestSuite *view_tests() {
0881     TestSuite *suite = create_test_suite();
0882
0883     set_setup(suite, basic_setup);
0884     set_teardown(suite, basic_teardown);
0885
0886     /* init view test */
0887     add_test(suite, test_Bvnull);
0888     add_test(suite, test_Bvsinit);
0889     add_test(suite, test_Bvrefresh);
0890     add_test(suite, test_Bvstof);
0891     add_test(suite, test_Bvftos);
0892     add_test(suite, test_Bvopt);
0893     add_test(suite, test_Bvcmp);
0894
0895     return suite;
0896 }
0897
0898 /*
0899  * Main test entry.
0900  */
0901 int main(int argc, char** argv)
0902 {
0903     TestSuite *suite = create_test_suite();
0904     int ret;
0905
0906     add_suite(suite, view_tests());
0907
0908     /* Dynamic view access: */
0909     add_suite(suite, vacc_CBvget_tests());
0910     add_suite(suite, vacc_CBvchg_tests());
0911     add_suite(suite, vacc_util_tests());
0912
0913     if (argc > 1)
0914     {
0915         ret=run_single_test(suite,argv[1],create_text_reporter());
0916     }
0917     else
0918     {
0919         ret=run_test_suite(suite, create_text_reporter());
0920     }
0921
0922     destroy_test_suite(suite);
0923
0924     return ret;
0925 }
0926
0927 /* vim: set ts=4 sw=4 et smartindent: */