atmitest/test040_typedview/vaccset.c

0001 /**
0002  * @brief View access unit tests - set field value
0003  *
0004  * @file vaccset.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 /**
0049  * Basic preparation before the test
0050  */
0051 exprivate void basic_setup(void)
0052 {
0053
0054 }
0055
0056 exprivate void basic_teardown(void)
0057 {
0058
0059 }
0060
0061 /**
0062  * Test Bvchg as short
0063  */
0064 Ensure(test_Bvchg_short)
0065 {
0066     struct MYVIEW1 v;
0067     short s;
0068     BFLDOCC maxocc;
0069     BFLDOCC realocc;
0070     long dim_size;
0071
0072     memset(&v, 0, sizeof(v));
0073
0074     s = 15556;
0075     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&s, 0L, BFLD_SHORT),
0076             EXSUCCEED);
0077     assert_equal(s, v.tshort1);
0078
0079     /* Invalid value, index out of bounds.. */
0080     s = 0;
0081     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&s, 0L, BFLD_SHORT),
0082             EXFAIL);
0083     assert_equal(Berror, BEINVAL);
0084
0085     s = 9999;
0086     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&s, 0L, BFLD_SHORT),
0087             EXSUCCEED);
0088     assert_equal(v.tshort2[0], 9999);
0089
0090     s = 8888;
0091     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&s, 0L, BFLD_SHORT),
0092             EXSUCCEED);
0093     assert_equal(v.tshort2[1], 8888);
0094
0095     /* occs 0 */
0096     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 0);
0097     assert_equal(maxocc, 3);
0098     assert_equal(realocc, 0);
0099
0100     s = 7777;
0101     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&s, 0L, BFLD_SHORT),
0102             EXSUCCEED);
0103     assert_equal(v.tshort3[0], 7777);
0104
0105     /* TEST: Occurrences 1 */
0106     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 1);
0107     assert_equal(maxocc, 3);
0108     assert_equal(realocc, 1);
0109
0110     s = -7777;
0111     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&s, 0L, BFLD_SHORT),
0112             EXSUCCEED);
0113     assert_equal(v.tshort3[1], -7777);
0114
0115
0116     /* TEST: Occurrences 2 */
0117     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 2);
0118     assert_equal(maxocc, 3);
0119     assert_equal(realocc, 2);
0120
0121
0122     s = -7777;
0123     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&s, 0L, BFLD_SHORT),
0124             EXSUCCEED);
0125     assert_equal(v.tshort3[2], -7777);
0126
0127     /* TEST: Occurrences 2 */
0128     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 3);
0129     assert_equal(maxocc, 3);
0130     assert_equal(realocc, 3);
0131
0132     assert_equal(v.C_tshort3, 3);
0133
0134     /* test first two empty occs... */
0135
0136     s = 0;
0137     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&s, 0L, BFLD_SHORT),
0138             EXSUCCEED);
0139     assert_equal(v.tshort3[0], 0);
0140
0141     s = 0;
0142     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&s, 0L, BFLD_SHORT),
0143             EXSUCCEED);
0144     assert_equal(v.tshort3[1], 0);
0145
0146     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 3);
0147     assert_equal(maxocc, 3);
0148     assert_equal(realocc, 3);
0149
0150     s = 0;
0151     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&s, 0L, BFLD_SHORT),
0152             EXSUCCEED);
0153     assert_equal(v.tshort3[2], 0);
0154
0155     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tshort3", &maxocc, &realocc, &dim_size, NULL), 3);
0156     assert_equal(maxocc, 3);
0157     assert_equal(realocc, 0);
0158
0159     s = -10;
0160     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort4", 0, (char *)&s, 0L, BFLD_SHORT),
0161             EXSUCCEED);
0162     assert_equal(v.tshort4, -10);
0163
0164
0165     s = 255;
0166     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&s, 0L, BFLD_SHORT),
0167             EXSUCCEED);
0168     assert_equal(v.tlong1, 255);
0169
0170     s = -100;
0171     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&s, 0L, BFLD_SHORT),
0172             EXSUCCEED);
0173     assert_equal(v.tint3, -100);
0174
0175     /* non existent field: */
0176     s = 0;
0177     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, (char *)&s, 0L, BFLD_SHORT),
0178             EXFAIL);
0179     assert_equal(Berror, BNOCNAME);
0180
0181     /* Test field NULL */
0182     s = -1;
0183     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&s, 0L, BFLD_SHORT),
0184             EXSUCCEED);
0185     assert_equal(v.tint4[0], -1);
0186
0187     s = -1;
0188     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&s, 0L, BFLD_SHORT),
0189             EXSUCCEED);
0190     assert_equal(v.tint4[1], -1);
0191
0192     assert_equal(Bvoccur((char *)&v, "MYVIEW1", "tint4", &maxocc, &realocc, &dim_size, NULL), 2);
0193     assert_equal(maxocc, 2);
0194     assert_equal(realocc, 0);
0195
0196     /* Test the ascii value to char */
0197     s = 65;
0198     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&s, 0L,
0199             BFLD_SHORT),
0200             EXSUCCEED);
0201     assert_equal(v.tchar1, 65);
0202
0203     s = 'D';
0204     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar3", 1, (char *)&s, 0L,
0205             BFLD_SHORT),
0206             EXSUCCEED);
0207     assert_equal(v.tchar3[1], 'D');
0208
0209
0210     s = 66;
0211     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&s, 0L,
0212             BFLD_SHORT),
0213             EXSUCCEED);
0214     assert_double_equal(v.tfloat1[1], 66);
0215
0216
0217     s = -999;
0218     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble2", 0, (char *)&s, 0L,
0219             BFLD_SHORT),
0220             EXSUCCEED);
0221     assert_double_equal(v.tdouble2,-999);
0222
0223
0224     s = 125;
0225     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&s, 0L,
0226             BFLD_SHORT),
0227             EXSUCCEED);
0228     assert_string_equal(v.tstring0[0], "125");
0229
0230
0231     s = 6500;
0232     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring2", 1, (char *)&s, 0L,
0233             BFLD_SHORT),
0234             EXSUCCEED);
0235     assert_string_equal(v.tstring2[1], "6500");
0236     assert_equal(v.L_tstring2[1], 5); /* bytes copied... */
0237
0238     s=521;
0239     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&s, 0L,
0240             BFLD_SHORT),
0241             EXSUCCEED);
0242     v.tcarray2[3] = EXEOS;
0243     assert_string_equal(v.tcarray2, "521");
0244     assert_equal(v.L_tcarray2, 3); /* bytes copied */
0245
0246 }
0247
0248 /**
0249  * Test Bvchg as long
0250  */
0251 Ensure(test_Bvchg_long)
0252 {
0253     struct MYVIEW1 v;
0254     long l;
0255
0256     memset(&v, 0, sizeof(v));
0257
0258     l = 15556;
0259     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&l, 0L, BFLD_LONG),
0260             EXSUCCEED);
0261     assert_equal(v.tshort1, 15556);
0262
0263     /* Invalid value, index out of bounds.. */
0264     l = 0;
0265     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&l, 0L, BFLD_LONG),
0266             EXFAIL);
0267     assert_equal(Berror, BEINVAL);
0268
0269     l = 9999;
0270     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&l, 0L, BFLD_LONG),
0271             EXSUCCEED);
0272     assert_equal(v.tshort2[0], 9999);
0273
0274     l = 8888;
0275     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&l, 0L, BFLD_LONG),
0276             EXSUCCEED);
0277     assert_equal(v.tshort2[1], 8888);
0278
0279     l = 7777;
0280     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&l, 0L, BFLD_LONG),
0281             EXSUCCEED);
0282     assert_equal(v.tshort3[0], 7777);
0283
0284
0285     l = 33333333;
0286     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&l, 0L, BFLD_LONG),
0287             EXSUCCEED);
0288     assert_equal(v.tlong1, 33333333);
0289
0290     l = -100;
0291     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&l, 0L, BFLD_LONG),
0292             EXSUCCEED);
0293     l = 1010101;
0294     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&l, 0L, BFLD_LONG),
0295             EXSUCCEED);
0296     assert_equal(v.tint3, -100);
0297     assert_equal(v.tint4[0], 1010101);
0298
0299     l = 989898;
0300     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&l, 0L, BFLD_LONG),
0301             EXSUCCEED);
0302     assert_equal(v.tint4[1], 989898);
0303
0304     /* non existent field: */
0305     l = 0;
0306     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, (char *)&l, 0L, BFLD_LONG),
0307             EXFAIL);
0308     assert_equal(Berror, BNOCNAME);
0309
0310
0311     /* Test the ascii value to char */
0312     l = 65;
0313
0314     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&l, 0L,
0315             BFLD_LONG),
0316             EXSUCCEED);
0317     assert_equal(v.tchar1, 65);
0318
0319     l = 67;
0320     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&l, 0L,
0321             BFLD_LONG),
0322             EXSUCCEED);
0323     l = 66;
0324     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&l, 0L,
0325             BFLD_LONG),
0326             EXSUCCEED);
0327
0328     assert_equal(v.tchar2[2], 67);
0329     assert_equal(v.tchar2[1], 66);
0330
0331
0332     l = 66;
0333     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&l, 0L,
0334             BFLD_LONG),
0335             EXSUCCEED);
0336     assert_double_equal(v.tfloat1[1], 66);
0337
0338     l = 65;
0339     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&l, 0L,
0340             BFLD_LONG),
0341             EXSUCCEED);
0342     assert_double_equal(v.tfloat1[1], 65);
0343
0344
0345     l = 11111;
0346     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&l, 0L,
0347             BFLD_LONG),
0348             EXSUCCEED);
0349     assert_double_equal(v.tdouble1[1],11111);
0350
0351
0352     l = 125;
0353     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 1, (char *)&l, 0L,
0354             BFLD_LONG),
0355             EXSUCCEED);
0356     assert_string_equal(v.tstring0[1], "125");
0357
0358
0359     l = 521;
0360     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&l, 0L,
0361             BFLD_LONG),
0362             EXSUCCEED);
0363
0364     v.tcarray2[3] = EXEOS;
0365     assert_string_equal(v.tcarray2, "521");
0366
0367
0368     l = 123456;
0369     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray4", 0, (char *)&l, 0L,
0370             BFLD_LONG),
0371             EXFAIL);
0372
0373     assert_equal(Berror, BNOSPACE);
0374
0375
0376 }
0377
0378 /**
0379  * Test Bvchg as char
0380  */
0381 Ensure(test_Bvchg_char)
0382 {
0383     struct MYVIEW1 v;
0384     init_MYVIEW1(&v);
0385     char c;
0386     short s;
0387     long l;
0388
0389     c = 65;
0390     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&c, 0L, BFLD_CHAR),
0391             EXSUCCEED);
0392     assert_equal(v.tshort1, 'A');
0393
0394     /* Invalid value, index out of bounds.. */
0395     c = 0;
0396     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&c, 0L, BFLD_CHAR),
0397             EXFAIL);
0398     assert_equal(Berror, BEINVAL);
0399
0400
0401     c = 'a';
0402     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&c, 0L, BFLD_CHAR),
0403             EXSUCCEED);
0404     assert_equal(v.tshort2[0], 'a');
0405
0406     c = 'b';
0407     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&c, 0L, BFLD_CHAR),
0408             EXSUCCEED);
0409     assert_equal(v.tlong1, 'b');
0410
0411
0412     c = 90;
0413     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&c, 0L, BFLD_CHAR),
0414             EXSUCCEED);
0415     assert_equal(v.tint3, 'Z');
0416
0417
0418     c = 89;
0419     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&c, 0L, BFLD_CHAR),
0420             EXSUCCEED);
0421     assert_equal(v.tint4[1], 'Y');
0422
0423     /* non existent field: */
0424     c = 0;
0425     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, (char *)&c, 0L, BFLD_CHAR),
0426             EXFAIL);
0427     assert_equal(Berror, BNOCNAME);
0428
0429
0430     c = 'i';
0431     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&c, 0L, BFLD_CHAR),
0432             EXSUCCEED);
0433     assert_equal(v.tint4[1], 'i');
0434
0435     c = 'h';
0436     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&c, 0L, BFLD_CHAR),
0437             EXSUCCEED);
0438     assert_equal(v.tint4[0], 'h');
0439
0440     /* Test the ascii value to char */
0441     c =  65;
0442     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&c, 0L,
0443             BFLD_CHAR),
0444             EXSUCCEED);
0445     assert_equal(v.tchar1, 65);
0446
0447
0448     c = 66;
0449     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&c, 0L,
0450             BFLD_CHAR),
0451             EXSUCCEED);
0452     assert_equal(v.tfloat1[1], 66);
0453
0454     c = 'D';
0455     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&c, 0L,
0456             BFLD_CHAR),
0457             EXSUCCEED);
0458     assert_equal(v.tdouble1[1],'D');
0459
0460
0461     c = 'X';
0462     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&c, 0L,
0463             BFLD_CHAR),
0464             EXSUCCEED);
0465
0466     assert_string_equal(v.tstring0[0],"X");
0467
0468     c = 'Y';
0469     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring2", 2, (char *)&c, 0L,
0470             BFLD_CHAR),
0471             EXSUCCEED);
0472
0473     assert_string_equal(v.tstring2[2],"Y");
0474     assert_equal(v.L_tstring2[2], 2); /* two bytes copied. */
0475
0476     /* Does not use EOS, just take first symbol.. */
0477     c='M';
0478     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&c, 0L,
0479             BFLD_CHAR),
0480             EXSUCCEED);
0481     assert_equal(v.tcarray2[0], 'M');
0482     assert_equal(v.L_tcarray2, 1);
0483
0484 }
0485
0486 /**
0487  * Test Bvchg as float
0488  */
0489 Ensure(test_Bvchg_float)
0490 {
0491     struct MYVIEW1 v;
0492     init_MYVIEW1(&v);
0493     float f;
0494
0495     f = 1555;
0496     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&f, 0L, BFLD_FLOAT),
0497             EXSUCCEED);
0498     assert_equal(v.tshort1, 1555);
0499
0500     /* Invalid value, index out of bounds.. */
0501     f = 0;
0502     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&f, 0L, BFLD_FLOAT),
0503             EXFAIL);
0504     assert_double_equal(Berror, BEINVAL);
0505
0506
0507     f = -8888;
0508     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&f, 0L, BFLD_FLOAT),
0509             EXSUCCEED);
0510     f = -7777;
0511     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&f, 0L, BFLD_FLOAT),
0512             EXSUCCEED);
0513
0514     assert_equal(v.tshort3[2], -8888);
0515     assert_equal(v.tshort3[1], -7777);
0516
0517     f = 333333;
0518     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&f, 0L, BFLD_FLOAT),
0519             EXSUCCEED);
0520     assert_equal(v.tlong1, 333333);
0521
0522     f = -100;
0523     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&f, 0L, BFLD_FLOAT),
0524             EXSUCCEED);
0525     assert_equal(v.tint3, -100);
0526
0527     f = 1010101;
0528     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&f, 0L, BFLD_FLOAT),
0529             EXSUCCEED);
0530     assert_equal(v.tint4[0], 1010101);
0531
0532     f = 989898;
0533     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&f, 0L, BFLD_FLOAT),
0534             EXSUCCEED);
0535     assert_equal(v.tint4[1], 989898);
0536
0537
0538     /* Test the ascii value to char */
0539     f = 65;
0540     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&f, 0L,
0541             BFLD_FLOAT),
0542             EXSUCCEED);
0543     assert_equal(v.tchar1, 65);
0544
0545
0546     f = 66;
0547     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&f, 0L,
0548             BFLD_FLOAT),
0549             EXSUCCEED);
0550     assert_double_equal(v.tfloat1[1], 66);
0551
0552
0553     f = 11.44;
0554     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&f, 0L,
0555             BFLD_FLOAT),
0556             EXSUCCEED);
0557     assert_double_equal(v.tdouble1[1],11.44);
0558
0559
0560     f = 55;
0561     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&f, 0L,
0562             BFLD_FLOAT),
0563             EXSUCCEED);
0564     assert_string_equal(v.tstring0[0],"55.00000");
0565
0566     f=44;
0567     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray3", 3, (char *)&f, 0L,
0568             BFLD_FLOAT),
0569             EXSUCCEED);
0570     v.tcarray3[3][8] = EXEOS;
0571     assert_string_equal(v.tcarray3[3], "44.00000");
0572
0573 }
0574
0575 /**
0576  * Test Bvchg as float
0577  */
0578 Ensure(test_Bvchg_double)
0579 {
0580     struct MYVIEW1 v;
0581     init_MYVIEW1(&v);
0582     double d;
0583
0584     d = 1555;
0585     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&d, 0L, BFLD_DOUBLE),
0586             EXSUCCEED);
0587     assert_equal(v.tshort1, 1555);
0588
0589     /* Invalid value, index out of bounds.. */
0590     d = 0;
0591     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&d, 0L, BFLD_DOUBLE),
0592             EXFAIL);
0593     assert_double_equal(Berror, BEINVAL);
0594
0595
0596     d = -8888;
0597     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 2, (char *)&d, 0L, BFLD_DOUBLE),
0598             EXSUCCEED);
0599     d = -7777;
0600     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 1, (char *)&d, 0L, BFLD_DOUBLE),
0601             EXSUCCEED);
0602
0603     assert_equal(v.tshort3[2], -8888);
0604     assert_equal(v.tshort3[1], -7777);
0605
0606     d = 333333;
0607     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&d, 0L, BFLD_DOUBLE),
0608             EXSUCCEED);
0609     assert_equal(v.tlong1, 333333);
0610
0611     d = -100;
0612     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&d, 0L, BFLD_DOUBLE),
0613             EXSUCCEED);
0614     assert_equal(v.tint3, -100);
0615
0616     d = 1010101;
0617     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&d, 0L, BFLD_DOUBLE),
0618             EXSUCCEED);
0619     assert_equal(v.tint4[0], 1010101);
0620
0621     d = 989898;
0622     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&d, 0L, BFLD_DOUBLE),
0623             EXSUCCEED);
0624     assert_equal(v.tint4[1], 989898);
0625
0626
0627     /* Test the ascii value to char */
0628     d = 65;
0629     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&d, 0L,
0630             BFLD_DOUBLE),
0631             EXSUCCEED);
0632     assert_equal(v.tchar1, 65);
0633
0634
0635     d = 66;
0636     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&d, 0L,
0637             BFLD_DOUBLE),
0638             EXSUCCEED);
0639     assert_double_equal(v.tfloat1[1], 66);
0640
0641
0642     d = 11.44;
0643     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&d, 0L,
0644             BFLD_DOUBLE),
0645             EXSUCCEED);
0646     assert_double_equal(v.tdouble1[1],11.44);
0647
0648
0649     d = 55;
0650     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 0, (char *)&d, 0L,
0651             BFLD_DOUBLE),
0652             EXSUCCEED);
0653     assert_string_equal(v.tstring0[0],"55.000000");
0654
0655     d=44;
0656     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray3", 3, (char *)&d, 0L,
0657             BFLD_DOUBLE),
0658             EXSUCCEED);
0659     v.tcarray3[3][9] = EXEOS;
0660     assert_string_equal(v.tcarray3[3], "44.000000");
0661
0662 }
0663
0664 /**
0665  * Test Bvchg as string
0666  */
0667 Ensure(test_Bvchg_string)
0668 {
0669     struct MYVIEW1 v;
0670     init_MYVIEW1(&v);
0671
0672     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, "32000", 0L, BFLD_STRING),
0673             EXSUCCEED);
0674     assert_equal(v.tshort1, 32000);
0675
0676     /* Invalid value, index out of bounds.. */
0677     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, "66", 0L, BFLD_STRING),
0678             EXFAIL);
0679     assert_equal(Berror, BEINVAL);
0680
0681
0682     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 1, "-32000", 0L, BFLD_STRING),
0683             EXSUCCEED);
0684     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, "55", 0L, BFLD_STRING),
0685             EXSUCCEED);
0686
0687     assert_equal(v.tshort2[1],-32000);
0688     assert_equal(v.tshort3[0], 55);
0689
0690
0691     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, "33333333", 0L, BFLD_STRING),
0692             EXSUCCEED);
0693     assert_equal(v.tlong1, 33333333);
0694
0695     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, "-100", 0L, BFLD_STRING),
0696             EXSUCCEED);
0697     assert_equal(v.tint3, -100);
0698
0699     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, "1010101", 0L, BFLD_STRING),
0700             EXSUCCEED);
0701     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, "989898", 0L, BFLD_STRING),
0702             EXSUCCEED);
0703
0704     assert_equal(v.tint4[0], 1010101);
0705     assert_equal(v.tint4[1], 989898);
0706
0707     /* non existent field: */
0708     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, "", 0L, BFLD_STRING),
0709             EXFAIL);
0710     assert_equal(Berror, BNOCNAME);
0711
0712     /* Test field NULL */
0713
0714     /* Test the ascii value to char */
0715
0716     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0717
0718     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, "A", 0L,
0719             BFLD_STRING),
0720             EXSUCCEED);
0721     assert_equal(v.tchar1, 'A');
0722
0723     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 4, "\t", 0L,
0724             BFLD_STRING),
0725             EXSUCCEED);
0726     assert_equal(v.tchar2[4], '\t');
0727
0728     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, "66.5", 0L,
0729             BFLD_STRING),
0730             EXSUCCEED);
0731     assert_double_equal(v.tfloat1[1], 66.5);
0732
0733     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, "11.440000", 0L,
0734             BFLD_STRING),
0735             EXSUCCEED);
0736     assert_double_equal(v.tdouble1[1], 11.44);
0737
0738
0739     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 1, "HELLO WOLRD", 0L,
0740             BFLD_STRING),
0741             EXSUCCEED);
0742     assert_string_equal(v.tstring0[1], "HELLO WOLRD");
0743
0744
0745     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring3", 1,
0746             "HELLO WOLRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD", 0L,
0747             BFLD_STRING),
0748             EXFAIL);
0749
0750     assert_equal(Berror, BNOSPACE);
0751
0752     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray3", 3, "HELLO1", 6,
0753             BFLD_STRING),
0754             EXSUCCEED);
0755
0756     v.tcarray3[3][6] = EXEOS;
0757     assert_string_equal(v.tcarray3[3], "HELLO1");
0758     assert_equal(v.L_tcarray3[3], 6);
0759
0760 }
0761
0762 /**
0763  * Test Bvchg as carray
0764  */
0765 Ensure(test_Bvchg_carray)
0766 {
0767     struct MYVIEW1 v;
0768     init_MYVIEW1(&v);
0769
0770     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, "32000", 5, BFLD_CARRAY),
0771             EXSUCCEED);
0772     assert_equal(v.tshort1, 32000);
0773
0774     /* Invalid value, index out of bounds.. */
0775     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, "66", 2, BFLD_STRING),
0776             EXFAIL);
0777     assert_equal(Berror, BEINVAL);
0778
0779
0780     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 1, "-32000", 6, BFLD_STRING),
0781             EXSUCCEED);
0782     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, "55", 2, BFLD_STRING),
0783             EXSUCCEED);
0784
0785     assert_equal(v.tshort2[1],-32000);
0786     assert_equal(v.tshort3[0], 55);
0787
0788
0789     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, "33333333", 8, BFLD_STRING),
0790             EXSUCCEED);
0791     assert_equal(v.tlong1, 33333333);
0792
0793     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, "-100", 4, BFLD_STRING),
0794             EXSUCCEED);
0795     assert_equal(v.tint3, -100);
0796
0797     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, "1010101", 7, BFLD_STRING),
0798             EXSUCCEED);
0799     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, "989898", 6, BFLD_STRING),
0800             EXSUCCEED);
0801
0802     assert_equal(v.tint4[0], 1010101);
0803     assert_equal(v.tint4[1], 989898);
0804
0805     /* non existent field: */
0806     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, "", 0L, BFLD_STRING),
0807             EXFAIL);
0808     assert_equal(Berror, BNOCNAME);
0809
0810     /* Test field NULL */
0811
0812     /* Test the ascii value to char */
0813
0814     NDRX_LOG(log_debug, "tchar1=%c", v.tchar1);
0815
0816     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, "A", 1,
0817             BFLD_STRING),
0818             EXSUCCEED);
0819     assert_equal(v.tchar1, 'A');
0820
0821     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 4, "\t", 1,
0822             BFLD_STRING),
0823             EXSUCCEED);
0824     assert_equal(v.tchar2[4], '\t');
0825
0826     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, "66.5", 4,
0827             BFLD_STRING),
0828             EXSUCCEED);
0829     assert_double_equal(v.tfloat1[1], 66.5);
0830
0831     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, "11.440000", 9,
0832             BFLD_STRING),
0833             EXSUCCEED);
0834     assert_double_equal(v.tdouble1[1], 11.44);
0835
0836
0837     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 1, "HELLO WOLRD", 11,
0838             BFLD_STRING),
0839             EXSUCCEED);
0840     assert_string_equal(v.tstring0[1], "HELLO WOLRD");
0841
0842
0843     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring3", 3,
0844             "HELLO WOLRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD", 75,
0845             BFLD_STRING),
0846             EXFAIL);
0847
0848     assert_equal(Berror, BNOSPACE);
0849
0850     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray3", 3, "HELLO1", 6,
0851             BFLD_STRING),
0852             EXSUCCEED);
0853
0854     v.tcarray3[3][6] = EXEOS;
0855     assert_string_equal(v.tcarray3[3], "HELLO1");
0856     assert_equal(v.L_tcarray3[3], 6);
0857
0858 }
0859
0860
0861 /**
0862  * Test Bvchg as int
0863  */
0864 Ensure(test_Bvchg_int)
0865 {
0866     struct MYVIEW1 v;
0867     int i;
0868
0869     memset(&v, 0, sizeof(v));
0870
0871     i = 15556;
0872     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 0, (char *)&i, 0L, BFLD_INT),
0873             EXSUCCEED);
0874     assert_equal(v.tshort1, 15556);
0875
0876     /* Invalid value, index out of bounds.. */
0877     i = 0;
0878     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort1", 1, (char *)&i, 0L, BFLD_INT),
0879             EXFAIL);
0880     assert_equal(Berror, BEINVAL);
0881
0882     i = 9999;
0883     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 0, (char *)&i, 0L, BFLD_INT),
0884             EXSUCCEED);
0885     assert_equal(v.tshort2[0], 9999);
0886
0887     i = 8888;
0888     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort2", 1, (char *)&i, 0L, BFLD_INT),
0889             EXSUCCEED);
0890     assert_equal(v.tshort2[1], 8888);
0891
0892     i = 7777;
0893     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tshort3", 0, (char *)&i, 0L, BFLD_INT),
0894             EXSUCCEED);
0895     assert_equal(v.tshort3[0], 7777);
0896
0897
0898     i = 33333333;
0899     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tlong1", 0, (char *)&i, 0L, BFLD_INT),
0900             EXSUCCEED);
0901     assert_equal(v.tlong1, 33333333);
0902
0903     i = -100;
0904     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint3", 0, (char *)&i, 0L, BFLD_INT),
0905             EXSUCCEED);
0906     i = 1010101;
0907     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 0, (char *)&i, 0L, BFLD_INT),
0908             EXSUCCEED);
0909     assert_equal(v.tint3, -100);
0910     assert_equal(v.tint4[0], 1010101);
0911
0912     i = 989898;
0913     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tint4", 1, (char *)&i, 0L, BFLD_INT),
0914             EXSUCCEED);
0915     assert_equal(v.tint4[1], 989898);
0916
0917     /* non existent field: */
0918     i = 0;
0919     assert_equal(CBvchg((char *)&v, "MYVIEW1", "xint3", 0, (char *)&i, 0L, BFLD_INT),
0920             EXFAIL);
0921     assert_equal(Berror, BNOCNAME);
0922
0923
0924     /* Test the ascii value to char */
0925     i = 65;
0926
0927     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar1", 0, (char *)&i, 0L,
0928             BFLD_INT),
0929             EXSUCCEED);
0930     assert_equal(v.tchar1, 65);
0931
0932     i = 67;
0933     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 2, (char *)&i, 0L,
0934             BFLD_INT),
0935             EXSUCCEED);
0936     i = 66;
0937     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tchar2", 1, (char *)&i, 0L,
0938             BFLD_INT),
0939             EXSUCCEED);
0940
0941     assert_equal(v.tchar2[2], 67);
0942     assert_equal(v.tchar2[1], 66);
0943
0944
0945     i = 66;
0946     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&i, 0L,
0947             BFLD_INT),
0948             EXSUCCEED);
0949     assert_double_equal(v.tfloat1[1], 66);
0950
0951     i = 65;
0952     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tfloat1", 1, (char *)&i, 0L,
0953             BFLD_INT),
0954             EXSUCCEED);
0955     assert_double_equal(v.tfloat1[1], 65);
0956
0957
0958     i = 11111;
0959     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tdouble1", 1, (char *)&i, 0L,
0960             BFLD_INT),
0961             EXSUCCEED);
0962     assert_double_equal(v.tdouble1[1],11111);
0963
0964
0965     i = 125;
0966     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tstring0", 1, (char *)&i, 0L,
0967             BFLD_INT),
0968             EXSUCCEED);
0969     assert_string_equal(v.tstring0[1], "125");
0970
0971
0972     i = 521;
0973     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray2", 0, (char *)&i, 0L,
0974             BFLD_INT),
0975             EXSUCCEED);
0976
0977     v.tcarray2[3] = EXEOS;
0978     assert_string_equal(v.tcarray2, "521");
0979
0980
0981     i = 123456;
0982     assert_equal(CBvchg((char *)&v, "MYVIEW1", "tcarray4", 0, (char *)&i, 0L,
0983             BFLD_INT),
0984             EXFAIL);
0985
0986     assert_equal(Berror, BNOSPACE);
0987
0988
0989 }
0990
0991
0992 /**
0993  * Very basic tests of the framework
0994  * @return
0995  */
0996 TestSuite *vacc_CBvchg_tests(void) {
0997     TestSuite *suite = create_test_suite();
0998
0999     set_setup(suite, basic_setup);
1000     set_teardown(suite, basic_teardown);
1001
1002     /* init view test */
1003     add_test(suite, test_Bvchg_short);
1004     add_test(suite, test_Bvchg_long);
1005     add_test(suite, test_Bvchg_char);
1006     add_test(suite, test_Bvchg_float);
1007     add_test(suite, test_Bvchg_double);
1008     add_test(suite, test_Bvchg_string);
1009     add_test(suite, test_Bvchg_carray);
1010     add_test(suite, test_Bvchg_int);
1011
1012     return suite;
1013 }
1014 /* vim: set ts=4 sw=4 et smartindent: */