atmitest/test040_typedview/vaccget.c

0001 /**
0002  * @brief View access unit
0003  *
0004  * @file vaccget.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 <math.h>
0039 #include <cgreen/cgreen.h>
0040 #include <ubf.h>
0041 #include <ndrstandard.h>
0042 #include <string.h>
0043 #include "test.fd.h"
0044 #include "ndebug.h"
0045 #include <fdatatype.h>
0046
0047 #include "test040.h"
0048
0049 /**
0050  * Basic preparation before the test
0051  */
0052 exprivate void basic_setup(void)
0053 {
0054
0055 }
0056
0057 exprivate void basic_teardown(void)
0058 {
0059
0060 }
0061
0062 /**
0063  * Test Bvget as short
0064  */
0065 Ensure(test_Bvget_short)
0066 {
0067     struct MYVIEW1 v;
0068     short s;
0069
0070     init_MYVIEW1(&v);
0071
0072     s = 0;
0073     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0074             EXSUCCEED);
0075     assert_equal(s, 15556);
0076
0077     /* Invalid value, index out of bounds.. */
0078     s = 0;
0079     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&s, 0L, BFLD_SHORT, 0L),
0080             EXFAIL);
0081     assert_equal(Berror, BEINVAL);
0082
0083     s = 0;
0084     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0085             EXSUCCEED);
0086     assert_equal(s, 9999);
0087
0088     s = 0;
0089     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&s, 0L, BFLD_SHORT, 0L),
0090             EXSUCCEED);
0091     assert_equal(s, 8888);
0092
0093     s = 0;
0094     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0095             EXSUCCEED);
0096     assert_equal(s, 7777);
0097
0098     s = 0;
0099     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&s, 0L, BFLD_SHORT, 0L),
0100             EXSUCCEED);
0101     assert_equal(s, -7777);
0102
0103     s = 0;
0104     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&s, 0L, BFLD_SHORT, 0L),
0105             EXSUCCEED);
0106     assert_equal(s, -7777);
0107
0108     s = 0;
0109     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&s, 0L,
0110             BFLD_SHORT, BVACCESS_NOTNULL),
0111             EXFAIL);
0112     assert_equal(Berror, BNOTPRES);
0113
0114     s = 0;
0115     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0116             EXSUCCEED);
0117     assert_equal(s, -10);
0118
0119
0120     s = 0;
0121     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0122             EXSUCCEED);
0123     assert_not_equal(s, 0);
0124
0125     s = 0;
0126     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0127             EXSUCCEED);
0128     assert_equal(s, -100);
0129
0130     /* non existent field: */
0131     s = 0;
0132     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0133             EXFAIL);
0134     assert_equal(Berror, BNOCNAME);
0135
0136     /* Test field NULL */
0137     v.tint4[0] = -1;
0138     v.tint4[1] = -1;
0139
0140     s = 0;
0141     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&s, 0L, BFLD_SHORT, 0L),
0142             EXSUCCEED);
0143     assert_equal(s, -1);
0144
0145     s = 0;
0146     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&s, 0L, BFLD_SHORT, 0L),
0147             EXSUCCEED);
0148     assert_equal(s, -1);
0149
0150
0151     /* not pres because of NULL value */
0152     s = 0;
0153     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&s, 0L,
0154             BFLD_SHORT, BVACCESS_NOTNULL),
0155             EXFAIL);
0156     assert_equal(Berror, BNOTPRES);
0157
0158     s = 0;
0159     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&s, 0L,
0160             BFLD_SHORT, BVACCESS_NOTNULL),
0161             EXFAIL);
0162     assert_equal(Berror, BNOTPRES);
0163
0164
0165     /* Test the ascii value to char */
0166     s = 0;
0167     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0168
0169     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&s, 0L,
0170             BFLD_SHORT, BVACCESS_NOTNULL),
0171             EXSUCCEED);
0172     assert_equal(s, 65);
0173
0174
0175     s = 0;
0176     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
0177
0178     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&s, 0L,
0179             BFLD_SHORT, BVACCESS_NOTNULL),
0180             EXFAIL);
0181     assert_equal(Berror, BNOTPRES);
0182
0183     s = 0;
0184     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&s, 0L,
0185             BFLD_SHORT, BVACCESS_NOTNULL),
0186             EXSUCCEED);
0187     assert_equal(s, 66);
0188
0189     s = 0;
0190     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&s, 0L,
0191             BFLD_SHORT, BVACCESS_NOTNULL),
0192             EXSUCCEED);
0193     assert_equal(s, 67);
0194
0195     s = 0;
0196     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&s, 0L,
0197             BFLD_SHORT, BVACCESS_NOTNULL),
0198             EXSUCCEED);
0199     assert_equal(s, '\n');
0200
0201     s = 0;
0202     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&s, 0L,
0203             BFLD_SHORT, BVACCESS_NOTNULL),
0204             EXSUCCEED);
0205     assert_equal(s, '\t');
0206
0207     s = 0;
0208     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&s, 0L,
0209             BFLD_SHORT, BVACCESS_NOTNULL),
0210             EXFAIL);
0211     assert_equal(Berror, BEINVAL);
0212
0213     s = 0;
0214     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&s, 0L,
0215             BFLD_SHORT, BVACCESS_NOTNULL),
0216             EXFAIL);
0217     assert_equal(Berror, BNOTPRES);
0218
0219     s = 0;
0220     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&s, 0L,
0221             BFLD_SHORT, BVACCESS_NOTNULL),
0222             EXFAIL);
0223     assert_equal(Berror, BNOTPRES);
0224
0225     s = 0;
0226     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&s, 0L,
0227             BFLD_SHORT, 0L),
0228             EXSUCCEED);
0229     assert_equal(s, 'C');
0230
0231     s = 0;
0232     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&s, 0L,
0233             BFLD_SHORT, 0L),
0234             EXSUCCEED);
0235     assert_equal(s, 'D');
0236
0237
0238     v.tfloat1[1] = 66.0f;
0239
0240     s = 0;
0241     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&s, 0L,
0242             BFLD_SHORT, 0L),
0243             EXSUCCEED);
0244     assert_equal(s, 66);
0245
0246
0247     v.tfloat1[1] = 66.0f;
0248
0249     s = 0;
0250     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&s, 0L,
0251             BFLD_SHORT, 0L),
0252             EXSUCCEED);
0253     assert_equal(s, 66);
0254
0255
0256     s = 0;
0257     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&s, 0L,
0258             BFLD_SHORT, 0L),
0259             EXSUCCEED);
0260     assert_equal(s,-999);
0261
0262
0263     NDRX_STRCPY_SAFE(v.tstring0[0], "125");
0264
0265     s = 0;
0266     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&s, 0L,
0267             BFLD_SHORT, 0L),
0268             EXSUCCEED);
0269     assert_equal(s,125);
0270
0271
0272     v.L_tcarray2 = 4; /* includes EOS.. */
0273     NDRX_STRCPY_SAFE(v.tcarray2, "521");
0274
0275
0276     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&s, 0L,
0277             BFLD_SHORT, 0L),
0278             EXSUCCEED);
0279     assert_equal(s,521);
0280
0281 }
0282
0283 /**
0284  * Test Bvget as long
0285  */
0286 Ensure(test_Bvget_long)
0287 {
0288     struct MYVIEW1 v;
0289     long l;
0290
0291     init_MYVIEW1(&v);
0292
0293     l = 0;
0294     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0295             EXSUCCEED);
0296     assert_equal(l, 15556);
0297
0298     /* Invalid value, index out of bounds.. */
0299     l = 0;
0300     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&l, 0L, BFLD_LONG, 0L),
0301             EXFAIL);
0302     assert_equal(Berror, BEINVAL);
0303
0304     l = 0;
0305     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0306             EXSUCCEED);
0307     assert_equal(l, 9999);
0308
0309     l = 0;
0310     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&l, 0L, BFLD_LONG, 0L),
0311             EXSUCCEED);
0312     assert_equal(l, 8888);
0313
0314     l = 0;
0315     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0316             EXSUCCEED);
0317     assert_equal(l, 7777);
0318
0319     l = 0;
0320     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&l, 0L, BFLD_LONG, 0L),
0321             EXSUCCEED);
0322     assert_equal(l, -7777);
0323
0324     l = 0;
0325     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&l, 0L, BFLD_LONG, 0L),
0326             EXSUCCEED);
0327     assert_equal(l, -7777);
0328
0329     l = 0;
0330     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&l, 0L,
0331             BFLD_LONG, BVACCESS_NOTNULL),
0332             EXFAIL);
0333     assert_equal(Berror, BNOTPRES);
0334
0335     l = 0;
0336     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0337             EXSUCCEED);
0338     assert_equal(l, -10);
0339
0340
0341     l = 0;
0342     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0343             EXSUCCEED);
0344     assert_equal(l, 33333333);
0345
0346     l = 0;
0347     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0348             EXSUCCEED);
0349     assert_equal(l, -100);
0350
0351     l = 0;
0352     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0353             EXSUCCEED);
0354     assert_equal(l, 1010101);
0355
0356     l = 0;
0357     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&l, 0L, BFLD_LONG, 0L),
0358             EXSUCCEED);
0359     assert_equal(l, 989898);
0360
0361     /* non existent field: */
0362     l = 0;
0363     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0364             EXFAIL);
0365     assert_equal(Berror, BNOCNAME);
0366
0367     /* Test field NULL */
0368     v.tint4[0] = -1;
0369     v.tint4[1] = -1;
0370
0371     l = 0;
0372     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&l, 0L, BFLD_LONG, 0L),
0373             EXSUCCEED);
0374     assert_equal(l, -1);
0375
0376     l = 0;
0377     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&l, 0L, BFLD_LONG, 0L),
0378             EXSUCCEED);
0379     assert_equal(l, -1);
0380
0381
0382     /* not pres because of NULL value */
0383     l = 0;
0384     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&l, 0L,
0385             BFLD_LONG, BVACCESS_NOTNULL),
0386             EXFAIL);
0387     assert_equal(Berror, BNOTPRES);
0388
0389     l = 0;
0390     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&l, 0L,
0391             BFLD_LONG, BVACCESS_NOTNULL),
0392             EXFAIL);
0393     assert_equal(Berror, BNOTPRES);
0394
0395
0396     /* Test the ascii value to char */
0397     l = 0;
0398     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0399
0400     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&l, 0L,
0401             BFLD_LONG, BVACCESS_NOTNULL),
0402             EXSUCCEED);
0403     assert_equal(l, 65);
0404
0405
0406     l = 0;
0407     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
0408
0409     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&l, 0L,
0410             BFLD_LONG, BVACCESS_NOTNULL),
0411             EXFAIL);
0412     assert_equal(Berror, BNOTPRES);
0413
0414     l = 0;
0415     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&l, 0L,
0416             BFLD_LONG, BVACCESS_NOTNULL),
0417             EXSUCCEED);
0418     assert_equal(l, 66);
0419
0420     l = 0;
0421     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&l, 0L,
0422             BFLD_LONG, BVACCESS_NOTNULL),
0423             EXSUCCEED);
0424     assert_equal(l, 67);
0425
0426     l = 0;
0427     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&l, 0L,
0428             BFLD_LONG, BVACCESS_NOTNULL),
0429             EXSUCCEED);
0430     assert_equal(l, '\n');
0431
0432     l = 0;
0433     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&l, 0L,
0434             BFLD_LONG, BVACCESS_NOTNULL),
0435             EXSUCCEED);
0436     assert_equal(l, '\t');
0437
0438     l = 0;
0439     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&l, 0L,
0440             BFLD_LONG, BVACCESS_NOTNULL),
0441             EXFAIL);
0442     assert_equal(Berror, BEINVAL);
0443
0444     l = 0;
0445     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&l, 0L,
0446             BFLD_LONG, BVACCESS_NOTNULL),
0447             EXFAIL);
0448     assert_equal(Berror, BNOTPRES);
0449
0450     l = 0;
0451     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&l, 0L,
0452             BFLD_LONG, BVACCESS_NOTNULL),
0453             EXFAIL);
0454     assert_equal(Berror, BNOTPRES);
0455
0456     l = 0;
0457     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&l, 0L,
0458             BFLD_LONG, 0L),
0459             EXSUCCEED);
0460     assert_equal(l, 'C');
0461
0462     l = 0;
0463     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&l, 0L,
0464             BFLD_LONG, 0L),
0465             EXSUCCEED);
0466     assert_equal(l, 'D');
0467
0468
0469     v.tfloat1[1] = 66.0f;
0470
0471     l = 0;
0472     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&l, 0L,
0473             BFLD_LONG, 0L),
0474             EXSUCCEED);
0475     assert_equal(l, 66);
0476
0477
0478     l = 0;
0479     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)&l, 0L,
0480             BFLD_LONG, 0L),
0481             EXSUCCEED);
0482     assert_equal(l, 100000);
0483
0484
0485     l = 0;
0486     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&l, 0L,
0487             BFLD_LONG, 0L),
0488             EXSUCCEED);
0489     assert_equal(l,11111);
0490
0491     l = 0;
0492     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&l, 0L,
0493             BFLD_LONG, 0L),
0494             EXSUCCEED);
0495     assert_equal(l,-999);
0496
0497
0498     NDRX_STRCPY_SAFE(v.tstring0[0], "125");
0499
0500     l = 0;
0501     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&l, 0L,
0502             BFLD_LONG, 0L),
0503             EXSUCCEED);
0504     assert_equal(l,125);
0505
0506
0507     v.L_tcarray2 = 4; /* includes EOS.. */
0508     NDRX_STRCPY_SAFE(v.tcarray2, "521");
0509
0510
0511     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&l, 0L,
0512             BFLD_LONG, 0L),
0513             EXSUCCEED);
0514     assert_equal(l,521);
0515
0516 }
0517
0518 /**
0519  * Test Bvget as char
0520  */
0521 Ensure(test_Bvget_char)
0522 {
0523     struct MYVIEW1 v;
0524
0525     char c;
0526     short s;
0527     long l;
0528
0529     init_MYVIEW1(&v);
0530
0531     c = 0;
0532     v.tshort1 = 65;
0533     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0534             EXSUCCEED);
0535     assert_equal(c, 'A');
0536
0537     /* Invalid value, index out of bounds.. */
0538     c = 0;
0539     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&c, 0L, BFLD_CHAR, 0L),
0540             EXFAIL);
0541     assert_equal(Berror, BEINVAL);
0542
0543
0544     v.tshort2[0] = 'a';
0545     c = 0;
0546     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0547             EXSUCCEED);
0548     assert_equal(c, 'a');
0549
0550
0551     v.tlong1 = 98;
0552     c = 0;
0553     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0554             EXSUCCEED);
0555     assert_equal(c, 'b');
0556
0557
0558     v.tint3 = 90;
0559     c = 0;
0560     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0561             EXSUCCEED);
0562     assert_equal(c, 'Z');
0563
0564
0565     c = 0;
0566     v.tint4[1] = 89;
0567     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&c, 0L, BFLD_CHAR, 0L),
0568             EXSUCCEED);
0569     assert_equal(c, 'Y');
0570
0571     /* non existent field: */
0572     c = 0;
0573     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0574             EXFAIL);
0575     assert_equal(Berror, BNOCNAME);
0576
0577     /* Test field NULL */
0578     v.tint4[0] = 104;
0579     v.tint4[1] = 105;
0580
0581     c = 0;
0582     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&c, 0L, BFLD_CHAR, 0L),
0583             EXSUCCEED);
0584     assert_equal(c, 'h');
0585
0586     c = 0;
0587     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&c, 0L, BFLD_CHAR, 0L),
0588             EXSUCCEED);
0589     assert_equal(c, 'i');
0590
0591
0592     /* not pres because of NULL value */
0593     c = 0;
0594     v.tint4[0]=-1;
0595     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&c, 0L,
0596             BFLD_CHAR, BVACCESS_NOTNULL),
0597             EXFAIL);
0598     assert_equal(Berror, BNOTPRES);
0599
0600     c = 0;
0601     v.tint4[1]=-1;
0602     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&c, 0L,
0603             BFLD_CHAR, BVACCESS_NOTNULL),
0604             EXFAIL);
0605     assert_equal(Berror, BNOTPRES);
0606
0607
0608     /* Test the ascii value to char */
0609     c = 0;
0610     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0611
0612     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&c, 0L,
0613             BFLD_CHAR, BVACCESS_NOTNULL),
0614             EXSUCCEED);
0615     assert_equal(c, 65);
0616
0617
0618     c = 0;
0619     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
0620
0621     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&c, 0L,
0622             BFLD_CHAR, BVACCESS_NOTNULL),
0623             EXFAIL);
0624     assert_equal(Berror, BNOTPRES);
0625
0626     c = 0;
0627     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&c, 0L,
0628             BFLD_CHAR, BVACCESS_NOTNULL),
0629             EXSUCCEED);
0630     assert_equal(c, 66);
0631
0632     c = 0;
0633     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&c, 0L,
0634             BFLD_CHAR, BVACCESS_NOTNULL),
0635             EXSUCCEED);
0636     assert_equal(c, 67);
0637
0638     c = 0;
0639     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&c, 0L,
0640             BFLD_CHAR, BVACCESS_NOTNULL),
0641             EXSUCCEED);
0642     assert_equal(c, '\n');
0643
0644     c = 0;
0645     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&c, 0L,
0646             BFLD_CHAR, BVACCESS_NOTNULL),
0647             EXSUCCEED);
0648     assert_equal(c, '\t');
0649
0650     c = 0;
0651     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&c, 0L,
0652             BFLD_CHAR, BVACCESS_NOTNULL),
0653             EXFAIL);
0654     assert_equal(Berror, BEINVAL);
0655
0656     c = 0;
0657     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&c, 0L,
0658             BFLD_CHAR, BVACCESS_NOTNULL),
0659             EXFAIL);
0660     assert_equal(Berror, BNOTPRES);
0661
0662     c = 0;
0663     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&c, 0L,
0664             BFLD_CHAR, BVACCESS_NOTNULL),
0665             EXFAIL);
0666     assert_equal(Berror, BNOTPRES);
0667
0668     c = 0;
0669     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&c, 0L,
0670             BFLD_CHAR, 0L),
0671             EXSUCCEED);
0672     assert_equal(c, 'C');
0673
0674     c = 0;
0675     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&c, 0L,
0676             BFLD_CHAR, 0L),
0677             EXSUCCEED);
0678     assert_equal(c, 'D');
0679
0680
0681     v.tfloat1[1] = 66.0f;
0682
0683     c = 0;
0684     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&c, 0L,
0685             BFLD_CHAR, 0L),
0686             EXSUCCEED);
0687     assert_equal(c, 66);
0688
0689
0690     c = 0;
0691     v.tdouble1[1]='D';
0692     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&c, 0L,
0693             BFLD_CHAR, 0L),
0694             EXSUCCEED);
0695     assert_equal(c,'D');
0696
0697
0698     NDRX_STRCPY_SAFE(v.tstring0[0], "X");
0699
0700     c = 0;
0701     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&c, 0L,
0702             BFLD_CHAR, 0L),
0703             EXSUCCEED);
0704     assert_equal(c,'X');
0705
0706
0707     v.L_tcarray2 = 0; /* includes EOS.. */
0708     NDRX_STRCPY_SAFE(v.tcarray2, "Y");
0709
0710
0711     /* Does not use EOS, just take first symbol.. */
0712     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&c, 0L,
0713             BFLD_CHAR, 0L),
0714             EXSUCCEED);
0715     assert_equal(c,'Y');
0716
0717 }
0718
0719 /**
0720  * Test Bvget as float
0721  */
0722 Ensure(test_Bvget_float)
0723 {
0724     struct MYVIEW1 v;
0725     float f;
0726
0727     init_MYVIEW1(&v);
0728
0729     f = 0;
0730     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0731             EXSUCCEED);
0732     assert_double_equal(f, 15556);
0733
0734     /* Invalid value, index out of bounds.. */
0735     f = 0;
0736     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&f, 0L, BFLD_FLOAT, 0L),
0737             EXFAIL);
0738     assert_double_equal(Berror, BEINVAL);
0739
0740     f = 0;
0741     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0742             EXSUCCEED);
0743     assert_double_equal(f, 9999);
0744
0745     f = 0;
0746     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&f, 0L, BFLD_FLOAT, 0L),
0747             EXSUCCEED);
0748     assert_double_equal(f, 8888);
0749
0750     f = 0;
0751     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0752             EXSUCCEED);
0753     assert_double_equal(f, 7777);
0754
0755     f = 0;
0756     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&f, 0L, BFLD_FLOAT, 0L),
0757             EXSUCCEED);
0758     assert_equal(f, -7777);
0759
0760     f = 0;
0761     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&f, 0L, BFLD_FLOAT, 0L),
0762             EXSUCCEED);
0763     assert_double_equal(f, -7777);
0764
0765     f = 0;
0766     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&f, 0L,
0767             BFLD_FLOAT, BVACCESS_NOTNULL),
0768             EXFAIL);
0769     assert_double_equal(Berror, BNOTPRES);
0770
0771     f = 0;
0772     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0773             EXSUCCEED);
0774     assert_double_equal(f, -10);
0775
0776
0777     f = 0;
0778     v.tlong1 = 333333;
0779     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0780             EXSUCCEED);
0781     assert_double_equal(f, 333333);
0782
0783     f = 0;
0784     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0785             EXSUCCEED);
0786     assert_double_equal(f, -100);
0787
0788     f = 0;
0789     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0790             EXSUCCEED);
0791     assert_double_equal(f, 1010101);
0792
0793     f = 0;
0794     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&f, 0L, BFLD_FLOAT, 0L),
0795             EXSUCCEED);
0796     assert_double_equal(f, 989898);
0797
0798     /* non existent field: */
0799     f = 0;
0800     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0801             EXFAIL);
0802     assert_equal(Berror, BNOCNAME);
0803
0804     /* Test field NULL */
0805     v.tint4[0] = -1;
0806     v.tint4[1] = -1;
0807
0808     f = 0;
0809     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&f, 0L, BFLD_FLOAT, 0L),
0810             EXSUCCEED);
0811     assert_double_equal(f, -1);
0812
0813     f = 0;
0814     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&f, 0L, BFLD_FLOAT, 0L),
0815             EXSUCCEED);
0816     assert_double_equal(f, -1);
0817
0818
0819     /* not pres because of NULL value */
0820     f = 0;
0821     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&f, 0L,
0822             BFLD_FLOAT, BVACCESS_NOTNULL),
0823             EXFAIL);
0824     assert_equal(Berror, BNOTPRES);
0825
0826     f = 0;
0827     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&f, 0L,
0828             BFLD_FLOAT, BVACCESS_NOTNULL),
0829             EXFAIL);
0830     assert_equal(Berror, BNOTPRES);
0831
0832
0833     /* Test the ascii value to char */
0834     f = 0;
0835     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0836
0837     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&f, 0L,
0838             BFLD_FLOAT, BVACCESS_NOTNULL),
0839             EXSUCCEED);
0840     assert_double_equal(f, 65);
0841
0842
0843     f = 0;
0844     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
0845
0846     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&f, 0L,
0847             BFLD_FLOAT, BVACCESS_NOTNULL),
0848             EXFAIL);
0849     assert_equal(Berror, BNOTPRES);
0850
0851     f = 0;
0852     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&f, 0L,
0853             BFLD_FLOAT, BVACCESS_NOTNULL),
0854             EXSUCCEED);
0855     assert_double_equal(f, 66);
0856
0857     f = 0;
0858     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&f, 0L,
0859             BFLD_FLOAT, BVACCESS_NOTNULL),
0860             EXSUCCEED);
0861     assert_double_equal(f, 67);
0862
0863     f = 0;
0864     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&f, 0L,
0865             BFLD_FLOAT, BVACCESS_NOTNULL),
0866             EXSUCCEED);
0867     assert_double_equal(f, '\n');
0868
0869     f = 0;
0870     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&f, 0L,
0871             BFLD_FLOAT, BVACCESS_NOTNULL),
0872             EXSUCCEED);
0873     assert_double_equal(f, '\t');
0874
0875     f = 0;
0876     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&f, 0L,
0877             BFLD_FLOAT, BVACCESS_NOTNULL),
0878             EXFAIL);
0879     assert_equal(Berror, BEINVAL);
0880
0881     f = 0;
0882     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&f, 0L,
0883             BFLD_FLOAT, BVACCESS_NOTNULL),
0884             EXFAIL);
0885     assert_equal(Berror, BNOTPRES);
0886
0887     f = 0;
0888     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&f, 0L,
0889             BFLD_FLOAT, BVACCESS_NOTNULL),
0890             EXFAIL);
0891     assert_equal(Berror, BNOTPRES);
0892
0893     f = 0;
0894     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&f, 0L,
0895             BFLD_FLOAT, 0L),
0896             EXSUCCEED);
0897     assert_double_equal(f, 'C');
0898
0899     f = 0;
0900     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&f, 0L,
0901             BFLD_FLOAT, 0L),
0902             EXSUCCEED);
0903     assert_double_equal(f, 'D');
0904
0905
0906     v.tfloat1[1] = 66.0f;
0907
0908     f = 0;
0909     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&f, 0L,
0910             BFLD_FLOAT, 0L),
0911             EXSUCCEED);
0912     assert_double_equal(f, 66);
0913
0914
0915     f = 0;
0916     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)&f, 0L,
0917             BFLD_FLOAT, 0L),
0918             EXSUCCEED);
0919     assert_double_equal(f, 100000.1);
0920
0921
0922     f = 0;
0923     v.tdouble1[1] = 11.44;
0924     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&f, 0L,
0925             BFLD_FLOAT, 0L),
0926             EXSUCCEED);
0927     assert_double_equal(f,11.44);
0928
0929     f = 0;
0930     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&f, 0L,
0931             BFLD_FLOAT, 0L),
0932             EXSUCCEED);
0933     assert_equal((fabs(f  + 999.123)<0.2), 1);
0934
0935
0936     NDRX_STRCPY_SAFE(v.tstring0[0], "125.77");
0937
0938     f = 0;
0939     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&f, 0L,
0940             BFLD_FLOAT, 0L),
0941             EXSUCCEED);
0942     assert_double_equal(f,125.77);
0943
0944
0945     v.L_tcarray2 = 6; /* includes EOS.. */
0946     NDRX_STRCPY_SAFE(v.tcarray2, "521.5");
0947
0948     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&f, 0L,
0949             BFLD_FLOAT, 0L),
0950             EXSUCCEED);
0951     assert_double_equal(f,521.5);
0952
0953 }
0954
0955 /**
0956  * Test Bvget as double
0957  */
0958 Ensure(test_Bvget_double)
0959 {
0960     struct MYVIEW1 v;
0961     double d;
0962
0963     init_MYVIEW1(&v);
0964
0965     d = 0;
0966     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0967             EXSUCCEED);
0968     assert_double_equal(d, 15556);
0969
0970     /* Invalid value, index out of bounds.. */
0971     d = 0;
0972     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0973             EXFAIL);
0974     assert_double_equal(Berror, BEINVAL);
0975
0976     d = 0;
0977     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0978             EXSUCCEED);
0979     assert_double_equal(d, 9999);
0980
0981     d = 0;
0982     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0983             EXSUCCEED);
0984     assert_double_equal(d, 8888);
0985
0986     d = 0;
0987     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0988             EXSUCCEED);
0989     assert_double_equal(d, 7777);
0990
0991     d = 0;
0992     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0993             EXSUCCEED);
0994     assert_equal(d, -7777);
0995
0996     d = 0;
0997     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&d, 0L, BFLD_DOUBLE, 0L),
0998             EXSUCCEED);
0999     assert_double_equal(d, -7777);
1000
1001     d = 0;
1002     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&d, 0L,
1003             BFLD_DOUBLE, BVACCESS_NOTNULL),
1004             EXFAIL);
1005     assert_double_equal(Berror, BNOTPRES);
1006
1007     d = 0;
1008     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1009             EXSUCCEED);
1010     assert_double_equal(d, -10);
1011
1012
1013     d = 0;
1014     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1015             EXSUCCEED);
1016     assert_double_equal(d, 33333333);
1017
1018     d = 0;
1019     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1020             EXSUCCEED);
1021     assert_double_equal(d, -100);
1022
1023     d = 0;
1024     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1025             EXSUCCEED);
1026     assert_double_equal(d, 1010101);
1027
1028     d = 0;
1029     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1030             EXSUCCEED);
1031     assert_double_equal(d, 989898);
1032
1033     /* non existent field: */
1034     d = 0;
1035     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1036             EXFAIL);
1037     assert_equal(Berror, BNOCNAME);
1038
1039     /* Test field NULL */
1040     v.tint4[0] = -1;
1041     v.tint4[1] = -1;
1042
1043     d = 0;
1044     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1045             EXSUCCEED);
1046     assert_double_equal(d, -1);
1047
1048     d = 0;
1049     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&d, 0L, BFLD_DOUBLE, 0L),
1050             EXSUCCEED);
1051     assert_double_equal(d, -1);
1052
1053
1054     /* not pres because of NULL value */
1055     d = 0;
1056     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&d, 0L,
1057             BFLD_DOUBLE, BVACCESS_NOTNULL),
1058             EXFAIL);
1059     assert_equal(Berror, BNOTPRES);
1060
1061     d = 0;
1062     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&d, 0L,
1063             BFLD_DOUBLE, BVACCESS_NOTNULL),
1064             EXFAIL);
1065     assert_equal(Berror, BNOTPRES);
1066
1067
1068     /* Test the ascii value to char */
1069     d = 0;
1070     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
1071
1072     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&d, 0L,
1073             BFLD_DOUBLE, BVACCESS_NOTNULL),
1074             EXSUCCEED);
1075     assert_double_equal(d, 65);
1076
1077
1078     d = 0;
1079     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
1080
1081     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&d, 0L,
1082             BFLD_DOUBLE, BVACCESS_NOTNULL),
1083             EXFAIL);
1084     assert_equal(Berror, BNOTPRES);
1085
1086     d = 0;
1087     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&d, 0L,
1088             BFLD_DOUBLE, BVACCESS_NOTNULL),
1089             EXSUCCEED);
1090     assert_double_equal(d, 66);
1091
1092     d = 0;
1093     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&d, 0L,
1094             BFLD_DOUBLE, BVACCESS_NOTNULL),
1095             EXSUCCEED);
1096     assert_double_equal(d, 67);
1097
1098     d = 0;
1099     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&d, 0L,
1100             BFLD_DOUBLE, BVACCESS_NOTNULL),
1101             EXSUCCEED);
1102     assert_double_equal(d, '\n');
1103
1104     d = 0;
1105     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&d, 0L,
1106             BFLD_DOUBLE, BVACCESS_NOTNULL),
1107             EXSUCCEED);
1108     assert_double_equal(d, '\t');
1109
1110     d = 0;
1111     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&d, 0L,
1112             BFLD_DOUBLE, BVACCESS_NOTNULL),
1113             EXFAIL);
1114     assert_equal(Berror, BEINVAL);
1115
1116     d = 0;
1117     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&d, 0L,
1118             BFLD_DOUBLE, BVACCESS_NOTNULL),
1119             EXFAIL);
1120     assert_equal(Berror, BNOTPRES);
1121
1122     d = 0;
1123     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&d, 0L,
1124             BFLD_DOUBLE, BVACCESS_NOTNULL),
1125             EXFAIL);
1126     assert_equal(Berror, BNOTPRES);
1127
1128     d = 0;
1129     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&d, 0L,
1130             BFLD_DOUBLE, 0L),
1131             EXSUCCEED);
1132     assert_double_equal(d, 'C');
1133
1134     d = 0;
1135     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&d, 0L,
1136             BFLD_DOUBLE, 0L),
1137             EXSUCCEED);
1138     assert_double_equal(d, 'D');
1139
1140
1141     v.tfloat1[1] = 66.0f;
1142
1143     d = 0;
1144     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&d, 0L,
1145             BFLD_DOUBLE, 0L),
1146             EXSUCCEED);
1147     assert_double_equal(d, 66);
1148
1149
1150     d = 0;
1151     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)&d, 0L,
1152             BFLD_DOUBLE, 0L),
1153             EXSUCCEED);
1154     assert_double_equal(d, 100000.1);
1155
1156
1157     d = 0;
1158     v.tdouble1[1] = 11.44;
1159     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&d, 0L,
1160             BFLD_DOUBLE, 0L),
1161             EXSUCCEED);
1162     assert_double_equal(d,11.44);
1163
1164     d = 0;
1165     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&d, 0L,
1166             BFLD_DOUBLE, 0L),
1167             EXSUCCEED);
1168     assert_double_equal(d,-999.123);
1169
1170
1171     NDRX_STRCPY_SAFE(v.tstring0[0], "125.77");
1172
1173     d = 0;
1174     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&d, 0L,
1175             BFLD_DOUBLE, 0L),
1176             EXSUCCEED);
1177     assert_double_equal(d,125.77);
1178
1179
1180     v.L_tcarray2 = 6; /* includes EOS.. */
1181     NDRX_STRCPY_SAFE(v.tcarray2, "521.5");
1182
1183     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&d, 0L,
1184             BFLD_DOUBLE, 0L),
1185             EXSUCCEED);
1186     assert_double_equal(d,521.5);
1187
1188 }
1189
1190 /**
1191  * Test Bvget as string
1192  */
1193 Ensure(test_Bvget_string)
1194 {
1195     struct MYVIEW1 v;
1196     char s[255];
1197     BFLDLEN len;
1198
1199     init_MYVIEW1(&v);
1200
1201     s[0] = EXEOS;
1202     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)s, 0L, BFLD_STRING, 0L),
1203             EXSUCCEED);
1204     assert_string_equal(s, "15556");
1205
1206
1207     s[0] = EXEOS;
1208     len = 255;
1209     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)s, &len, BFLD_STRING, 0L),
1210             EXSUCCEED);
1211     assert_string_equal(s, "15556");
1212     assert_equal(len, 6); /* + EOS */
1213
1214     /* test buffer no space */
1215     s[0] = EXEOS;
1216     len = 1;
1217     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)s, &len, BFLD_STRING, 0L),
1218             EXFAIL);
1219     assert_equal(Berror, BNOSPACE);
1220
1221
1222     s[0] = EXEOS;
1223     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)s, 0L, BFLD_STRING, 0L),
1224             EXSUCCEED);
1225     assert_string_equal(s, "15556");
1226
1227     /* Invalid value, index out of bounds.. */
1228     s[0] = EXEOS;
1229     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)s, 0L, BFLD_STRING, 0L),
1230             EXFAIL);
1231     assert_equal(Berror, BEINVAL);
1232
1233     s[0] = EXEOS;
1234     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)s, 0L, BFLD_STRING, 0L),
1235             EXSUCCEED);
1236     assert_string_equal(s, "9999");
1237
1238     s[0] = EXEOS;
1239     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)s, 0L, BFLD_STRING, 0L),
1240             EXSUCCEED);
1241     assert_string_equal(s, "8888");
1242
1243     s[0] = EXEOS;
1244     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)s, 0L, BFLD_STRING, 0L),
1245             EXSUCCEED);
1246     assert_string_equal(s, "7777");
1247
1248     s[0] = EXEOS;
1249     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)s, 0L, BFLD_STRING, 0L),
1250             EXSUCCEED);
1251     assert_string_equal(s, "-7777");
1252
1253     s[0] = EXEOS;
1254     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)s, 0L, BFLD_STRING, 0L),
1255             EXSUCCEED);
1256     assert_string_equal(s, "-7777");
1257
1258     s[0] = EXEOS;
1259     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)s, 0L,
1260             BFLD_STRING, BVACCESS_NOTNULL),
1261             EXFAIL);
1262     assert_equal(Berror, BNOTPRES);
1263
1264     s[0] = EXEOS;
1265     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)s, 0L, BFLD_STRING, 0L),
1266             EXSUCCEED);
1267     assert_string_equal(s, "-10");
1268
1269
1270     s[0] = EXEOS;
1271     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)s, 0L, BFLD_STRING, 0L),
1272             EXSUCCEED);
1273     assert_string_equal(s, "33333333");
1274
1275     s[0] = EXEOS;
1276     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)s, 0L, BFLD_STRING, 0L),
1277             EXSUCCEED);
1278     assert_string_equal(s, "-100");
1279
1280     s[0] = EXEOS;
1281     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)s, 0L, BFLD_STRING, 0L),
1282             EXSUCCEED);
1283     assert_string_equal(s, "1010101");
1284
1285     s[0] = EXEOS;
1286     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)s, 0L, BFLD_STRING, 0L),
1287             EXSUCCEED);
1288     assert_string_equal(s, "989898");
1289
1290     /* non existent field: */
1291     s[0] = EXEOS;
1292     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)s, 0L, BFLD_STRING, 0L),
1293             EXFAIL);
1294     assert_equal(Berror, BNOCNAME);
1295
1296     /* Test field NULL */
1297
1298     v.tint4[0] = -1;
1299     v.tint4[1] = -1;
1300     s[0] = EXEOS;
1301     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)s, 0L, BFLD_STRING, 0L),
1302             EXSUCCEED);
1303     assert_string_equal(s, "-1");
1304
1305     s[0] = EXEOS;
1306     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)s, 0L, BFLD_STRING, 0L),
1307             EXSUCCEED);
1308     assert_string_equal(s, "-1");
1309
1310     /* not pres because of NULL value */
1311     s[0] = EXEOS;
1312     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)s, 0L,
1313             BFLD_STRING, BVACCESS_NOTNULL),
1314             EXFAIL);
1315     assert_equal(Berror, BNOTPRES);
1316
1317     s[0] = EXEOS;
1318     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)s, 0L,
1319             BFLD_STRING, BVACCESS_NOTNULL),
1320             EXFAIL);
1321     assert_equal(Berror, BNOTPRES);
1322
1323
1324     /* Test the ascii value to char */
1325     s[0] = EXEOS;
1326     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
1327
1328     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)s, 0L,
1329             BFLD_STRING, BVACCESS_NOTNULL),
1330             EXSUCCEED);
1331     assert_string_equal(s, "A");
1332
1333
1334     s[0] = EXEOS;
1335     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
1336
1337     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)s, 0L,
1338             BFLD_STRING, BVACCESS_NOTNULL),
1339             EXFAIL);
1340     assert_equal(Berror, BNOTPRES);
1341
1342     s[0] = EXEOS;
1343     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)s, 0L,
1344             BFLD_STRING, BVACCESS_NOTNULL),
1345             EXSUCCEED);
1346     assert_string_equal(s, "B");
1347
1348     s[0] = EXEOS;
1349     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)s, 0L,
1350             BFLD_STRING, BVACCESS_NOTNULL),
1351             EXSUCCEED);
1352     assert_string_equal(s, "C");
1353
1354     s[0] = EXEOS;
1355     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)s, 0L,
1356             BFLD_STRING, BVACCESS_NOTNULL),
1357             EXSUCCEED);
1358     assert_string_equal(s, "\n");
1359
1360     s[0] = EXEOS;
1361     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)s, 0L,
1362             BFLD_STRING, BVACCESS_NOTNULL),
1363             EXSUCCEED);
1364     assert_string_equal(s, "\t");
1365
1366     s[0] = EXEOS;
1367     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)s, 0L,
1368             BFLD_STRING, BVACCESS_NOTNULL),
1369             EXFAIL);
1370     assert_equal(Berror, BEINVAL);
1371
1372     s[0] = EXEOS;
1373     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)s, 0L,
1374             BFLD_STRING, BVACCESS_NOTNULL),
1375             EXFAIL);
1376     assert_equal(Berror, BNOTPRES);
1377
1378     s[0] = EXEOS;
1379     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)s, 0L,
1380             BFLD_STRING, BVACCESS_NOTNULL),
1381             EXFAIL);
1382     assert_equal(Berror, BNOTPRES);
1383
1384     s[0] = EXEOS;
1385     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)s, 0L,
1386             BFLD_STRING, 0L),
1387             EXSUCCEED);
1388     assert_string_equal(s, "C");
1389
1390     s[0] = EXEOS;
1391     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)s, 0L,
1392             BFLD_STRING, 0L),
1393             EXSUCCEED);
1394     assert_string_equal(s, "D");
1395
1396     v.tfloat1[1] = 66.0f;
1397
1398     s[0] = EXEOS;
1399     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)s, 0L,
1400             BFLD_STRING, 0L),
1401             EXSUCCEED);
1402     assert_string_equal(s, "66.00000");
1403
1404
1405     s[0] = EXEOS;
1406     v.tfloat2[0] = 1.22;
1407     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)s, 0L,
1408             BFLD_STRING, 0L),
1409             EXSUCCEED);
1410     assert_string_equal(s, "1.22000");
1411
1412
1413     s[0] = EXEOS;
1414     v.tdouble1[1] = 11.44;
1415     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)s, 0L,
1416             BFLD_STRING, 0L),
1417             EXSUCCEED);
1418     assert_string_equal(s,"11.440000");
1419
1420     s[0] = EXEOS;
1421     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)s, 0L,
1422             BFLD_STRING, 0L),
1423             EXSUCCEED);
1424     assert_string_equal(s,"-999.123000");
1425
1426
1427     NDRX_STRCPY_SAFE(v.tstring0[0], "HELLO WOLRD");
1428
1429     s[0] = EXEOS;
1430     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)s, 0L,
1431             BFLD_STRING, 0L),
1432             EXSUCCEED);
1433     assert_string_equal(s,"HELLO WOLRD");
1434
1435
1436     v.L_tcarray2 = 6; /* includes EOS.. */
1437     NDRX_STRCPY_SAFE(v.tcarray2, "HELLOO");
1438
1439     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)s, 0L,
1440             BFLD_STRING, 0L),
1441             EXSUCCEED);
1442     assert_string_equal(s,"HELLOO");
1443
1444 }
1445
1446 /**
1447  * Test Bvget as carray
1448  */
1449 Ensure(test_Bvget_carray)
1450 {
1451     struct MYVIEW1 v;
1452     char c[255];
1453     BFLDLEN len;
1454
1455     init_MYVIEW1(&v);
1456
1457     c[0] = EXEOS;
1458     len = sizeof(c);
1459     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)c, &len, BFLD_CARRAY, 0L),
1460             EXSUCCEED);
1461     assert_equal(0==strncmp(c, "15556", 5), 1);
1462     assert_equal(len, 5);
1463
1464     c[0] = EXEOS;
1465     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1466             EXSUCCEED);
1467     assert_equal(0==strncmp(c, "15556", 5), 1);
1468
1469     /* test buffer no space */
1470     c[0] = EXEOS;
1471     len = 1;
1472     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)c, &len, BFLD_CARRAY, 0L),
1473             EXFAIL);
1474     assert_equal(Berror, BNOSPACE);
1475
1476     c[0] = EXEOS;
1477     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1478             EXSUCCEED);
1479     assert_equal(0==strncmp(c, "15556", 5), 1);
1480
1481     /* Invalid value, index out of bounds.. */
1482     c[0] = EXEOS;
1483     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)c, 0L, BFLD_CARRAY, 0L),
1484             EXFAIL);
1485     assert_equal(Berror, BEINVAL);
1486
1487     c[0] = EXEOS;
1488     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1489             EXSUCCEED);
1490     c[4] =EXEOS;
1491     assert_string_equal(c, "9999");
1492
1493     c[0] = EXEOS;
1494     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)c, 0L, BFLD_CARRAY, 0L),
1495             EXSUCCEED);
1496     c[4] = EXEOS;
1497     assert_string_equal(c, "8888");
1498
1499     c[0] = EXEOS;
1500     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1501             EXSUCCEED);
1502     assert_string_equal(c, "7777");
1503
1504     c[0] = EXEOS;
1505     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)c, 0L, BFLD_CARRAY, 0L),
1506             EXSUCCEED);
1507     c[5] = EXEOS;
1508     assert_string_equal(c, "-7777");
1509
1510     c[0] = EXEOS;
1511     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)c, 0L, BFLD_CARRAY, 0L),
1512             EXSUCCEED);
1513     c[5] = EXEOS;
1514     assert_string_equal(c, "-7777");
1515
1516     c[0] = EXEOS;
1517     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)c, 0L,
1518             BFLD_CARRAY, BVACCESS_NOTNULL),
1519             EXFAIL);
1520     assert_equal(Berror, BNOTPRES);
1521
1522     c[0] = EXEOS;
1523     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1524             EXSUCCEED);
1525     c[3] = EXEOS;
1526     assert_string_equal(c, "-10");
1527
1528
1529     c[0] = EXEOS;
1530     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1531             EXSUCCEED);
1532     c[8] = EXEOS;
1533     assert_string_equal(c, "33333333");
1534
1535     c[0] = EXEOS;
1536     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1537             EXSUCCEED);
1538     c[4] = EXEOS;
1539     assert_string_equal(c, "-100");
1540
1541     c[0] = EXEOS;
1542     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1543             EXSUCCEED);
1544     c[7] = EXEOS;
1545     assert_string_equal(c, "1010101");
1546
1547     c[0] = EXEOS;
1548     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)c, 0L, BFLD_CARRAY, 0L),
1549             EXSUCCEED);
1550     c[6] = EXEOS;
1551     assert_string_equal(c, "989898");
1552
1553     /* non existent field: */
1554     c[0] = EXEOS;
1555     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1556             EXFAIL);
1557     assert_equal(Berror, BNOCNAME);
1558
1559     /* Test field NULL */
1560
1561     v.tint4[0] = -1;
1562     v.tint4[1] = -1;
1563     c[0] = EXEOS;
1564     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)c, 0L, BFLD_CARRAY, 0L),
1565             EXSUCCEED);
1566     c[2] = EXEOS;
1567     assert_string_equal(c, "-1");
1568
1569     c[0] = EXEOS;
1570     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)c, 0L, BFLD_CARRAY, 0L),
1571             EXSUCCEED);
1572     c[2] = EXEOS;
1573     assert_string_equal(c, "-1");
1574
1575     /* not pres because of NULL value */
1576     c[0] = EXEOS;
1577     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)c, 0L,
1578             BFLD_CARRAY, BVACCESS_NOTNULL),
1579             EXFAIL);
1580     assert_equal(Berror, BNOTPRES);
1581
1582     c[0] = EXEOS;
1583     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)c, 0L,
1584             BFLD_CARRAY, BVACCESS_NOTNULL),
1585             EXFAIL);
1586     assert_equal(Berror, BNOTPRES);
1587
1588
1589     /* Test the ascii value to char */
1590     c[0] = EXEOS;
1591     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
1592
1593     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)c, 0L,
1594             BFLD_CARRAY, BVACCESS_NOTNULL),
1595             EXSUCCEED);
1596     c[1] = EXEOS;
1597     assert_string_equal(c, "A");
1598
1599
1600     c[0] = EXEOS;
1601     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
1602
1603     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)c, 0L,
1604             BFLD_CARRAY, BVACCESS_NOTNULL),
1605             EXFAIL);
1606     assert_equal(Berror, BNOTPRES);
1607
1608     c[0] = EXEOS;
1609     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)c, 0L,
1610             BFLD_CARRAY, BVACCESS_NOTNULL),
1611             EXSUCCEED);
1612     c[1] = EXEOS;
1613     assert_string_equal(c, "B");
1614
1615     c[0] = EXEOS;
1616     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)c, 0L,
1617             BFLD_CARRAY, BVACCESS_NOTNULL),
1618             EXSUCCEED);
1619
1620     c[1] = EXEOS;
1621     assert_string_equal(c, "C");
1622
1623     c[0] = EXEOS;
1624     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)c, 0L,
1625             BFLD_CARRAY, BVACCESS_NOTNULL),
1626             EXSUCCEED);
1627     c[1] = EXEOS;
1628     assert_string_equal(c, "\n");
1629
1630     c[0] = EXEOS;
1631     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)c, 0L,
1632             BFLD_CARRAY, BVACCESS_NOTNULL),
1633             EXSUCCEED);
1634     c[1] = EXEOS;
1635     assert_string_equal(c, "\t");
1636
1637     c[0] = EXEOS;
1638     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)c, 0L,
1639             BFLD_CARRAY, BVACCESS_NOTNULL),
1640             EXFAIL);
1641     assert_equal(Berror, BEINVAL);
1642
1643     c[0] = EXEOS;
1644     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)c, 0L,
1645             BFLD_CARRAY, BVACCESS_NOTNULL),
1646             EXFAIL);
1647     assert_equal(Berror, BNOTPRES);
1648
1649     c[0] = EXEOS;
1650     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)c, 0L,
1651             BFLD_CARRAY, BVACCESS_NOTNULL),
1652             EXFAIL);
1653     assert_equal(Berror, BNOTPRES);
1654
1655     c[0] = EXEOS;
1656     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)c, 0L,
1657             BFLD_CARRAY, 0L),
1658             EXSUCCEED);
1659     c[1] = EXEOS;
1660     assert_string_equal(c, "C");
1661
1662     c[0] = EXEOS;
1663     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)c, 0L,
1664             BFLD_CARRAY, 0L),
1665             EXSUCCEED);
1666     c[1] = EXEOS;
1667     assert_string_equal(c, "D");
1668
1669     v.tfloat1[1] = 66.0f;
1670
1671     c[0] = EXEOS;
1672     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)c, 0L,
1673             BFLD_CARRAY, 0L),
1674             EXSUCCEED);
1675     c[8] = EXEOS;
1676     assert_string_equal(c, "66.00000");
1677
1678
1679     c[0] = EXEOS;
1680     v.tfloat2[0] = 1.22;
1681     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)c, 0L,
1682             BFLD_CARRAY, 0L),
1683             EXSUCCEED);
1684     c[7] = EXEOS;
1685     assert_string_equal(c, "1.22000");
1686
1687
1688     c[0] = EXEOS;
1689     v.tdouble1[1] = 11.44;
1690     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)c, 0L,
1691             BFLD_CARRAY, 0L),
1692             EXSUCCEED);
1693     c[9] = EXEOS;
1694     assert_string_equal(c, "11.440000");
1695
1696     c[0] = EXEOS;
1697     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)c, 0L,
1698             BFLD_CARRAY, 0L),
1699             EXSUCCEED);
1700     c[11] = EXEOS;
1701     assert_string_equal(c,"-999.123000");
1702
1703
1704     NDRX_STRCPY_SAFE(v.tstring0[0], "HELLO WOLRD");
1705
1706     c[0] = EXEOS;
1707     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)c, 0L,
1708             BFLD_CARRAY, 0L),
1709             EXSUCCEED);
1710     c[11] =EXEOS;
1711     assert_string_equal(c, "HELLO WOLRD");
1712
1713
1714     v.L_tcarray2 = 6; /* includes EOS.. */
1715     NDRX_STRCPY_SAFE(v.tcarray2, "HELLOO");
1716
1717     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)c, 0L,
1718             BFLD_CARRAY, 0L),
1719             EXSUCCEED);
1720
1721     c[6] = EXEOS;
1722     assert_string_equal(c,"HELLOO");
1723
1724 }
1725
1726 /**
1727  * Test Bvget as int
1728  */
1729 Ensure(test_Bvget_int)
1730 {
1731     struct MYVIEW1 v;
1732     int i;
1733     init_MYVIEW1(&v);
1734
1735     i = 0;
1736     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&i, 0L, BFLD_INT, 0L),
1737             EXSUCCEED);
1738     assert_equal(i, 15556);
1739
1740     /* Invalid value, index out of bounds.. */
1741     i = 0;
1742     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&i, 0L, BFLD_INT, 0L),
1743             EXFAIL);
1744     assert_equal(Berror, BEINVAL);
1745
1746     i = 0;
1747     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&i, 0L, BFLD_INT, 0L),
1748             EXSUCCEED);
1749     assert_equal(i, 9999);
1750
1751     i = 0;
1752     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&i, 0L, BFLD_INT, 0L),
1753             EXSUCCEED);
1754     assert_equal(i, 8888);
1755
1756     i = 0;
1757     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&i, 0L, BFLD_INT, 0L),
1758             EXSUCCEED);
1759     assert_equal(i, 7777);
1760
1761     i = 0;
1762     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&i, 0L, BFLD_INT, 0L),
1763             EXSUCCEED);
1764     assert_equal(i, -7777);
1765
1766     i = 0;
1767     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&i, 0L, BFLD_INT, 0L),
1768             EXSUCCEED);
1769     assert_equal(i, -7777);
1770
1771     i = 0;
1772     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&i, 0L,
1773             BFLD_INT, BVACCESS_NOTNULL),
1774             EXFAIL);
1775     assert_equal(Berror, BNOTPRES);
1776
1777     i = 0;
1778     assert_equal(CBvget((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&i, 0L, BFLD_INT, 0L),
1779             EXSUCCEED);
1780     assert_equal(i, -10);
1781
1782
1783     i = 0;
1784     assert_equal(CBvget((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&i, 0L, BFLD_INT, 0L),
1785             EXSUCCEED);
1786     assert_equal(i, 33333333);
1787
1788     i = 0;
1789     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint3", 0, (char *)&i, 0L, BFLD_INT, 0L),
1790             EXSUCCEED);
1791     assert_equal(i, -100);
1792
1793     i = 0;
1794     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&i, 0L, BFLD_INT, 0L),
1795             EXSUCCEED);
1796     assert_equal(i, 1010101);
1797
1798     i = 0;
1799     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&i, 0L, BFLD_INT, 0L),
1800             EXSUCCEED);
1801     assert_equal(i, 989898);
1802
1803     /* non existent field: */
1804     i = 0;
1805     assert_equal(CBvget((char *)&v, "MYVIEW1", "xint3", 0, (char *)&i, 0L, BFLD_INT, 0L),
1806             EXFAIL);
1807     assert_equal(Berror, BNOCNAME);
1808
1809     /* Test field NULL */
1810     v.tint4[0] = -1;
1811     v.tint4[1] = -1;
1812
1813     i = 0;
1814     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&i, 0L, BFLD_INT, 0L),
1815             EXSUCCEED);
1816     assert_equal(i, -1);
1817
1818     i = 0;
1819     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&i, 0L, BFLD_INT, 0L),
1820             EXSUCCEED);
1821     assert_equal(i, -1);
1822
1823
1824     /* not pres because of NULL value */
1825     i = 0;
1826     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 0, (char *)&i, 0L,
1827             BFLD_INT, BVACCESS_NOTNULL),
1828             EXFAIL);
1829     assert_equal(Berror, BNOTPRES);
1830
1831     i = 0;
1832     assert_equal(CBvget((char *)&v, "MYVIEW1", "tint4", 1, (char *)&i, 0L,
1833             BFLD_INT, BVACCESS_NOTNULL),
1834             EXFAIL);
1835     assert_equal(Berror, BNOTPRES);
1836
1837
1838     /* Test the ascii value to char */
1839     i = 0;
1840     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
1841
1842     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&i, 0L,
1843             BFLD_INT, BVACCESS_NOTNULL),
1844             EXSUCCEED);
1845     assert_equal(i, 65);
1846
1847
1848     i = 0;
1849     NDRX_LOG(log_debug, "tchar2=%c", v.tchar1);
1850
1851     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 0, (char *)&i, 0L,
1852             BFLD_INT, BVACCESS_NOTNULL),
1853             EXFAIL);
1854     assert_equal(Berror, BNOTPRES);
1855
1856     i = 0;
1857     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&i, 0L,
1858             BFLD_INT, BVACCESS_NOTNULL),
1859             EXSUCCEED);
1860     assert_equal(i, 66);
1861
1862     i = 0;
1863     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&i, 0L,
1864             BFLD_INT, BVACCESS_NOTNULL),
1865             EXSUCCEED);
1866     assert_equal(i, 67);
1867
1868     i = 0;
1869     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 3, (char *)&i, 0L,
1870             BFLD_INT, BVACCESS_NOTNULL),
1871             EXSUCCEED);
1872     assert_equal(i, '\n');
1873
1874     i = 0;
1875     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 4, (char *)&i, 0L,
1876             BFLD_INT, BVACCESS_NOTNULL),
1877             EXSUCCEED);
1878     assert_equal(i, '\t');
1879
1880     i = 0;
1881     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar2", 5, (char *)&i, 0L,
1882             BFLD_INT, BVACCESS_NOTNULL),
1883             EXFAIL);
1884     assert_equal(Berror, BEINVAL);
1885
1886     i = 0;
1887     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&i, 0L,
1888             BFLD_INT, BVACCESS_NOTNULL),
1889             EXFAIL);
1890     assert_equal(Berror, BNOTPRES);
1891
1892     i = 0;
1893     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&i, 0L,
1894             BFLD_INT, BVACCESS_NOTNULL),
1895             EXFAIL);
1896     assert_equal(Berror, BNOTPRES);
1897
1898     i = 0;
1899     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 0, (char *)&i, 0L,
1900             BFLD_INT, 0L),
1901             EXSUCCEED);
1902     assert_equal(i, 'C');
1903
1904     i = 0;
1905     assert_equal(CBvget((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&i, 0L,
1906             BFLD_INT, 0L),
1907             EXSUCCEED);
1908     assert_equal(i, 'D');
1909
1910
1911     v.tfloat1[1] = 66.0f;
1912
1913     i = 0;
1914     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&i, 0L,
1915             BFLD_INT, 0L),
1916             EXSUCCEED);
1917     assert_equal(i, 66);
1918
1919
1920     i = 0;
1921     assert_equal(CBvget((char *)&v, "MYVIEW1", "tfloat2", 0, (char *)&i, 0L,
1922             BFLD_INT, 0L),
1923             EXSUCCEED);
1924     assert_equal(i, 100000);
1925
1926
1927     i = 0;
1928     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&i, 0L,
1929             BFLD_INT, 0L),
1930             EXSUCCEED);
1931     assert_equal(i,11111);
1932
1933     i = 0;
1934     assert_equal(CBvget((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&i, 0L,
1935             BFLD_INT, 0L),
1936             EXSUCCEED);
1937     assert_equal(i,-999);
1938
1939
1940     NDRX_STRCPY_SAFE(v.tstring0[0], "125");
1941
1942     i = 0;
1943     assert_equal(CBvget((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&i, 0L,
1944             BFLD_INT, 0L),
1945             EXSUCCEED);
1946     assert_equal(i,125);
1947
1948
1949     v.L_tcarray2 = 4; /* includes EOS.. */
1950     NDRX_STRCPY_SAFE(v.tcarray2, "521");
1951
1952     assert_equal(CBvget((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&i, 0L,
1953             BFLD_INT, 0L),
1954             EXSUCCEED);
1955     assert_equal(i,521);
1956
1957 }
1958
1959 /**
1960  * Test Bvgetalloc(0
1961  * This is based on CBvget(), thus just check few buffer allocations
1962  *
1963  */
1964 Ensure(test_CBvgetalloc)
1965 {
1966     struct MYVIEW1 v;
1967     char *ret;
1968     BFLDLEN extra=0;
1969
1970     init_MYVIEW1(&v);
1971
1972     /* cast overflow test... */
1973     v.tdouble2=9999991.55551111312313;
1974     ret = CBvgetalloc((char *)&v, "MYVIEW1", "tdouble2", 0, BFLD_STRING, 0, &extra);
1975     assert_not_equal(ret, NULL);
1976     assert_equal(0==strncmp("9999991", ret, 7), EXTRUE);
1977     NDRX_FREE(ret);
1978
1979     /* Check other castings too.. */
1980     memset(v.tcarray1, 0, sizeof(v.tcarray1));
1981
1982     v.tcarray1[0]='A';
1983     v.tcarray1[1]='B';
1984     v.tcarray1[2]='C';
1985
1986     extra=0;
1987
1988     ret = CBvgetalloc((char *)&v, "MYVIEW1", "tcarray1", 0, BFLD_STRING, 0, &extra);
1989     assert_not_equal(ret, NULL);
1990     assert_string_equal(ret, "ABC");
1991     assert_equal(extra, 4);
1992
1993     NDRX_FREE(ret);
1994 }
1995
1996 /**
1997  * Very basic tests of the framework
1998  * @return
1999  */
2000 TestSuite *vacc_CBvget_tests(void) {
2001     TestSuite *suite = create_test_suite();
2002
2003     set_setup(suite, basic_setup);
2004     set_teardown(suite, basic_teardown);
2005
2006     /* init view test */
2007     add_test(suite, test_Bvget_short);
2008     add_test(suite, test_Bvget_long);
2009     add_test(suite, test_Bvget_char);
2010     add_test(suite, test_Bvget_float);
2011     add_test(suite, test_Bvget_double);
2012     add_test(suite, test_Bvget_string);
2013     add_test(suite, test_Bvget_carray);
2014     add_test(suite, test_Bvget_int);
2015     add_test(suite, test_CBvgetalloc);
2016
2017     return suite;
2018 }
2019 /* vim: set ts=4 sw=4 et smartindent: */