source/ubftest/test_cbget.c

0001 /**
0002  *
0003  * @file test_cbget.c
0004  */
0005 /* -----------------------------------------------------------------------------
0006  * Enduro/X Middleware Platform for Distributed Transaction Processing
0007  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0008  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0009  * This software is released under one of the following licenses:
0010  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0011  * See LICENSE file for full text.
0012  * -----------------------------------------------------------------------------
0013  * AGPL license:
0014  *
0015  * This program is free software; you can redistribute it and/or modify it under
0016  * the terms of the GNU Affero General Public License, version 3 as published
0017  * by the Free Software Foundation;
0018  *
0019  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0020  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0021  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0022  * for more details.
0023  *
0024  * You should have received a copy of the GNU Affero General Public License along
0025  * with this program; if not, write to the Free Software Foundation, Inc.,
0026  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0027  *
0028  * -----------------------------------------------------------------------------
0029  * A commercial use license is available from Mavimax, Ltd
0030  * contact@mavimax.com
0031  * -----------------------------------------------------------------------------
0032  */
0033
0034 #include <stdio.h>
0035 #include <stdlib.h>
0036 #include <cgreen/cgreen.h>
0037 #include <ubf.h>
0038 #include <ndrstandard.h>
0039 #include <string.h>
0040 #include "test.fd.h"
0041 #include "ubfunit1.h"
0042
0043
0044
0045
0046 /**
0047  * Original field is BFLD_SHORT => T_SHORT_FLD
0048  */
0049 Ensure(test_CBget_short_org)
0050 {
0051     char buf[640];
0052     UBFH *p_ub = (UBFH *)buf;
0053     short test_val=4564;
0054     int len = 0;
0055     short small_val=44;
0056     /* test buffers */
0057     short test_short = 0;
0058     long test_long = 0;
0059     char test_char = 0;
0060     float test_float = 0.0;
0061     double test_double = 0.0;
0062     char test_string[128];
0063     char test_carray[128];
0064     char tmp[1024];
0065     char *ptr;
0066     BVIEWFLD v;
0067     UBFH *p_tmp_ub = (UBFH *)tmp;
0068
0069     /* init */
0070     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0071     len = sizeof(test_val);
0072     assert_equal(Badd(p_ub, T_SHORT_FLD, (char *)&test_val, len), EXSUCCEED);
0073
0074     /* Now test all types */
0075     /* short out */
0076     len=sizeof(test_short);
0077     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0078     assert_equal(test_short, 4564);
0079     assert_equal(len, sizeof(test_short));
0080     /* long out */
0081     len=sizeof(test_long);
0082     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0083     assert_equal(test_long, 4564);
0084     assert_equal(len, sizeof(test_long));
0085     /* char out */
0086     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&small_val, 0), EXSUCCEED);
0087     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&test_char, 0, BFLD_CHAR), EXSUCCEED);
0088     assert_equal(test_char, ',');
0089     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED); /* restore back */
0090     /* test float */
0091     len=sizeof(test_float);
0092     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0093     assert_equal(test_float, 4564);
0094     assert_equal(len, sizeof(test_float));
0095     /* test double */
0096     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&test_double, 0, BFLD_DOUBLE), EXSUCCEED);
0097     assert_equal(test_float, 4564);
0098     /* test string */
0099     len=sizeof(test_string);
0100     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0101     assert_string_equal(test_string, "4564");
0102     assert_equal(len, 5);
0103     /* test carray */
0104     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)test_carray, 0, BFLD_CARRAY), EXSUCCEED);
0105     assert_equal(strncmp(test_carray, "4564", 4), 0);
0106
0107     /* may be cast to PTR */
0108     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0109     assert_equal((long)ptr, 4564);
0110
0111     v.data = tmp;
0112     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0113     assert_equal(Berror, BEBADOP);
0114
0115     assert_equal(CBget(p_ub, T_SHORT_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0116     assert_equal(Berror, BEBADOP);
0117
0118 }
0119
0120 /**
0121  * Original field is BFLD_LONG => T_LONG_FLD
0122  */
0123 Ensure(test_CBget_long_org)
0124 {
0125     char buf[640];
0126     UBFH *p_ub = (UBFH *)buf;
0127     long test_val=456412;
0128     int len = 0;
0129     long small_val=44;
0130     /* test buffers */
0131     short test_short = 0;
0132     long test_long = 0;
0133     char test_char = 0;
0134     float test_float = 0.0;
0135     double test_double = 0.0;
0136     char test_string[128];
0137     char test_carray[128];
0138     char tmp[1024];
0139     char *ptr;
0140     BVIEWFLD v;
0141     UBFH *p_tmp_ub = (UBFH *)tmp;
0142
0143     /* init */
0144     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0145     len = sizeof(test_val);
0146     assert_equal(Badd(p_ub, T_LONG_FLD, (char *)&small_val, len), EXSUCCEED);
0147
0148     /* Now test all types */
0149     /* short out */
0150     len=sizeof(test_short);
0151     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0152     assert_equal(test_short, 44);
0153     assert_equal(len, sizeof(test_short));
0154     /* char out */
0155     len=sizeof(test_char);
0156     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0157     assert_equal(test_char, ',');
0158     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED); /* restore back */
0159     assert_equal(len, sizeof(test_char));
0160
0161     /* long out */
0162     len=sizeof(test_long);
0163     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0164     assert_equal(test_long, 456412);
0165     assert_equal(len, sizeof(test_long));
0166     /* test float */
0167     len=sizeof(test_float);
0168     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0169     assert_equal(test_float, 456412);
0170     assert_equal(len, sizeof(test_float));
0171     /* test double */
0172     len=sizeof(test_double);
0173     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0174     assert_equal(test_float, 456412);
0175     assert_equal(len, sizeof(test_double));
0176     /* test string */
0177     len=sizeof(test_string);
0178     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0179     assert_string_equal(test_string, "456412");
0180     assert_equal(len, 7);
0181     /* test carray */
0182     len=sizeof(test_string);
0183     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0184     assert_equal(strncmp(test_carray, "456412", 6), 0);
0185     assert_equal(len, 6);
0186
0187     /* may be cast to PTR */
0188     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0189     assert_equal((long)ptr, 456412);
0190
0191     v.data = tmp;
0192     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0193     assert_equal(Berror, BEBADOP);
0194
0195     assert_equal(CBget(p_ub, T_LONG_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0196     assert_equal(Berror, BEBADOP);
0197
0198 }
0199
0200 /**
0201  * Original field is BFLD_CHAR => T_CHAR_FLD
0202  */
0203 Ensure(test_CBget_char_org)
0204 {
0205     char buf[640];
0206     UBFH *p_ub = (UBFH *)buf;
0207     long test_val=456412;
0208     int len = 0;
0209     long small_val=0;
0210     /* test buffers */
0211     short test_short = 0;
0212     long test_long = 0;
0213     char test_char = 'r';
0214     float test_float = 0.0;
0215     double test_double = 0.0;
0216     char test_string[128];
0217     char test_carray[128];
0218     char tmp[1024];
0219     char *ptr;
0220     BVIEWFLD v;
0221     UBFH *p_tmp_ub = (UBFH *)tmp;
0222
0223     /* init */
0224     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0225     len = sizeof(test_val);
0226     assert_equal(Badd(p_ub, T_CHAR_FLD, (char *)&test_char, len), EXSUCCEED);
0227
0228     /* Now test all types */
0229     /* short out */
0230     len=sizeof(test_short);
0231     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0232     assert_equal(test_short, 114);
0233     assert_equal(len, sizeof(test_short));
0234
0235     /* long out */
0236     len=sizeof(test_long);
0237     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0238     assert_equal(test_long, 114);
0239     assert_equal(len, sizeof(test_long));
0240
0241     /* char out */
0242     len=sizeof(test_char);
0243     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0244     assert_equal(test_char, 'r');
0245     assert_equal(len, sizeof(test_char));
0246
0247     /* test float */
0248     len=sizeof(test_float);
0249     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0250     assert_equal(test_float, 114);
0251     assert_equal(len, sizeof(test_float));
0252
0253     /* test double */
0254     len=sizeof(test_double);
0255     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0256     assert_equal(test_float, 114);
0257     assert_equal(len, sizeof(test_double));
0258
0259     /* test string */
0260     len=sizeof(test_string);
0261     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0262     assert_string_equal(test_string, "r");
0263     assert_equal(len, 2);
0264
0265     /* test carray */
0266     len=sizeof(test_string);
0267     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0268     assert_equal(strncmp(test_carray, "r", 1), 0);
0269     assert_equal(len, 1);
0270
0271
0272     /* may be cast to PTR */
0273     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0274     assert_equal((long)ptr, 114);
0275
0276     v.data = tmp;
0277     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0278     assert_equal(Berror, BEBADOP);
0279
0280     assert_equal(CBget(p_ub, T_CHAR_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0281     assert_equal(Berror, BEBADOP);
0282
0283 }
0284
0285 /**
0286  * Original field is BFLD_FLOAT => T_FLOAT_FLD
0287  */
0288 Ensure(test_CBget_float_org)
0289 {
0290     char buf[640];
0291     UBFH *p_ub = (UBFH *)buf;
0292     long test_val=0;
0293     int len = 0;
0294     /* test buffers */
0295     short test_short = 0;
0296     long test_long = 0;
0297     unsigned char test_char = 0;
0298     float test_float = 16822.5;
0299     double test_double = 0.0;
0300     char test_string[128];
0301     char test_carray[128];
0302
0303     char tmp[1024];
0304     char *ptr;
0305     BVIEWFLD v;
0306     UBFH *p_tmp_ub = (UBFH *)tmp;
0307
0308     /* init */
0309     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0310     len = sizeof(test_float);
0311     assert_equal(Badd(p_ub, T_FLOAT_FLD, (char *)&test_float, len), EXSUCCEED);
0312
0313     /* Now test all types */
0314     /* short out */
0315     len=sizeof(test_short);
0316     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0317     assert_equal(test_short, 16822);
0318     assert_equal(len, sizeof(test_short));
0319
0320     /* long out */
0321     len=sizeof(test_long);
0322     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0323     assert_equal(test_long, 16822);
0324     assert_equal(len, sizeof(test_long));
0325
0326     /* char out */
0327
0328     len = sizeof(test_float);
0329     test_float = 168.5;
0330     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&test_float, len), EXSUCCEED);
0331     len=sizeof(test_char);
0332     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0333     assert_equal(test_char, 168);
0334     assert_equal(len, sizeof(test_char));
0335
0336     /* test float */
0337     /* continue as normal */
0338     len = sizeof(test_float);
0339     test_float = 16822.5;
0340     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&test_float, len), EXSUCCEED);
0341
0342     len=sizeof(test_float);
0343     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0344     assert_equal(test_float, 16822.5);
0345     assert_equal(len, sizeof(test_float));
0346
0347     /* test double */
0348     len=sizeof(test_double);
0349     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0350     assert_equal(test_float, 16822.5);
0351     assert_equal(len, sizeof(test_double));
0352
0353     /* test string */
0354     len=sizeof(test_string);
0355     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0356     assert_string_equal(test_string, "16822.50000");
0357     assert_equal(len, 12);
0358
0359     /* test carray */
0360     len=sizeof(test_string);
0361     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0362     assert_equal(strncmp(test_carray, "16822.50000", 10), 0);
0363     assert_equal(len, 11);
0364
0365     /* may be cast to PTR */
0366     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0367     assert_equal((long)ptr, 16822);
0368
0369     v.data = tmp;
0370     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0371     assert_equal(Berror, BEBADOP);
0372
0373     assert_equal(CBget(p_ub, T_FLOAT_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0374     assert_equal(Berror, BEBADOP);
0375
0376 }
0377
0378 /**
0379  * Original field is BFLD_DOUBLE => T_DOUBLE_FLD
0380  */
0381 Ensure(test_CBget_double_org)
0382 {
0383     char buf[640];
0384     UBFH *p_ub = (UBFH *)buf;
0385     int len = 0;
0386     /* test buffers */
0387     short test_short = 0;
0388     long test_long = 0;
0389     unsigned char test_char = 0;
0390     float test_float = 0.0;
0391     double test_double = 16822.5;
0392     char test_string[128];
0393     char test_carray[128];
0394     char tmp[1024];
0395     char *ptr;
0396     BVIEWFLD v;
0397     UBFH *p_tmp_ub = (UBFH *)tmp;
0398
0399     /* init */
0400     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0401     len = sizeof(test_double);
0402     assert_equal(Badd(p_ub, T_DOUBLE_FLD, (char *)&test_double, len), EXSUCCEED);
0403
0404     /* Now test all types */
0405     /* short out */
0406     len=sizeof(test_short);
0407     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0408     assert_equal(test_short, 16822);
0409     assert_equal(len, sizeof(test_short));
0410
0411     /* long out */
0412     len=sizeof(test_long);
0413     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0414     assert_equal(test_long, 16822);
0415     assert_equal(len, sizeof(test_long));
0416
0417     /* char out */
0418     len = sizeof(test_double);
0419     test_double = 168.5;
0420     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&test_double, len), EXSUCCEED);
0421
0422     len=sizeof(test_char);
0423     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0424     assert_equal(test_char, 168);
0425     assert_equal(len, sizeof(test_char));
0426
0427     /* test float */
0428     /* continue as normal */
0429     test_double = 16822.5;
0430     len = sizeof(test_double);
0431     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&test_double, len), EXSUCCEED);
0432
0433     len=sizeof(test_float);
0434     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0435     assert_equal(test_float, 16822.5);
0436     assert_equal(len, sizeof(test_float));
0437
0438     /* test double */
0439     len=sizeof(test_double);
0440     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0441     assert_equal(test_float, 16822.5);
0442     assert_equal(len, sizeof(test_double));
0443
0444     /* test string */
0445     len=sizeof(test_string);
0446     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0447     assert_string_equal(test_string, "16822.500000");
0448     assert_equal(len, 13);
0449
0450     /* test carray */
0451     len=sizeof(test_string);
0452     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0453     assert_equal(strncmp(test_carray, "16822.500000", 10), 0);
0454     assert_equal(len, 12);
0455
0456     /* may be cast to PTR */
0457     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0458     assert_equal((long)ptr, 16822);
0459
0460     v.data = tmp;
0461     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0462     assert_equal(Berror, BEBADOP);
0463
0464     assert_equal(CBget(p_ub, T_DOUBLE_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0465     assert_equal(Berror, BEBADOP);
0466
0467 }
0468 /**
0469  * Original field is BFLD_STRING => T_STRING_FLD
0470  */
0471 Ensure(test_CBget_string_org)
0472 {
0473     char buf[2048];
0474     UBFH *p_ub = (UBFH *)buf;
0475     int len = 0;
0476     /* test buffers */
0477     short test_short = 0;
0478     long test_long = 0;
0479     unsigned char test_char = 0;
0480     float test_float = 0.0;
0481     double test_double = 16822.5;
0482     char test_string[1024];
0483     char test_carray[1024];
0484     char tmp[1024];
0485     char *ptr;
0486     BVIEWFLD v;
0487     UBFH *p_tmp_ub = (UBFH *)tmp;
0488
0489     /* init */
0490     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0491     /*  len 1 - should be ok, because it is ignored!*/
0492     assert_equal(Badd(p_ub, T_STRING_FLD, "16822.5000000000000", 1), EXSUCCEED);
0493
0494     /* Now test all types */
0495     /* short out */
0496     len=sizeof(test_short);
0497     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0498     assert_equal(test_short, 16822);
0499     assert_equal(len, sizeof(test_short));
0500
0501     /* long out */
0502     len=sizeof(test_long);
0503     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0504     assert_equal(test_long, 16822);
0505     assert_equal(len, sizeof(test_long));
0506
0507     /* char out */
0508     len=sizeof(test_char);
0509     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0510     assert_equal(test_char, '1');
0511     assert_equal(len, sizeof(test_char));
0512
0513     /* test float */
0514     len=sizeof(test_float);
0515     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0516     assert_equal(test_float, 16822.5);
0517     assert_equal(len, sizeof(test_float));
0518
0519     /* test double */
0520     len=sizeof(test_double);
0521     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0522     assert_equal(test_float, 16822.5);
0523     assert_equal(len, sizeof(test_double));
0524
0525     /* test string */
0526     len=sizeof(test_string);
0527     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0528     assert_string_equal(test_string, "16822.5000000000000");
0529     assert_equal(len, 20);
0530
0531     /* test carray */
0532     len=sizeof(test_string);
0533     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0534     assert_equal(strncmp(test_carray, "16822.5000000000000", 17), 0);
0535     assert_equal(len, 19);
0536
0537     /* Special test for hadling strings & carrays */
0538     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, BIG_TEST_STRING, 0), EXSUCCEED);
0539     len=sizeof(test_carray);
0540     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0541     assert_equal(strncmp(test_carray, BIG_TEST_STRING, strlen(BIG_TEST_STRING)), 0);
0542     assert_equal(len, strlen(BIG_TEST_STRING));
0543
0544
0545     /* may be cast to PTR -> this will try to parse 0xHEX ptr */
0546     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, "0xFFAABB", 0L), EXSUCCEED);
0547     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0548     assert_equal((long)ptr, 0xFFAABB);
0549
0550     v.data = tmp;
0551     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0552     assert_equal(Berror, BEBADOP);
0553
0554     assert_equal(CBget(p_ub, T_STRING_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0555     assert_equal(Berror, BEBADOP);
0556
0557 }
0558
0559 /**
0560  * Original field is BFLD_CARRAY => T_CARRAY_FLD
0561  */
0562 Ensure(test_CBget_carray_org)
0563 {
0564     char buf[2048];
0565     UBFH *p_ub = (UBFH *)buf;
0566     int len = 0;
0567     /* test buffers */
0568     short test_short = 0;
0569     long test_long = 0;
0570     unsigned char test_char = 0;
0571     float test_float = 0.0;
0572     double test_double = 16822.5;
0573     char test_string[1024];
0574     char test_carray[1024];
0575     char test_data_str [] = "16822.5000000000000";
0576
0577     char tmp[1024];
0578     char *ptr;
0579     BVIEWFLD v;
0580     UBFH *p_tmp_ub = (UBFH *)tmp;
0581
0582     /* init */
0583     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0584     len = strlen(test_data_str);
0585     assert_equal(Badd(p_ub, T_CARRAY_FLD, test_data_str, len), EXSUCCEED);
0586
0587     /* Now test all types */
0588     /* short out */
0589     len=sizeof(test_short);
0590     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0591     assert_equal(test_short, 16822);
0592     assert_equal(len, sizeof(test_short));
0593
0594     /* long out */
0595     len=sizeof(test_long);
0596     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0597     assert_equal(test_long, 16822);
0598     assert_equal(len, sizeof(test_long));
0599
0600     /* char out */
0601     len=sizeof(test_char);
0602     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0603     assert_equal(test_char, '1');
0604     assert_equal(len, sizeof(test_char));
0605
0606     /* test float */
0607     len=sizeof(test_float);
0608     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0609     assert_equal(test_float, 16822.5);
0610     assert_equal(len, sizeof(test_float));
0611
0612     /* test double */
0613     len=sizeof(test_double);
0614     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0615     assert_equal(test_float, 16822.5);
0616     assert_equal(len, sizeof(test_double));
0617
0618     /* test string */
0619     len=sizeof(test_string);
0620     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0621     assert_string_equal(test_string, test_data_str);
0622     assert_equal(len, 20);
0623
0624     /* test carray */
0625     len=sizeof(test_string);
0626     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0627     assert_equal(strncmp(test_carray, test_data_str, 17), 0);
0628     assert_equal(len, 19);
0629
0630     /* Special test for hadling strings & carrays */
0631     len = strlen(BIG_TEST_STRING);
0632     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, BIG_TEST_STRING, len), EXSUCCEED);
0633     len=sizeof(test_string);
0634     memset(test_string, 0xff, sizeof(test_string)); /* For checking EOS terminator */
0635     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0636     assert_equal(strncmp(test_string, BIG_TEST_STRING, strlen(BIG_TEST_STRING)), 0);
0637     assert_equal(len, strlen(BIG_TEST_STRING)+1);
0638     assert_equal(strlen(test_string), strlen(BIG_TEST_STRING));
0639
0640
0641     /* may be cast to PTR -> this will try to parse 0xHEX ptr */
0642     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, "0xFFAABB", 0L, BFLD_STRING), EXSUCCEED);
0643     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0644     assert_equal((long)ptr, 0xFFAABB);
0645
0646     v.data = tmp;
0647     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0648     assert_equal(Berror, BEBADOP);
0649
0650     assert_equal(CBget(p_ub, T_CARRAY_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0651     assert_equal(Berror, BEBADOP);
0652
0653 }
0654
0655 Ensure(test_CBget_view_org)
0656 {
0657     char buf[2048];
0658     UBFH *p_ub = (UBFH *)buf;
0659     char tmp[1024];
0660     BVIEWFLD vf;
0661     struct UBTESTVIEW2 v;
0662
0663     memset(&v, 0, sizeof(v));
0664
0665     vf.data=(char *)&v;
0666     vf.vflags=0;
0667     NDRX_STRCPY_SAFE(vf.vname, "UBTESTVIEW2");
0668
0669     /* init */
0670     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0671     assert_equal(Badd(p_ub, T_VIEW_FLD, (char *)&vf, 0), EXSUCCEED);
0672
0673     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_SHORT), EXFAIL);
0674     assert_equal(Berror, BEBADOP);
0675
0676     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_LONG), EXFAIL);
0677     assert_equal(Berror, BEBADOP);
0678
0679     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_CHAR), EXFAIL);
0680     assert_equal(Berror, BEBADOP);
0681
0682     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_FLOAT), EXFAIL);
0683     assert_equal(Berror, BEBADOP);
0684
0685     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_DOUBLE), EXFAIL);
0686     assert_equal(Berror, BEBADOP);
0687
0688     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_STRING), EXFAIL);
0689     assert_equal(Berror, BEBADOP);
0690
0691     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_CARRAY), EXFAIL);
0692     assert_equal(Berror, BEBADOP);
0693
0694     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_PTR), EXFAIL);
0695     assert_equal(Berror, BEBADOP);
0696
0697     assert_equal(CBget(p_ub, T_VIEW_FLD, 0, (char *)tmp, 0, BFLD_UBF), EXFAIL);
0698     assert_equal(Berror, BEBADOP);
0699
0700 }
0701
0702 Ensure(test_CBget_ubf_org)
0703 {
0704     char buf[2048];
0705     UBFH *p_ub = (UBFH *)buf;
0706     char tmp[1024];
0707     UBFH *p_tmp_ub = (UBFH *)tmp;
0708
0709     /* Check adding invalid UBF...? Check atleast the magic..? */
0710
0711     /* init */
0712     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0713
0714     memset(tmp, 1, sizeof(tmp));
0715     assert_equal(Badd(p_ub, T_UBF_FLD, (char *)tmp, 0), EXFAIL);
0716     assert_equal(Berror, BNOTFLD);
0717
0718     assert_equal(Binit(p_tmp_ub, sizeof(tmp)), EXSUCCEED);
0719     assert_equal(Badd(p_tmp_ub, T_STRING_FLD, "HELLO", 0), EXSUCCEED);
0720     assert_equal(Badd(p_ub, T_UBF_FLD, (char *)p_ub, 0), EXSUCCEED);
0721
0722     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_SHORT), EXFAIL);
0723     assert_equal(Berror, BEBADOP);
0724
0725     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_LONG), EXFAIL);
0726     assert_equal(Berror, BEBADOP);
0727
0728     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_CHAR), EXFAIL);
0729     assert_equal(Berror, BEBADOP);
0730
0731     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_FLOAT), EXFAIL);
0732     assert_equal(Berror, BEBADOP);
0733
0734     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_DOUBLE), EXFAIL);
0735     assert_equal(Berror, BEBADOP);
0736
0737     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_STRING), EXFAIL);
0738     assert_equal(Berror, BEBADOP);
0739
0740     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_CARRAY), EXFAIL);
0741     assert_equal(Berror, BEBADOP);
0742
0743     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_PTR), EXFAIL);
0744     assert_equal(Berror, BEBADOP);
0745
0746     assert_equal(CBget(p_ub, T_UBF_FLD, 0, (char *)tmp, 0, BFLD_VIEW), EXFAIL);
0747     assert_equal(Berror, BEBADOP);
0748
0749 }
0750
0751 Ensure(test_CBget_ptr_org)
0752 {
0753     char buf[640];
0754     UBFH *p_ub = (UBFH *)buf;
0755     long test_val=456412;
0756     int len = 0;
0757     char *small_val=(char *)44;
0758     /* test buffers */
0759     short test_short = 0;
0760     long test_long = 0;
0761     char test_char = 0;
0762     float test_float = 0.0;
0763     double test_double = 0.0;
0764     char test_string[128];
0765     char test_carray[128];
0766     char tmp[1024];
0767     char *ptr;
0768     BVIEWFLD v;
0769     UBFH *p_tmp_ub = (UBFH *)tmp;
0770
0771     /* init */
0772     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0773     len = sizeof(test_val);
0774     assert_equal(Badd(p_ub, T_PTR_FLD, (char *)&small_val, len), EXSUCCEED);
0775
0776     /* Now test all types */
0777     /* short out */
0778     len=sizeof(test_short);
0779     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&test_short, &len, BFLD_SHORT), EXSUCCEED);
0780     assert_equal(test_short, 44);
0781     assert_equal(len, sizeof(test_short));
0782     /* char out */
0783     len=sizeof(test_char);
0784     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&test_char, &len, BFLD_CHAR), EXSUCCEED);
0785     assert_equal(test_char, 44);
0786
0787     /* long out */
0788     len=sizeof(test_long);
0789     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&test_long, &len, BFLD_LONG), EXSUCCEED);
0790     assert_equal(test_long, 44);
0791     assert_equal(len, sizeof(test_long));
0792     /* test float */
0793     len=sizeof(test_float);
0794     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&test_float, &len, BFLD_FLOAT), EXSUCCEED);
0795     assert_equal(test_float, 44);
0796     assert_equal(len, sizeof(test_float));
0797     /* test double */
0798     len=sizeof(test_double);
0799     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&test_double, &len, BFLD_DOUBLE), EXSUCCEED);
0800     assert_equal(test_float, 44);
0801     assert_equal(len, sizeof(test_double));
0802     /* test string */
0803     len=sizeof(test_string);
0804     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)test_string, &len, BFLD_STRING), EXSUCCEED);
0805     assert_string_equal(test_string, "0x2c");
0806     assert_equal(len, 5);
0807     /* test carray */
0808     len=sizeof(test_string);
0809     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)test_carray, &len, BFLD_CARRAY), EXSUCCEED);
0810     assert_equal(strncmp(test_carray, "0x2c", 4), 0);
0811     assert_equal(len, 4);
0812
0813     /* may be cast to PTR */
0814     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&ptr, 0, BFLD_PTR), EXSUCCEED);
0815     assert_equal((long)ptr, 44);
0816
0817     v.data = tmp;
0818     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)&v, 0, BFLD_VIEW), EXFAIL);
0819     assert_equal(Berror, BEBADOP);
0820
0821     assert_equal(CBget(p_ub, T_PTR_FLD, 0, (char *)p_tmp_ub, 0, BFLD_UBF), EXFAIL);
0822     assert_equal(Berror, BEBADOP);
0823 }
0824
0825 TestSuite *ubf_cfget_tests(void)
0826 {
0827     TestSuite *suite = create_test_suite();
0828
0829     std_basic_setup();
0830
0831     add_test(suite, test_CBget_short_org);
0832     add_test(suite, test_CBget_long_org);
0833     add_test(suite, test_CBget_char_org);
0834     add_test(suite, test_CBget_float_org);
0835     add_test(suite, test_CBget_double_org);
0836     add_test(suite, test_CBget_string_org);
0837     add_test(suite, test_CBget_carray_org);
0838     add_test(suite, test_CBget_view_org);
0839     add_test(suite, test_CBget_ubf_org);
0840     add_test(suite, test_CBget_ptr_org);
0841
0842     /* string & carray */
0843
0844     return suite;
0845 }
0846
0847 /* vim: set ts=4 sw=4 et smartindent: */