Back to home page

Enduro/X
 
 

     

0001 /**
0002  * Perform tests on embedded UBF buffer
0003  *  Testing strategy:
0004  *  - check error handling for each api
0005  *  - check reading: some fixed len, string, UBF
0006  * 
0007  * @file test_embubf.c
0008  */
0009 /* -----------------------------------------------------------------------------
0010  * Enduro/X Middleware Platform for Distributed Transaction Processing
0011  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0012  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0013  * This software is released under one of the following licenses:
0014  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0015  * See LICENSE file for full text.
0016  * -----------------------------------------------------------------------------
0017  * AGPL license:
0018  *
0019  * This program is free software; you can redistribute it and/or modify it under
0020  * the terms of the GNU Affero General Public License, version 3 as published
0021  * by the Free Software Foundation;
0022  *
0023  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0024  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0025  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0026  * for more details.
0027  *
0028  * You should have received a copy of the GNU Affero General Public License along 
0029  * with this program; if not, write to the Free Software Foundation, Inc.,
0030  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0031  *
0032  * -----------------------------------------------------------------------------
0033  * A commercial use license is available from Mavimax, Ltd
0034  * contact@mavimax.com
0035  * -----------------------------------------------------------------------------
0036  */
0037 
0038 #include <stdio.h>
0039 #include <stdlib.h>
0040 #include <cgreen/cgreen.h>
0041 #include <ubf.h>
0042 #include <ndrstandard.h>
0043 #include <ndebug.h>
0044 #include <string.h>
0045 #include "test.fd.h"
0046 #include "ubfunit1.h"
0047 
0048 /**
0049  * Perform tests for buffer add
0050  */
0051 expublic void load_recursive_data(UBFH *p_ub)
0052 {
0053     char buf1[56000];
0054     UBFH *p_ub1 = (UBFH *)buf1;
0055     
0056     char buf2[56000];
0057     UBFH *p_ub2 = (UBFH *)buf2;
0058     
0059     char buf4[56000];
0060     UBFH *p_ub4 = (UBFH *)buf4;
0061 
0062     struct UBTESTVIEW1 v;
0063     BVIEWFLD vf;
0064         
0065     memset(buf1, 0, sizeof(buf1));
0066     memset(buf2, 0, sizeof(buf2));
0067     memset(buf4, 0, sizeof(buf4));
0068     memset(&v, 11, sizeof(v));
0069     
0070     assert_equal(Binit(p_ub1, sizeof(buf1)), EXSUCCEED);
0071     assert_equal(Binit(p_ub2, sizeof(buf2)), EXSUCCEED);
0072     assert_equal(Binit(p_ub4, sizeof(buf4)), EXSUCCEED);
0073     
0074     assert_equal(Badd(p_ub2, T_STRING_3_FLD, "HELLO_CHILD", 0), EXSUCCEED);
0075     assert_equal(Badd(p_ub2, T_STRING_3_FLD, "HELLO_CHILD 2", 0), EXSUCCEED);
0076     assert_equal(Badd(p_ub2, T_STRING_3_FLD, "HELLO_CHILD 3", 0), EXSUCCEED);
0077     assert_equal(Badd(p_ub2, T_STRING_3_FLD, "HELLO_CHILD 4", 0), EXSUCCEED);
0078     
0079     assert_equal(Badd(p_ub1, T_STRING_2_FLD, "HELLO_PARENT", 0), EXSUCCEED);
0080     assert_equal(Badd(p_ub1, T_STRING_4_FLD, "HELLO_PARENT 2", 0), EXSUCCEED);
0081 
0082     /* Load view data: */    
0083     extest_init_UBTESTVIEW1(&v);
0084     vf.data=(char *)&v;
0085     vf.vflags=0;
0086     NDRX_STRCPY_SAFE(vf.vname, "UBTESTVIEW1");
0087     
0088     assert_equal(Bchg(p_ub2, T_VIEW_FLD, 1, (char *)&vf, 0), EXSUCCEED);
0089     
0090     /* load add fields to lev 2 */
0091     set_up_dummy_data(p_ub4);
0092     assert_equal(Badd(p_ub2, T_UBF_2_FLD, (void *)p_ub4, 0), EXSUCCEED);
0093     
0094     assert_equal(Badd(p_ub1, T_UBF_FLD, (char *)p_ub2, 0), EXSUCCEED);
0095     assert_equal(Badd(p_ub1, T_UBF_FLD, (char *)p_ub4, 0), EXSUCCEED);
0096     
0097     /* load standard base to lev 3*/
0098     assert_equal(Badd(p_ub, T_UBF_FLD, (char *)p_ub4, 0), EXSUCCEED);
0099     assert_equal(Bchg(p_ub, T_UBF_2_FLD, 1, (char *)p_ub1, 0), EXSUCCEED);
0100     set_up_dummy_data(p_ub);
0101     
0102     
0103     /*
0104      Bprint(p_ub); 
0105      */
0106     
0107     /*
0108 
0109 T_LONG_3_FLD    0
0110 T_LONG_3_FLD    0
0111 T_LONG_3_FLD    0
0112 T_LONG_3_FLD    889991
0113 T_DOUBLE_3_FLD  1.110000
0114 T_DOUBLE_3_FLD  2.412310
0115 T_STRING_10_FLD HELLO WORLD5
0116 T_STRING_3_FLD  HELLO WORLD7
0117 T_STRING_4_FLD  HELLO WORLD
0118 T_STRING_4_FLD  HELLO WORLD6
0119 T_STRING_5_FLD  HELLO WORLD2
0120 T_STRING_6_FLD  HELLO WORLD4
0121 T_STRING_7_FLD  HELLO WORLD3
0122 T_STRING_8_FLD  HELLO WORLD1
0123 T_STRING_9_FLD  01
0124 T_STRING_9_FLD  20
0125 T_STRING_9_FLD  31
0126 T_CARRAY_2_FLD  
0127 T_CARRAY_2_FLD  TEST CARRAY
0128 T_PTR_3_FLD 0xc7
0129 T_PTR_3_FLD 0x12b
0130 T_UBF_FLD   
0131     T_LONG_3_FLD    0
0132     T_LONG_3_FLD    0
0133     T_LONG_3_FLD    0
0134     T_LONG_3_FLD    889991
0135     T_DOUBLE_3_FLD  1.110000
0136     T_DOUBLE_3_FLD  2.412310
0137     T_STRING_10_FLD HELLO WORLD5
0138     T_STRING_3_FLD  HELLO WORLD7
0139     T_STRING_4_FLD  HELLO WORLD
0140     T_STRING_4_FLD  HELLO WORLD6
0141     T_STRING_5_FLD  HELLO WORLD2
0142     T_STRING_6_FLD  HELLO WORLD4
0143     T_STRING_7_FLD  HELLO WORLD3
0144     T_STRING_8_FLD  HELLO WORLD1
0145     T_STRING_9_FLD  01
0146     T_STRING_9_FLD  20
0147     T_STRING_9_FLD  31
0148     T_CARRAY_2_FLD  
0149     T_CARRAY_2_FLD  TEST CARRAY
0150     T_PTR_3_FLD 0xc7
0151     T_PTR_3_FLD 0x12b
0152     T_UBF_3_FLD 
0153     T_UBF_3_FLD 
0154     T_UBF_3_FLD 
0155         T_STRING_9_FLD  
0156         T_STRING_9_FLD  
0157         T_STRING_9_FLD  
0158         T_STRING_9_FLD  HELLO WORLD UB
0159     T_UBF_3_FLD 
0160         T_STRING_7_FLD  
0161         T_STRING_7_FLD  
0162         T_STRING_7_FLD  ANOTHER UB
0163         T_STRING_9_FLD  
0164         T_STRING_9_FLD  
0165         T_STRING_9_FLD  
0166         T_STRING_9_FLD  HELLO WORLD UB
0167     T_VIEW_3_FLD    UBTESTVIEW2
0168         tshort1 100
0169         tlong1  200
0170         tchar1  G
0171         tfloat1 400.00000
0172         tdouble1    500.000000
0173         tstring1    6XX
0174         tcarray1    7XX\00\00\00\00\00\00\00
0175     T_VIEW_3_FLD    
0176     T_VIEW_3_FLD    
0177     T_VIEW_3_FLD    
0178     T_VIEW_3_FLD    UBTESTVIEW2
0179         tshort1 100
0180         tlong1  200
0181         tchar1  Z
0182         tfloat1 400.00000
0183         tdouble1    500.000000
0184         tstring1    6YY
0185         tcarray1    7YY\00\00\00\00\00\00\00
0186 T_UBF_2_FLD 
0187 T_UBF_2_FLD 
0188     T_STRING_2_FLD  HELLO_PARENT
0189     T_STRING_4_FLD  HELLO_PARENT 2
0190     T_UBF_FLD   
0191         T_STRING_3_FLD  HELLO_CHILD
0192         T_STRING_3_FLD  HELLO_CHILD 2
0193         T_STRING_3_FLD  HELLO_CHILD 3
0194         T_STRING_3_FLD  HELLO_CHILD 4
0195         T_UBF_2_FLD 
0196             T_LONG_3_FLD    0
0197             T_LONG_3_FLD    0
0198             T_LONG_3_FLD    0
0199             T_LONG_3_FLD    889991
0200             T_DOUBLE_3_FLD  1.110000
0201             T_DOUBLE_3_FLD  2.412310
0202             T_STRING_10_FLD HELLO WORLD5
0203             T_STRING_3_FLD  HELLO WORLD7
0204             T_STRING_4_FLD  HELLO WORLD
0205             T_STRING_4_FLD  HELLO WORLD6
0206             T_STRING_5_FLD  HELLO WORLD2
0207             T_STRING_6_FLD  HELLO WORLD4
0208             T_STRING_7_FLD  HELLO WORLD3
0209             T_STRING_8_FLD  HELLO WORLD1
0210             T_STRING_9_FLD  01
0211             T_STRING_9_FLD  20
0212             T_STRING_9_FLD  31
0213             T_CARRAY_2_FLD  
0214             T_CARRAY_2_FLD  TEST CARRAY
0215             T_PTR_3_FLD 0xc7
0216             T_PTR_3_FLD 0x12b
0217             T_UBF_3_FLD 
0218             T_UBF_3_FLD 
0219             T_UBF_3_FLD 
0220                 T_STRING_9_FLD  
0221                 T_STRING_9_FLD  
0222                 T_STRING_9_FLD  
0223                 T_STRING_9_FLD  HELLO WORLD UB
0224             T_UBF_3_FLD 
0225                 T_STRING_7_FLD  
0226                 T_STRING_7_FLD  
0227                 T_STRING_7_FLD  ANOTHER UB
0228                 T_STRING_9_FLD  
0229                 T_STRING_9_FLD  
0230                 T_STRING_9_FLD  
0231                 T_STRING_9_FLD  HELLO WORLD UB
0232             T_VIEW_3_FLD    UBTESTVIEW2
0233                 tshort1 100
0234                 tlong1  200
0235                 tchar1  G
0236                 tfloat1 400.00000
0237                 tdouble1    500.000000
0238                 tstring1    6XX
0239                 tcarray1    7XX\00\00\00\00\00\00\00
0240             T_VIEW_3_FLD    
0241             T_VIEW_3_FLD    
0242             T_VIEW_3_FLD    
0243             T_VIEW_3_FLD    UBTESTVIEW2
0244                 tshort1 100
0245                 tlong1  200
0246                 tchar1  Z
0247                 tfloat1 400.00000
0248                 tdouble1    500.000000
0249                 tstring1    6YY
0250                 tcarray1    7YY\00\00\00\00\00\00\00
0251         T_VIEW_FLD  
0252         T_VIEW_FLD  UBTESTVIEW1
0253             tshort1 15556
0254             tshort2 9999
0255             tshort2 8888
0256             tshort3 7777
0257             tshort3 -7777
0258             tshort4 -10
0259             tlong1  33333333
0260             tint2   54545
0261             tint2   23232
0262             tint3   -100
0263             tint4   1010101
0264             tint4   989898
0265             tchar1  A
0266             tchar2  A
0267             tchar2  B
0268             tchar2  C
0269             tchar2  
0270 
0271             tchar2      
0272             tfloat1 -0.11000
0273             tfloat1 -0.22000
0274             tfloat1 0.33000
0275             tfloat1 0.44000
0276             tfloat2 100000.10156
0277             tfloat2 200000.20312
0278             tfloat3 333333.12500
0279             tdouble1    99999.111111
0280             tdouble1    11111.999999
0281             tdouble2    -999.123000
0282             tstring0    HELLO Enduro/X
0283             tstring0    
0284             tstring0    \0aABC\0a
0285             tstring1    Pack my box
0286             tstring1    BOX MY PACK
0287             tstring1    \0aEnduro/X\0a
0288             tstring2    CCCCAAAADDDD
0289             tstring2    EEEFFFGGG
0290             tstring3    LLLLLL
0291             tstring3    MMMMMM
0292             tstring3    
0293             tstring3    NNNNNN
0294             tstring4    Some string
0295             tstring5    MEGA TEST
0296             tcarray1    \00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d
0297             tcarray2    \01\02\03\04\05
0298             tcarray3    \02
0299             tcarray3    \02\03
0300             tcarray3    \02\03\04
0301             tcarray3    \02\03\04\05
0302             tcarray3    \02\03\04\05\06
0303             tcarray3    \02\03\04\05\06\07
0304             tcarray3    \02\03\04\05\06\07\08
0305             tcarray3    \02\03\04\05\06\07\08\09
0306             tcarray3    \02\03\04\05\06\07\08\09\0a
0307             tcarray4    \03\04\05\06\07
0308             tcarray5    \04\05\06\07\08
0309     T_UBF_FLD   
0310         T_LONG_3_FLD    0
0311         T_LONG_3_FLD    0
0312         T_LONG_3_FLD    0
0313         T_LONG_3_FLD    889991
0314         T_DOUBLE_3_FLD  1.110000
0315         T_DOUBLE_3_FLD  2.412310
0316         T_STRING_10_FLD HELLO WORLD5
0317         T_STRING_3_FLD  HELLO WORLD7
0318         T_STRING_4_FLD  HELLO WORLD
0319         T_STRING_4_FLD  HELLO WORLD6
0320         T_STRING_5_FLD  HELLO WORLD2
0321         T_STRING_6_FLD  HELLO WORLD4
0322         T_STRING_7_FLD  HELLO WORLD3
0323         T_STRING_8_FLD  HELLO WORLD1
0324         T_STRING_9_FLD  01
0325         T_STRING_9_FLD  20
0326         T_STRING_9_FLD  31
0327         T_CARRAY_2_FLD  
0328         T_CARRAY_2_FLD  TEST CARRAY
0329         T_PTR_3_FLD 0xc7
0330         T_PTR_3_FLD 0x12b
0331         T_UBF_3_FLD 
0332         T_UBF_3_FLD 
0333         T_UBF_3_FLD 
0334             T_STRING_9_FLD  
0335             T_STRING_9_FLD  
0336             T_STRING_9_FLD  
0337             T_STRING_9_FLD  HELLO WORLD UB
0338         T_UBF_3_FLD 
0339             T_STRING_7_FLD  
0340             T_STRING_7_FLD  
0341             T_STRING_7_FLD  ANOTHER UB
0342             T_STRING_9_FLD  
0343             T_STRING_9_FLD  
0344             T_STRING_9_FLD  
0345             T_STRING_9_FLD  HELLO WORLD UB
0346         T_VIEW_3_FLD    UBTESTVIEW2
0347             tshort1 100
0348             tlong1  200
0349             tchar1  G
0350             tfloat1 400.00000
0351             tdouble1    500.000000
0352             tstring1    6XX
0353             tcarray1    7XX\00\00\00\00\00\00\00
0354         T_VIEW_3_FLD    
0355         T_VIEW_3_FLD    
0356         T_VIEW_3_FLD    
0357         T_VIEW_3_FLD    UBTESTVIEW2
0358             tshort1 100
0359             tlong1  200
0360             tchar1  Z
0361             tfloat1 400.00000
0362             tdouble1    500.000000
0363             tstring1    6YY
0364             tcarray1    7YY\00\00\00\00\00\00\00
0365 T_UBF_3_FLD 
0366 T_UBF_3_FLD 
0367 T_UBF_3_FLD 
0368     T_STRING_9_FLD  
0369     T_STRING_9_FLD  
0370     T_STRING_9_FLD  
0371     T_STRING_9_FLD  HELLO WORLD UB
0372 T_UBF_3_FLD 
0373     T_STRING_7_FLD  
0374     T_STRING_7_FLD  
0375     T_STRING_7_FLD  ANOTHER UB
0376     T_STRING_9_FLD  
0377     T_STRING_9_FLD  
0378     T_STRING_9_FLD  
0379     T_STRING_9_FLD  HELLO WORLD UB
0380 T_VIEW_3_FLD    UBTESTVIEW2
0381     tshort1 100
0382     tlong1  200
0383     tchar1  G
0384     tfloat1 400.00000
0385     tdouble1    500.000000
0386     tstring1    6XX
0387     tcarray1    7XX\00\00\00\00\00\00\00
0388 T_VIEW_3_FLD    
0389 T_VIEW_3_FLD    
0390 T_VIEW_3_FLD    
0391 T_VIEW_3_FLD    UBTESTVIEW2
0392     tshort1 100
0393     tlong1  200
0394     tchar1  Z
0395     tfloat1 400.00000
0396     tdouble1    500.000000
0397     tstring1    6YY
0398     tcarray1    7YY\00\00\00\00\00\00\00
0399      
0400      */
0401     
0402 }
0403 
0404 Ensure(test_Bgetr)
0405 {
0406     char buf[56000];
0407     char buf_tmp[56000];
0408     UBFH *p_ub = (UBFH *)buf;
0409     char tmp[1024];
0410     BFLDLEN len;
0411     long l;
0412     UBFH *p_ub_tmp = (UBFH *)buf_tmp;
0413     BVIEWFLD vf;
0414     struct UBTESTVIEW2 v;
0415     
0416     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0417     load_recursive_data(p_ub);
0418     
0419     /* check error path: */
0420     
0421     assert_equal(Bgetr (p_ub, (int []){BBADFLDOCC}, 
0422             tmp, &len), EXFAIL);
0423     assert_equal(Berror, BBADFLD);
0424 
0425     assert_equal(Bgetr (p_ub, (int []){ T_UBF_2_FLD, BBADFLDOCC}, 
0426             tmp, &len), EXFAIL);
0427     assert_equal(Berror, BBADFLD);
0428     
0429     assert_equal(Bgetrv (p_ub, tmp, &len, T_UBF_2_FLD, BBADFLDOCC), EXFAIL);
0430     assert_equal(Berror, BBADFLD);
0431     
0432     /* check invalid subfield (i.e subfield of non UBF..) */
0433     assert_equal(Bgetr (p_ub, (int []){ T_STRING_8_FLD, 0, T_STRING_10_FLD, 0, BBADFLDOCC}, 
0434             tmp, &len), EXFAIL);
0435     assert_equal(Berror, BEBADOP);
0436     
0437     assert_equal(Bgetrv (p_ub, tmp, &len, 
0438             T_STRING_8_FLD, 0, T_STRING_10_FLD, 0, BBADFLDOCC), EXFAIL);
0439     assert_equal(Berror, BEBADOP);
0440     
0441     /* check field not found */
0442     
0443     assert_equal(Bgetrv (p_ub, tmp, &len, 
0444             T_UBF_2_FLD, 1, T_UBF_FLD, 4, T_STRING_3_FLD, 1, BBADFLDOCC), EXFAIL);
0445     assert_equal(Berror, BNOTPRES);
0446     
0447     /* check no space.. */
0448     
0449     /* check standard version */
0450     len=sizeof(tmp);
0451     assert_equal(Bgetr (p_ub, (int []){ T_UBF_2_FLD, 1, T_UBF_FLD, 0, T_STRING_3_FLD, 1, BBADFLDOCC}, 
0452             tmp, &len), EXSUCCEED);
0453     assert_string_equal(tmp, "HELLO_CHILD 2");
0454     assert_equal(len, 14);
0455     
0456     /* Check the v version */
0457     len=sizeof(tmp);
0458     tmp[0]=EXEOS;
0459     
0460     assert_equal(Bgetrv (p_ub, tmp, &len, 
0461             T_UBF_2_FLD, 1, T_UBF_FLD, 0, T_STRING_3_FLD, 1, BBADFLDOCC), EXSUCCEED);
0462     assert_string_equal(tmp, "HELLO_CHILD 2");
0463     assert_equal(len, 14);
0464 
0465     /* read fixed len for level 0*/
0466     
0467     assert_equal(Bgetr (p_ub, (int []){ T_LONG_3_FLD, 3, BBADFLDOCC}, (char *)&l, &len), EXSUCCEED);
0468     assert_equal(l, 889991);
0469     
0470     l=0;
0471     assert_equal(Bgetrv (p_ub, (char *)&l, &len, T_LONG_3_FLD, 3, BBADFLDOCC), EXSUCCEED);
0472     assert_equal(l, 889991);
0473     
0474     
0475     /* Read the UBF... and validate dummy data */
0476     
0477     /* check no space.. */
0478     len=1;
0479     assert_equal(Bgetr (p_ub, (int []){ T_UBF_2_FLD,1,T_UBF_FLD,0,T_UBF_2_FLD,0,BBADFLDOCC}, 
0480             (char *)p_ub_tmp, &len), EXFAIL);
0481     assert_equal(Berror, BNOSPACE);
0482     
0483     len=sizeof(buf_tmp);
0484     assert_equal(Bgetr (p_ub, (int []){ T_UBF_2_FLD,1,T_UBF_FLD,0,T_UBF_2_FLD,0,BBADFLDOCC}, 
0485             (char *)p_ub_tmp, &len), EXSUCCEED);
0486     do_dummy_data_test(p_ub_tmp);
0487     
0488     vf.data=(char *)&v;
0489     len=sizeof(v);
0490     assert_equal(Bgetrv (p_ub, (char *)&vf, &len, 
0491             T_UBF_2_FLD, 1, T_UBF_FLD, 0, T_UBF_2_FLD, 0, T_VIEW_3_FLD, 4, BBADFLDOCC), EXSUCCEED);
0492     assert_equal(v.tlong1, 200);
0493     
0494 }
0495 
0496 Ensure(test_CBgetr)
0497 {
0498     char buf[56000];
0499     char buf_tmp[56000];
0500     long l=0;
0501     BFLDLEN len;
0502     UBFH *p_ub = (UBFH *)buf;
0503     
0504     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0505     load_recursive_data(p_ub);
0506     
0507     /* convert ok */
0508     assert_equal(CBgetr (p_ub, (int []){T_UBF_FLD,0,T_STRING_9_FLD,1,BBADFLDOCC}, 
0509             (char *)&l, NULL, BFLD_LONG), EXSUCCEED);
0510     assert_equal(l, 20);
0511     
0512     /* check no space */
0513     len=1;
0514     assert_equal(CBgetrv (p_ub, (char *)buf_tmp, &len, BFLD_STRING, 
0515             T_UBF_FLD,0,T_UBF_3_FLD,2,T_STRING_9_FLD,3,BBADFLDOCC), EXFAIL);
0516     assert_equal(Berror, BNOSPACE);
0517     
0518     /* check ok */
0519     len=sizeof(buf_tmp);
0520     assert_equal(CBgetrv (p_ub, (char *)buf_tmp, &len, BFLD_STRING, 
0521             T_UBF_FLD,0,T_UBF_3_FLD,2,T_STRING_9_FLD,3,BBADFLDOCC), EXSUCCEED);
0522     assert_string_equal(buf_tmp, "HELLO WORLD UB");
0523     
0524 }
0525 
0526 Ensure(test_CBgetallocr)
0527 {
0528     char buf[56000];
0529     long *l=0;
0530     BFLDLEN extra;
0531     char *ret;
0532     UBFH *p_ub = (UBFH *)buf;
0533     
0534     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0535     load_recursive_data(p_ub);
0536     
0537     /* convert ok */
0538     extra=100;
0539     ret=CBgetallocr (p_ub, (int []){T_UBF_FLD,0,T_STRING_9_FLD,1,BBADFLDOCC}, 
0540             BFLD_LONG, &extra);
0541     assert_not_equal(ret, NULL);
0542     l=(long *)ret;
0543     assert_equal(*l, 20);
0544     assert_equal(extra, sizeof(long));
0545     memset(ret, 0, sizeof(long)+100);
0546     NDRX_FREE(ret);
0547     
0548     /* check with out len */
0549     ret=CBgetallocrv (p_ub,
0550             BFLD_LONG, NULL, T_UBF_FLD,0,T_STRING_9_FLD,1,BBADFLDOCC);
0551     assert_not_equal(ret, NULL);
0552     l=(long *)ret;
0553     assert_equal(*l, 20);
0554     NDRX_FREE(ret);
0555     
0556     /* invalid path */
0557     ret=CBgetallocrv (p_ub,
0558             BFLD_LONG, NULL, BBADFLDOCC);
0559     assert_equal(ret, NULL);
0560     assert_equal(Berror, BBADFLD);
0561     
0562 }
0563 
0564 Ensure(test_Bfindr)
0565 {
0566     char buf[56000];
0567     char *ptr;
0568     BVIEWFLD *vf;
0569     struct UBTESTVIEW2 *v;
0570     BFLDLEN len;
0571     UBFH *p_ub = (UBFH *)buf;
0572     
0573     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0574     load_recursive_data(p_ub);
0575     
0576     /* find value OK with len */
0577     ptr=Bfindrv(p_ub, &len, T_UBF_2_FLD,1,T_UBF_FLD,0,T_UBF_2_FLD,0,T_VIEW_3_FLD,4,BBADFLDOCC);
0578     
0579     assert_not_equal(ptr, NULL);
0580     vf=(BVIEWFLD *)ptr;
0581     v=(struct UBTESTVIEW2 *)vf->data;
0582     
0583     assert_string_equal(vf->vname, "UBTESTVIEW2");
0584     assert_equal(len, sizeof(struct UBTESTVIEW2));
0585     /* check view values... */
0586     assert_string_equal(v->tstring1, "6YY");
0587     
0588     /* check the error handling.. */
0589     ptr=Bfindrv(p_ub, &len, T_UBF_2_FLD,1,T_UBF_FLD,0,T_UBF_2_FLD,0,T_VIEW_3_FLD,10,BBADFLDOCC);
0590     assert_equal(ptr, NULL);
0591     assert_equal(Berror, BNOTPRES);
0592     
0593 }
0594 
0595 Ensure(test_CBfindr)
0596 {
0597     char buf[56000];
0598     char *p;
0599     BFLDLEN len;
0600     long *lv;
0601     UBFH *p_ub = (UBFH *)buf;
0602     
0603     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0604     load_recursive_data(p_ub);
0605     
0606     p=CBfindrv(p_ub, &len, BFLD_LONG, T_UBF_FLD,0,T_STRING_9_FLD,2,BBADFLDOCC);
0607     assert_not_equal(p, NULL);
0608     lv = (long *)p;
0609     assert_equal(*lv, 31);
0610     assert_equal(len, sizeof(long));
0611     
0612     /* check error */
0613     p=CBfindrv(p_ub, &len, BFLD_LONG, T_UBF_FLD,0,T_STRING_9_FLD,1000,BBADFLDOCC);
0614     assert_equal(p, NULL);
0615     assert_equal(Berror, BNOTPRES);
0616 }
0617 
0618 Ensure(test_CBvgetr)
0619 {
0620     char buf[56000];
0621     char buf_tmp[56000];
0622     BFLDLEN len;
0623     UBFH *p_ub = (UBFH *)buf;
0624     
0625     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0626     load_recursive_data(p_ub);
0627     
0628     /* get view field from recursive buffer */
0629     len=sizeof(buf_tmp);
0630     assert_equal(CBvgetrv(p_ub, "tstring0", 2, buf_tmp, &len, BFLD_STRING, 0,
0631             T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXSUCCEED);
0632     assert_string_equal(buf_tmp, "\nABC\n");
0633     
0634     /* check the error */
0635     len=0;
0636     assert_equal(CBvgetrv(p_ub, "tstring0", 2, buf_tmp, &len, BFLD_STRING, 0,
0637             T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXFAIL);
0638     assert_equal(Berror, BNOSPACE);
0639     
0640     /* check type cast */
0641     len=sizeof(buf_tmp);
0642     assert_equal(CBvgetrv(p_ub, "tint2", 1, buf_tmp, &len, BFLD_STRING, 0,
0643             T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXSUCCEED);
0644     assert_string_equal(buf_tmp, "23232");
0645 }
0646 
0647 Ensure(test_CBvgetallocr)
0648 {
0649     char buf[56000];
0650     BFLDLEN len;
0651     UBFH *p_ub = (UBFH *)buf;
0652     char *ret;
0653     BFLDLEN extra;
0654     
0655     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0656     load_recursive_data(p_ub);
0657     
0658     /* get view field from recursive buffer */
0659     extra=100;
0660     ret=CBvgetallocrv(p_ub, "tstring0", 2, BFLD_STRING, 0, &extra,
0661             T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC);
0662             
0663     assert_not_equal(ret, NULL);
0664     assert_string_equal(ret, "\nABC\n");
0665     /* + eos*/
0666     assert_equal(extra, 6);
0667     /* shall not core dump */
0668     memset(ret, 0, 106 );
0669     NDRX_FREE(ret);
0670     
0671     /* check type cast w/o len*/
0672     
0673     ret = CBvgetallocrv(p_ub, "tint2", 1, BFLD_STRING, 0, NULL,
0674             T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC);
0675     assert_not_equal(NULL, ret);
0676     assert_string_equal(ret, "23232");
0677     NDRX_FREE(ret);
0678 }
0679 
0680 Ensure(test_Bvnullr)
0681 {
0682     char buf[56000];
0683     UBFH *p_ub = (UBFH *)buf;
0684     
0685     assert_equal(Binit(p_ub, sizeof(buf)), EXSUCCEED);
0686     load_recursive_data(p_ub);
0687     
0688     /* check null field... */
0689     assert_equal(Bvnullrv(p_ub, "tchar2", 0, T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXTRUE);
0690     assert_equal(Bvnullrv(p_ub, "tchar2", 1, T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXFALSE);
0691     assert_equal(Bvnullrv(p_ub, "tcarray3", 9, T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXTRUE);
0692     
0693     /* check errors */
0694     assert_equal(Bvnullrv(p_ub, "tchar2", 10, T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,1,BBADFLDOCC), EXFAIL);
0695     assert_equal(Berror, BEINVAL);
0696 
0697     /* check unknown view ? */
0698     assert_equal(Bvnullrv(p_ub, "tchar2", 10, T_UBF_2_FLD,1,T_UBF_FLD,0,T_VIEW_FLD,0,BBADFLDOCC), EXFAIL);
0699     assert_equal(Berror, BEINVAL);
0700 }
0701 
0702 /**
0703  * Common suite entry
0704  * @return
0705  */
0706 TestSuite *ubf_embubf_tests(void)
0707 {
0708     TestSuite *suite = create_test_suite();
0709 
0710     std_basic_setup();
0711     
0712     add_test(suite, test_Bgetr);
0713     
0714     add_test(suite, test_CBgetr);
0715     add_test(suite, test_CBgetallocr);
0716     add_test(suite, test_Bfindr);
0717     add_test(suite, test_CBfindr);
0718     add_test(suite, test_CBvgetr);
0719     add_test(suite, test_CBvgetallocr);
0720     add_test(suite, test_Bvnullr);    
0721     return suite;
0722 }
0723 /* vim: set ts=4 sw=4 et smartindent: */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!