source/ubftest/test_cbchg.c

0001 /**
0002  *
0003  * @file test_cbchg.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 <fml.h>
0039 #include <fml32.h>
0040 #include <ndrstandard.h>
0041 #include <string.h>
0042 #include "test.fd.h"
0043 #include "ubfunit1.h"
0044
0045 /**
0046  * Original field is BFLD_SHORT => T_SHORT_FLD
0047  */
0048 Ensure(test_Bchg_short_org)
0049 {
0050     char buf[2048];
0051     UBFH *p_ub = (UBFH *)buf;
0052     short test_val;
0053     short short_val = 123;
0054     long long_val = 102;
0055     char char_val = '7';
0056     float float_val=11;
0057     double double_val=1443;
0058     char string[129]="31255";
0059     char carray[128]="26411";
0060     char *ptr=(char *)(ndrx_longptr_t)11;
0061
0062     /* init */
0063     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0064     set_up_dummy_data(p_ub);
0065
0066     /* short-to-short */
0067     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0068     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0069     assert_equal(test_val, 123);
0070     do_dummy_data_test(p_ub);
0071     /* long-to-short */
0072     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0073     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0074     assert_equal(test_val, 102);
0075     do_dummy_data_test(p_ub);
0076     /* char-to-short */
0077     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0078     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0079     assert_equal(test_val, 55); /* 55 - ascii code for '7' */
0080     do_dummy_data_test(p_ub);
0081     /* float-to-short */
0082     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0083     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0084     assert_equal(test_val, 11);
0085     do_dummy_data_test(p_ub);
0086     /* double-to-short */
0087     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0088     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0089     assert_equal(test_val, 1443);
0090     do_dummy_data_test(p_ub);
0091     /* string-to-short */
0092     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0093     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0094     assert_equal(test_val, 31255);
0095     do_dummy_data_test(p_ub);
0096     /* carray-to-short */
0097     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0098     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0099     assert_equal(test_val, 26411);
0100     do_dummy_data_test(p_ub);
0101
0102     /* ptr-to-short */
0103     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0104     assert_equal(Bget(p_ub, T_SHORT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0105     assert_equal(test_val, 11);
0106     do_dummy_data_test(p_ub);
0107
0108     /* ubf-to-short */
0109     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0110     assert_equal(Berror, BEBADOP);
0111     do_dummy_data_test(p_ub);
0112
0113     /* view-to-short */
0114     assert_equal(CBchg(p_ub, T_SHORT_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0115     assert_equal(Berror, BEBADOP);
0116     do_dummy_data_test(p_ub);
0117
0118 }
0119
0120 /**
0121  * Original field is BFLD_LONG => T_LONG_FLD
0122  */
0123 Ensure(test_Bchg_long_org)
0124 {
0125     char buf[2048];
0126     UBFH *p_ub = (UBFH *)buf;
0127     long test_val;
0128     short short_val = 123;
0129     long long_val = 102;
0130     char char_val = '7';
0131     float float_val=11123341;
0132     double double_val=14431234;
0133     char string[129]="3125511";
0134     char carray[128]="2641133";
0135     char *ptr=(char *)(ndrx_longptr_t)11;
0136
0137     /* init */
0138     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0139     set_up_dummy_data(p_ub);
0140
0141     /* short-to-long */
0142     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0143     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0144     assert_equal(test_val, 123);
0145     do_dummy_data_test(p_ub);
0146     /* long-to-long */
0147     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0148     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0149     assert_equal(test_val, 102);
0150     do_dummy_data_test(p_ub);
0151     /* char-to-long */
0152     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0153     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0154     assert_equal(test_val, 55); /* 55 - ascii code for '7' */
0155     do_dummy_data_test(p_ub);
0156     /* float-to-long */
0157     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0158     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0159     assert_equal(test_val, 11123341);
0160     do_dummy_data_test(p_ub);
0161     /* double-to-long */
0162     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0163     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0164     assert_equal(test_val, 14431234);
0165     do_dummy_data_test(p_ub);
0166     /* string-to-long */
0167     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0168     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0169     assert_equal(test_val, 3125511);
0170     do_dummy_data_test(p_ub);
0171     /* carray-to-long */
0172     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0173     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0174     assert_equal(test_val, 2641133);
0175     do_dummy_data_test(p_ub);
0176
0177     /* ptr-to-long */
0178     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0179     assert_equal(Bget(p_ub, T_LONG_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0180     assert_equal(test_val, 11);
0181     do_dummy_data_test(p_ub);
0182
0183     /* ubf-to-long */
0184     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0185     assert_equal(Berror, BEBADOP);
0186     do_dummy_data_test(p_ub);
0187
0188     /* view-to-long */
0189     assert_equal(CBchg(p_ub, T_LONG_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0190     assert_equal(Berror, BEBADOP);
0191     do_dummy_data_test(p_ub);
0192 }
0193
0194 /**
0195  * Original field is BFLD_CHAR => T_CHAR_FLD
0196  */
0197 Ensure(test_Bchg_char_org)
0198 {
0199     char buf[2048];
0200     UBFH *p_ub = (UBFH *)buf;
0201     char test_val;
0202     short short_val = 1;
0203     long long_val = 2;
0204     char char_val = '7';
0205     float float_val=3;
0206     double double_val=4;
0207     char string[129]="5";
0208     char carray[128]="6";
0209     char *ptr=(char *)(ndrx_longptr_t)65;
0210
0211     /* init */
0212     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0213     set_up_dummy_data(p_ub);
0214
0215     /* short-to-char */
0216     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0217     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0218     assert_equal(test_val, 1);
0219     do_dummy_data_test(p_ub);
0220     /* long-to-char */
0221     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0222     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0223     assert_equal(test_val, 2);
0224     do_dummy_data_test(p_ub);
0225     /* char-to-long */
0226     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0227     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0228     assert_equal(test_val, 55); /* 55 - ascii code for '7' */
0229     do_dummy_data_test(p_ub);
0230     /* float-to-char */
0231     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0232     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0233     assert_equal(test_val, 3);
0234     do_dummy_data_test(p_ub);
0235     /* double-to-char */
0236     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0237     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0238     assert_equal(test_val, 4);
0239     do_dummy_data_test(p_ub);
0240     /* string-to-char */
0241     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0242     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0243     assert_equal(test_val, 53);
0244     do_dummy_data_test(p_ub);
0245     /* carray-to-char */
0246     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0247     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0248     assert_equal(test_val, 54);
0249     do_dummy_data_test(p_ub);
0250
0251     /* ptr-to-char */
0252     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0253     assert_equal(Bget(p_ub, T_CHAR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0254     assert_equal(test_val, 'A');
0255     do_dummy_data_test(p_ub);
0256
0257     /* ubf-to-char */
0258     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0259     assert_equal(Berror, BEBADOP);
0260     do_dummy_data_test(p_ub);
0261
0262     /* view-to-char */
0263     assert_equal(CBchg(p_ub, T_CHAR_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0264     assert_equal(Berror, BEBADOP);
0265     do_dummy_data_test(p_ub);
0266 }
0267
0268 /**
0269  * Original field is BFLD_FLOAT => T_FLOAT_FLD
0270  */
0271 Ensure(test_Bchg_float_org)
0272 {
0273     char buf[2048];
0274     UBFH *p_ub = (UBFH *)buf;
0275     float test_val;
0276     short short_val = 12321;
0277     long long_val = 10223112;
0278     char char_val = '7';
0279     float float_val=111233.41;
0280     double double_val=144.31234;
0281     char string[129]="3125.511";
0282     char carray[128]="-264.1133";
0283     BFLDLEN len; /* Testing len only for few, because thos other should work fine w/out them */
0284     char *ptr=(char *)(ndrx_longptr_t)65;
0285
0286     /* init */
0287     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0288     set_up_dummy_data(p_ub);
0289
0290     /* short-to-float */
0291     len=sizeof(test_val);
0292     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0293     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0294     assert_double_equal(test_val, 12321);
0295     do_dummy_data_test(p_ub);
0296     assert_equal(sizeof(test_val), len);
0297     /* long-to-float */
0298     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0299     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0300     assert_double_equal(test_val, 10223112);
0301     do_dummy_data_test(p_ub);
0302     /* char-to-float */
0303     len=sizeof(test_val);
0304     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0305     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0306     assert_double_equal(test_val, 55); /* 55 - ascii code for '7' */
0307     do_dummy_data_test(p_ub);
0308     assert_equal(len, sizeof(test_val));
0309     len=sizeof(test_val)-1;
0310     /* validate the error output! */
0311     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, &len), EXFAIL);
0312     assert_equal(Berror, BNOSPACE);
0313     /* Check the case when buffer is too short! */
0314     /* float-to-float */
0315     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0316     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0317     assert_double_equal(test_val, 111233.41);
0318     do_dummy_data_test(p_ub);
0319     /* double-to-float */
0320     len=sizeof(test_val);
0321     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0322     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0323     assert_double_equal(test_val, 144.31234);
0324     do_dummy_data_test(p_ub);
0325     assert_equal(len, sizeof(test_val));
0326     /* string-to-float */
0327     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0328     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0329     assert_double_equal(test_val, 3125.511);
0330     do_dummy_data_test(p_ub);
0331     /* carray-to-float */
0332     len=sizeof(test_val);
0333     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0334     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0335     assert_double_equal(test_val, -264.1133f);
0336     do_dummy_data_test(p_ub);
0337     assert_equal(len, sizeof(test_val));
0338
0339     /* ptr-to-float */
0340     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0341     assert_equal(Bget(p_ub, T_FLOAT_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0342     assert_double_equal(test_val, 65.0f);
0343     do_dummy_data_test(p_ub);
0344
0345     /* ubf-to-float */
0346     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0347     assert_equal(Berror, BEBADOP);
0348     do_dummy_data_test(p_ub);
0349
0350     /* view-to-float */
0351     assert_equal(CBchg(p_ub, T_FLOAT_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0352     assert_equal(Berror, BEBADOP);
0353     do_dummy_data_test(p_ub);
0354 }
0355
0356 /**
0357  * Original field is BFLD_DOUBLE => T_DOUBLE_FLD
0358  */
0359 Ensure(test_Bchg_double_org)
0360 {
0361     char buf[2048];
0362     UBFH *p_ub = (UBFH *)buf;
0363     double test_val;
0364     short short_val = 22321;
0365     long long_val = 20223112;
0366     char char_val = '4';
0367     float float_val=211233.41;
0368     double double_val=244.31234;
0369     char string[129]="2125.511";
0370     char carray[128]="-2264.1133";
0371     BFLDLEN len; /* Testing len only for few, because thos other should work fine w/out them */
0372     char *ptr=(char *)(ndrx_longptr_t)65;
0373
0374     /* init */
0375     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0376     set_up_dummy_data(p_ub);
0377
0378     /* short-to-float */
0379     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0380     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0381     assert_double_equal(test_val, 22321);
0382     do_dummy_data_test(p_ub);
0383     /* long-to-float */
0384     len=sizeof(test_val);
0385     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0386     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0387     assert_double_equal(test_val, 20223112);
0388     do_dummy_data_test(p_ub);
0389     assert_equal(sizeof(test_val), len);
0390
0391     /* char-to-float */
0392     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0393     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0394     assert_double_equal(test_val, 52); /* 55 - ascii code for '7' */
0395     do_dummy_data_test(p_ub);
0396     /* float-to-float */
0397     len=sizeof(test_val);
0398     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0399     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0400     assert_double_equal(test_val, 211233.41);
0401     do_dummy_data_test(p_ub);
0402     assert_equal(sizeof(test_val), len);
0403     /* double-to-float */
0404     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0405     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0406     assert_double_equal(test_val, 244.31234);
0407     do_dummy_data_test(p_ub);
0408     /* string-to-double */
0409     len=sizeof(test_val);
0410     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0411     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, &len), EXSUCCEED);
0412     assert_double_equal(test_val, 2125.511);
0413     do_dummy_data_test(p_ub);
0414     assert_equal(sizeof(test_val), len);
0415
0416     /* carray-to-float */
0417     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0418     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0419     assert_double_equal(test_val, -2264.1133);
0420     do_dummy_data_test(p_ub);
0421
0422     /* ptr-to-double */
0423     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0424     assert_equal(Bget(p_ub, T_DOUBLE_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0425     assert_double_equal(test_val, 65.0f);
0426     do_dummy_data_test(p_ub);
0427
0428     /* ubf-to-double */
0429     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0430     assert_equal(Berror, BEBADOP);
0431     do_dummy_data_test(p_ub);
0432
0433     /* view-to-double */
0434     assert_equal(CBchg(p_ub, T_DOUBLE_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0435     assert_equal(Berror, BEBADOP);
0436     do_dummy_data_test(p_ub);
0437 }
0438
0439 /**
0440  * Original field is BFLD_STRING => T_STRING_FLD
0441  */
0442 Ensure(test_Bchg_string_org)
0443 {
0444     char buf[3072];
0445     UBFH *p_ub = (UBFH *)buf;
0446     char test_val[641];
0447     short short_val = 22321;
0448     long long_val = 20223112;
0449     char char_val = '4';
0450     float float_val=211233.41;
0451     double double_val=244.31234;
0452     double double_val2=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0453     double double_tmp;
0454     char string[514+1]="2125.511";
0455     char carray[514];
0456     int i;
0457     BFLDLEN len;
0458     /* variables for big buffer test */
0459     char string_big[1024];
0460     int str_len_tmp;
0461     int big_loop;
0462     char *ptr=(char *)(ndrx_longptr_t)65;
0463
0464     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0465     set_up_dummy_data(p_ub);
0466     /*
0467      * Initialize character array to some dummy value
0468      */
0469     for (i=0; i<sizeof(carray); i++)
0470     {
0471         char c = 48 + (i % 74);
0472         carray[i] = c;
0473         string[1] = c-1;
0474     }
0475     /* Put trailing EOS */
0476     string[sizeof(string)-1] = 0;
0477
0478     len=sizeof(test_val);
0479     /* short-to-string */
0480
0481     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0482     Bprint(p_ub);
0483     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0484     assert_string_equal(test_val, "22321");
0485     assert_equal(len, 6);
0486
0487     do_dummy_data_test(p_ub);
0488     /* long-to-string */
0489     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0490     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, 0), EXSUCCEED);
0491     assert_string_equal(test_val, "20223112");
0492     do_dummy_data_test(p_ub);
0493     /* char-to-string */
0494     len=sizeof(test_val);
0495     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0496     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0497     assert_string_equal(test_val, "4"); /* 55 - ascii code for '7' */
0498     assert_equal(len, 2);
0499     do_dummy_data_test(p_ub);
0500     /* float-to-string (test on Tuxedo) */
0501     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0502     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, 0), EXSUCCEED);
0503     assert_equal(strncmp(test_val, "211233.41", 8),0);
0504     do_dummy_data_test(p_ub);
0505     /* double-to-string (test un Tuxedo?) */
0506     len=sizeof(test_val);
0507     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0508     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0509     assert_equal(strncmp(test_val, "244.31234",9),0);
0510     assert_true(len>9);
0511     do_dummy_data_test(p_ub);
0512     assert_equal(CBchg(p_ub, T_STRING_FLD, 1, (char *)&double_val2, 0, BFLD_DOUBLE), EXSUCCEED);
0513     assert_equal(CBget(p_ub, T_STRING_FLD, 1, (char *)&double_tmp, 0, BFLD_DOUBLE), EXSUCCEED);
0514     assert_double_equal(double_val2, double_tmp);
0515     Bdel(p_ub, T_STRING_FLD, 1);
0516
0517     /* string-to-string */
0518     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0519     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, 0), EXSUCCEED);
0520     assert_string_equal(test_val, string);
0521     do_dummy_data_test(p_ub);
0522     /* carray-to-string */
0523     len=sizeof(test_val);
0524     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)carray, sizeof(carray), BFLD_CARRAY), EXSUCCEED);
0525     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0526     assert_equal(strncmp(test_val, carray, sizeof(carray)), 0);
0527     assert_equal(len, sizeof(carray)+1);
0528     do_dummy_data_test(p_ub);
0529
0530     /* Special test for handling large strings & carrays */
0531     for (big_loop=0; big_loop<10;big_loop++)
0532     {
0533         str_len_tmp=strlen(BIG_TEST_STRING);
0534         assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)BIG_TEST_STRING, str_len_tmp, BFLD_CARRAY), EXSUCCEED);
0535         len = sizeof(string_big);
0536         assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)string_big, &len), EXSUCCEED);
0537         assert_equal(len, str_len_tmp+1);
0538         assert_equal(strncmp(string_big, BIG_TEST_STRING, str_len_tmp), 0);
0539     }
0540
0541     /* ptr-to-string */
0542     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0543     assert_equal(Bget(p_ub, T_STRING_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0544     assert_string_equal(test_val, "0x41");
0545     do_dummy_data_test(p_ub);
0546
0547     /* ubf-to-string */
0548     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0549     assert_equal(Berror, BEBADOP);
0550     do_dummy_data_test(p_ub);
0551
0552     /* view-to-string */
0553     assert_equal(CBchg(p_ub, T_STRING_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0554     assert_equal(Berror, BEBADOP);
0555     do_dummy_data_test(p_ub);
0556
0557 }
0558
0559 /**
0560  * Original field is BFLD_CARRAY => T_CARRAY_FLD
0561  */
0562 Ensure(test_Bchg_carray_org)
0563 {
0564     char buf[3072];
0565     UBFH *p_ub = (UBFH *)buf;
0566     char test_val[514];
0567     short short_val = 22321;
0568     long long_val = 20223112;
0569     char char_val = '4';
0570     float float_val=211233.41;
0571     double double_val=244.31234;
0572     double double_val2=1223234232342324323423423423423423434342343454353453243245343453243452343453243243425343453425523423423423423234234234234234234234234234234234234234234234234243234234324343.65;
0573     char string[514+1]="2125.511";
0574     char carray[514];
0575     int i;
0576     int len;
0577     /* Big buffer test... */
0578     char carray_big[1024];
0579     int str_len_tmp;
0580     int big_loop;
0581
0582     /* working in LP64 mode */
0583     char *ptr=(char *)(ndrx_longptr_t)0xff;
0584
0585     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0586     set_up_dummy_data(p_ub);
0587     /*
0588      * Initialize character array to some dummy value
0589      */
0590     for (i=0; i<sizeof(carray); i++)
0591     {
0592         char c = 48 + (i % 74);
0593         carray[i] = c;
0594         string[1] = c-1;
0595     }
0596     /* Put trailing EOS */
0597     string[sizeof(string)-1] = 0;
0598
0599     /* short-to-carray */
0600     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0601     Bprint(p_ub);
0602     len=sizeof(carray);
0603     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0604     assert_equal(strncmp(test_val,  "22321", 5), 0);
0605     assert_equal(len, 5);
0606     do_dummy_data_test(p_ub);
0607
0608     /* Bug #495 - no length passed */
0609     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, NULL), EXSUCCEED);
0610     assert_equal(strncmp(test_val,  "22321", 5), 0);
0611
0612     /* long-to-carray */
0613     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0614     len=sizeof(carray);
0615     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0616     assert_equal(strncmp(test_val,  "20223112", 8), 0);
0617     assert_equal(len, 8);
0618     do_dummy_data_test(p_ub);
0619     /* char-to-carray */
0620     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0621     len=sizeof(carray);
0622     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0623     assert_equal(strncmp(test_val,  "4", 1), 0); /* 55 - ascii code for '7' */
0624     assert_equal(len, 1);
0625     do_dummy_data_test(p_ub);
0626     /* float-to-carray (test on Tuxedo) */
0627     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0628     len=sizeof(carray);
0629     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0630     assert_equal(strncmp(test_val, "211233.41", 8),0);
0631     assert_true(len>=8);
0632     do_dummy_data_test(p_ub);
0633     /* double-to-carray (test un Tuxedo?) */
0634     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0635     len=sizeof(carray);
0636     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0637     assert_equal(strncmp(test_val, "244.31234",9),0);
0638     assert_true(len>=9);
0639     do_dummy_data_test(p_ub);
0640
0641     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 1, (char *)&double_val2, 0, BFLD_DOUBLE), EXSUCCEED);
0642     Bdel(p_ub, T_CARRAY_FLD, 1);
0643
0644     /* string-to-carray */
0645     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0646     len=sizeof(carray);
0647     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0648     assert_equal(strncmp(test_val, string, strlen(string)),0);
0649
0650     do_dummy_data_test(p_ub);
0651     /* carray-to-carray */
0652     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)carray, sizeof(carray), BFLD_CARRAY), EXSUCCEED);
0653     len=sizeof(carray);
0654     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0655     assert_equal(strncmp(test_val, carray, sizeof(carray)), 0);
0656
0657     /* test empty carray */
0658     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)carray, 0, BFLD_CARRAY), EXSUCCEED);
0659     len=sizeof(carray);
0660     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)test_val, &len), EXSUCCEED);
0661     assert_equal(len, 0);
0662
0663     do_dummy_data_test(p_ub);
0664
0665     /* Special test for hadling large strings & carrays */
0666     str_len_tmp=strlen(BIG_TEST_STRING);
0667
0668     for (big_loop=0; big_loop<10;big_loop++)
0669     {
0670         assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)BIG_TEST_STRING, str_len_tmp, BFLD_CARRAY), EXSUCCEED);
0671         len = sizeof(carray_big);
0672         assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)carray_big, &len), EXSUCCEED);
0673         assert_equal(len, str_len_tmp);
0674         assert_equal(strncmp(carray_big, BIG_TEST_STRING, str_len_tmp), 0);
0675     }
0676
0677     /* ptr-to-carray */
0678     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0679     assert_equal(Bget(p_ub, T_CARRAY_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0680     assert_equal(strncmp(test_val, "0xff", 4), 0);
0681     do_dummy_data_test(p_ub);
0682
0683     /* ubf-to-carray */
0684     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0685     assert_equal(Berror, BEBADOP);
0686     do_dummy_data_test(p_ub);
0687
0688     /* view-to-carray */
0689     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0690     assert_equal(Berror, BEBADOP);
0691     do_dummy_data_test(p_ub);
0692 }
0693
0694 Ensure(test_Bchg_simple)
0695 {
0696     char fb[1024];
0697     char buf[1024]="This is test...";
0698     int len = sizeof(fb);
0699
0700     UBFH *p_ub = (UBFH *)fb;
0701     assert_equal(Binit(p_ub, len), EXSUCCEED);
0702     assert_equal(CBchg(p_ub, T_CARRAY_FLD, 0, buf, len-84, BFLD_CARRAY), EXSUCCEED);
0703 }
0704
0705 /**
0706  * Note all over the system we assume that sizeof(long) == sizeof(ptr)
0707  * In case if will port to Windows someday, then this needs to be corrected
0708  * i.e. in that case we need to use long long LLP64
0709  */
0710 Ensure(test_Bchg_ptr_org)
0711 {
0712     char buf[2048];
0713     UBFH *p_ub = (UBFH *)buf;
0714     ndrx_longptr_t test_val;
0715     short short_val = 123;
0716     long long_val = 102;
0717     char char_val = '7';
0718     float float_val=11123341;
0719     double double_val=14431234;
0720     char string[129]="0x3125511";
0721     char carray[128]="0x2641133";
0722     char *ptr=(char *)(ndrx_longptr_t)11;
0723
0724     /* init */
0725     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0726     set_up_dummy_data(p_ub);
0727
0728     /* short-to-ptr */
0729     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&short_val, 0, BFLD_SHORT), EXSUCCEED);
0730     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0731     assert_equal(test_val, 123);
0732     do_dummy_data_test(p_ub);
0733     /* long-to-ptr */
0734     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&long_val, 0, BFLD_LONG), EXSUCCEED);
0735     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0736     assert_equal(test_val, 102);
0737     do_dummy_data_test(p_ub);
0738     /* char-to-ptr */
0739     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&char_val, 0, BFLD_CHAR), EXSUCCEED);
0740     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0741     assert_equal(test_val, 55); /* 55 - ascii code for '7' */
0742     do_dummy_data_test(p_ub);
0743     /* float-to-ptr */
0744     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&float_val, 0, BFLD_FLOAT), EXSUCCEED);
0745     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0746     assert_equal(test_val, 11123341);
0747     do_dummy_data_test(p_ub);
0748     /* double-to-ptr */
0749     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&double_val, 0, BFLD_DOUBLE), EXSUCCEED);
0750     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0751     assert_equal(test_val, 14431234);
0752     do_dummy_data_test(p_ub);
0753     /* string-to-ptr */
0754     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)string, 0, BFLD_STRING), EXSUCCEED);
0755     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0756     assert_equal(test_val, 0x3125511);
0757     do_dummy_data_test(p_ub);
0758     /* carray-to-ptr */
0759     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)carray, strlen(carray), BFLD_CARRAY), EXSUCCEED);
0760     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0761     assert_equal(test_val, 0x2641133);
0762     do_dummy_data_test(p_ub);
0763
0764     /* ptr-to-ptr */
0765     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&ptr, 0L, BFLD_PTR), EXSUCCEED);
0766     assert_equal(Bget(p_ub, T_PTR_FLD, 0, (char *)&test_val, 0), EXSUCCEED);
0767     assert_equal(test_val, 11);
0768     do_dummy_data_test(p_ub);
0769
0770     /* ubf-to-ptr */
0771     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)&ptr, 0L, BFLD_UBF), EXFAIL);
0772     assert_equal(Berror, BEBADOP);
0773     do_dummy_data_test(p_ub);
0774
0775     /* view-to-ptr */
0776     assert_equal(CBchg(p_ub, T_PTR_FLD, 0, (char *)ptr, 0L, BFLD_VIEW), EXFAIL);
0777     assert_equal(Berror, BEBADOP);
0778     do_dummy_data_test(p_ub);
0779 }
0780
0781 Ensure(test_Bchg_ubf_org)
0782 {
0783     char buf[2048];
0784     UBFH *p_ub = (UBFH *)buf;
0785
0786     char buf_tmp[2048];
0787     UBFH *p_ub_tmp = (UBFH *)buf_tmp;
0788
0789     /* init */
0790     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0791     assert_equal(Binit(p_ub_tmp, sizeof(buf_tmp)), EXSUCCEED);
0792
0793     set_up_dummy_data(p_ub);
0794
0795     /* load some UBF */
0796     assert_equal(Badd(p_ub_tmp, T_STRING_FLD, "HELLO WORLD", 0), EXSUCCEED);
0797     assert_equal(Badd(p_ub, T_UBF_FLD, (char *)p_ub_tmp, 0), EXSUCCEED);
0798
0799     /* short-to-ubf */
0800     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_SHORT), EXFAIL);
0801     assert_equal(Berror, BEBADOP);
0802     do_dummy_data_test(p_ub);
0803
0804     /* long-to-ubf */
0805     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_LONG), EXFAIL);
0806     assert_equal(Berror, BEBADOP);
0807     do_dummy_data_test(p_ub);
0808
0809     /* char-to-ubf */
0810     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_CHAR), EXFAIL);
0811     assert_equal(Berror, BEBADOP);
0812     do_dummy_data_test(p_ub);
0813
0814     /* float-to-ubf */
0815     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_FLOAT), EXFAIL);
0816     assert_equal(Berror, BEBADOP);
0817     do_dummy_data_test(p_ub);
0818
0819     /* double-to-ubf */
0820     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_DOUBLE), EXFAIL);
0821     assert_equal(Berror, BEBADOP);
0822     do_dummy_data_test(p_ub);
0823
0824     /* string-to-ubf */
0825     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_STRING), EXFAIL);
0826     assert_equal(Berror, BEBADOP);
0827     do_dummy_data_test(p_ub);
0828
0829     /* carray-to-ubf */
0830     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_CARRAY), EXFAIL);
0831     assert_equal(Berror, BEBADOP);
0832     do_dummy_data_test(p_ub);
0833
0834     /* ptr-to-ubf */
0835     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_PTR), EXFAIL);
0836     assert_equal(Berror, BEBADOP);
0837     do_dummy_data_test(p_ub);
0838
0839     /* view-to-ubf */
0840     assert_equal(CBchg(p_ub, T_UBF_FLD, 0, (char *)buf_tmp, 0, BFLD_VIEW), EXFAIL);
0841     assert_equal(Berror, BEBADOP);
0842     do_dummy_data_test(p_ub);
0843 }
0844
0845 Ensure(test_Bchg_view_org)
0846 {
0847     char buf[2048];
0848     UBFH *p_ub = (UBFH *)buf;
0849     char buf_tmp[2048];
0850     BVIEWFLD vf;
0851     struct UBTESTVIEW2 v;
0852
0853     NDRX_STRCPY_SAFE(vf.vname, "UBTESTVIEW2");
0854     vf.vflags=0;
0855     vf.data=(char *)&v;
0856
0857     /* init */
0858     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0859
0860     set_up_dummy_data(p_ub);
0861
0862     /* load some UBF */
0863     assert_equal(Badd(p_ub, T_VIEW_FLD, (char *)&vf, 0), EXSUCCEED);
0864
0865     /* short-to-view */
0866     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_SHORT), EXFAIL);
0867     assert_equal(Berror, BEBADOP);
0868     do_dummy_data_test(p_ub);
0869
0870     /* long-to-view */
0871     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_LONG), EXFAIL);
0872     assert_equal(Berror, BEBADOP);
0873     do_dummy_data_test(p_ub);
0874
0875     /* char-to-view */
0876     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_CHAR), EXFAIL);
0877     assert_equal(Berror, BEBADOP);
0878     do_dummy_data_test(p_ub);
0879
0880     /* float-to-view */
0881     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_FLOAT), EXFAIL);
0882     assert_equal(Berror, BEBADOP);
0883     do_dummy_data_test(p_ub);
0884
0885     /* double-to-view */
0886     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_DOUBLE), EXFAIL);
0887     assert_equal(Berror, BEBADOP);
0888     do_dummy_data_test(p_ub);
0889
0890     /* string-to-view */
0891     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_STRING), EXFAIL);
0892     assert_equal(Berror, BEBADOP);
0893     do_dummy_data_test(p_ub);
0894
0895     /* carray-to-view */
0896     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_CARRAY), EXFAIL);
0897     assert_equal(Berror, BEBADOP);
0898     do_dummy_data_test(p_ub);
0899
0900     /* ptr-to-view */
0901     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_PTR), EXFAIL);
0902     assert_equal(Berror, BEBADOP);
0903     do_dummy_data_test(p_ub);
0904
0905     /* ubf-to-view */
0906     assert_equal(CBchg(p_ub, T_VIEW_FLD, 0, (char *)buf_tmp, 0, BFLD_UBF), EXFAIL);
0907     assert_equal(Berror, BEBADOP);
0908     do_dummy_data_test(p_ub);
0909 }
0910
0911 /**
0912  * Test FML wrapper
0913  * i.e. FLD_PTR logic is different for FML.
0914  */
0915 Ensure(test_Fchg)
0916 {
0917     char buf1[56000];
0918     char buf_ptr1[100];
0919     char buf_ptr2[100];
0920     char *ptr_get = NULL;
0921     long l;
0922     BFLDLEN len;
0923     UBFH *p_ub1 = (UBFH *)buf1;
0924
0925     memset(buf1, 0, sizeof(buf1));
0926     assert_equal(Binit(p_ub1, sizeof(buf1)), EXSUCCEED);
0927
0928     /* Load ptr */
0929     assert_equal(Fchg(p_ub1, T_PTR_FLD, 0, buf_ptr1, 0), EXSUCCEED);
0930     assert_equal(Fchg(p_ub1, T_PTR_FLD, 1, buf_ptr1, 0), EXSUCCEED);
0931
0932     /* test the occ field */
0933     assert_equal(Fchg32(p_ub1, T_PTR_FLD, 1, buf_ptr2, 0), EXSUCCEED);
0934
0935     l=999;
0936     assert_equal(Fchg(p_ub1, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0937     l=888;
0938     assert_equal(Fchg(p_ub1, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0939
0940     assert_equal(Fchg(p_ub1, T_STRING_FLD, 0, "HELLO 1", 0), EXSUCCEED);
0941     assert_equal(Fchg32(p_ub1, T_STRING_FLD, 1, "HELLO 2", 0), EXSUCCEED);
0942
0943     assert_equal(Fchg(p_ub1, T_CARRAY_FLD, 0, "ABCD", 1), EXSUCCEED);
0944     assert_equal(Fchg32(p_ub1, T_CARRAY_FLD, 1, "CDE", 1), EXSUCCEED);
0945
0946     /* Validate the data.., ptr */
0947     assert_equal(Bget(p_ub1, T_PTR_FLD, 0, (char *)&ptr_get, 0), EXSUCCEED);
0948     assert_equal(ptr_get, buf_ptr1);
0949
0950     assert_equal(Bget(p_ub1, T_PTR_FLD, 1, (char *)&ptr_get, 0), EXSUCCEED);
0951     assert_equal(ptr_get, buf_ptr2);
0952
0953     /* validate string */
0954     assert_equal(Bget(p_ub1, T_STRING_FLD, 0, buf_ptr1, 0), EXSUCCEED);
0955     assert_string_equal(buf_ptr1, "HELLO 1");
0956
0957     assert_equal(Bget(p_ub1, T_STRING_FLD, 1, buf_ptr1, 0), EXSUCCEED);
0958     assert_string_equal(buf_ptr1, "HELLO 2");
0959
0960     assert_equal(CBget(p_ub1, T_CARRAY_FLD, 0, buf_ptr1, 0, BFLD_STRING), EXSUCCEED);
0961     assert_string_equal(buf_ptr1, "A");
0962
0963     assert_equal(CBget(p_ub1, T_CARRAY_FLD, 1, buf_ptr1, 0, BFLD_STRING), EXSUCCEED);
0964     assert_string_equal(buf_ptr1, "C");
0965
0966     /* validate long */
0967
0968     assert_equal(Bget(p_ub1, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0969     assert_equal(l, 999);
0970
0971     assert_equal(Bget(p_ub1, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0972     assert_equal(l, 888);
0973
0974 }
0975
0976 TestSuite *ubf_cfchg_tests(void)
0977 {
0978     TestSuite *suite = create_test_suite();
0979 /*
0980     setup_(suite, basic_setup1);
0981     teardown_(suite, basic_teardown1);
0982 */
0983     add_test(suite, test_Bchg_simple);
0984     add_test(suite, test_Bchg_short_org);
0985     add_test(suite, test_Bchg_long_org);
0986     add_test(suite, test_Bchg_char_org);
0987     add_test(suite, test_Bchg_float_org);
0988     add_test(suite, test_Bchg_double_org);
0989     add_test(suite, test_Bchg_string_org);
0990     add_test(suite, test_Bchg_carray_org);
0991     add_test(suite, test_Bchg_ptr_org);
0992     add_test(suite, test_Bchg_ubf_org);
0993     add_test(suite, test_Bchg_view_org);
0994     add_test(suite, test_Fchg);
0995
0996     return suite;
0997 }
0998
0999 /* vim: set ts=4 sw=4 et smartindent: */