Back to home page

Enduro/X
 
 

     

0001 /**
0002  * @brief General purpose *get* testing file
0003  *
0004  * @file test_get.c
0005  */
0006 /* -----------------------------------------------------------------------------
0007  * Enduro/X Middleware Platform for Distributed Transaction Processing
0008  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0009  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0010  * This software is released under one of the following licenses:
0011  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0012  * See LICENSE file for full text.
0013  * -----------------------------------------------------------------------------
0014  * AGPL license:
0015  *
0016  * This program is free software; you can redistribute it and/or modify it under
0017  * the terms of the GNU Affero General Public License, version 3 as published
0018  * by the Free Software Foundation;
0019  *
0020  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0021  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0022  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0023  * for more details.
0024  *
0025  * You should have received a copy of the GNU Affero General Public License along 
0026  * with this program; if not, write to the Free Software Foundation, Inc.,
0027  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0028  *
0029  * -----------------------------------------------------------------------------
0030  * A commercial use license is available from Mavimax, Ltd
0031  * contact@mavimax.com
0032  * -----------------------------------------------------------------------------
0033  */
0034 
0035 
0036 #include <stdio.h>
0037 #include <stdlib.h>
0038 #include <cgreen/cgreen.h>
0039 #include <ubf.h>
0040 #include <ndrstandard.h>
0041 #include <string.h>
0042 #include "test.fd.h"
0043 #include "ubfunit1.h"
0044 
0045 extern void load_find_test_data(UBFH *p_ub);
0046 
0047 void load_get_test_data(UBFH *p_ub)
0048 {
0049     short s = 88;
0050     long l = -1021;
0051     char c = 'c';
0052     float f = 17.31;
0053     double d = 12312.1111;
0054     char carr[] = "CARRAY1 TEST STRING DATA";
0055     BFLDLEN len = strlen(carr);
0056 
0057     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0058     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l, 0), EXSUCCEED);
0059     assert_equal(Bchg(p_ub, T_CHAR_FLD, 0, (char *)&c, 0), EXSUCCEED);
0060     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 0, (char *)&f, 0), EXSUCCEED);
0061     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 0, (char *)&d, 0), EXSUCCEED);
0062     assert_equal(Bchg(p_ub, T_STRING_FLD, 0, (char *)"TEST STR VAL", 0), EXSUCCEED);
0063     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, (char *)carr, len), EXSUCCEED);
0064     
0065     gen_load_ptr(p_ub, 0, 0, 0);
0066     gen_load_ubf(p_ub, 0, 0, 0);
0067     gen_load_view(p_ub, 0, 0, 0);
0068 
0069     /* Make second copy of field data (another for not equal test)*/
0070     s = 88;
0071     l = -1021;
0072     c = '.';
0073     f = 17.31;
0074     d = 12312.1111;
0075     carr[0] = 'Y';
0076     len = strlen(carr);
0077 
0078     assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&s, 0), EXSUCCEED);
0079     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0080     assert_equal(Bchg(p_ub, T_CHAR_FLD, 1, (char *)&c, 0), EXSUCCEED);
0081     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 1, (char *)&f, 0), EXSUCCEED);
0082     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 1, (char *)&d, 0), EXSUCCEED);
0083     assert_equal(Bchg(p_ub, T_STRING_FLD, 1, (char *)"TEST STRING ARRAY2", 0), EXSUCCEED);
0084     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 1, (char *)carr, len), EXSUCCEED);
0085 
0086     gen_load_ptr(p_ub, 1, 1, 0);    
0087     gen_load_ubf(p_ub, 1, 1, 0);
0088     gen_load_view(p_ub, 1, 1, 0);
0089 
0090 
0091     l = 888;
0092     assert_equal(Bchg(p_ub, T_LONG_FLD, 4, (char *)&l, 0), EXSUCCEED);
0093 
0094     s = 212;
0095     l = 212;
0096     c = 'b';
0097     f = 12127;
0098     d = 1231232.1;
0099     carr[0] = 'X';
0100     assert_equal(Bchg(p_ub, T_SHORT_2_FLD, 0, (char *)&s, 0), EXSUCCEED);
0101     assert_equal(Bchg(p_ub, T_LONG_2_FLD, 0, (char *)&l, 0), EXSUCCEED);
0102     assert_equal(Bchg(p_ub, T_CHAR_2_FLD, 0, (char *)&c, 0), EXSUCCEED);
0103     assert_equal(Bchg(p_ub, T_FLOAT_2_FLD, 0, (char *)&f, 0), EXSUCCEED);
0104     assert_equal(Bchg(p_ub, T_DOUBLE_2_FLD, 0, (char *)&d, 0), EXSUCCEED);
0105     assert_equal(Bchg(p_ub, T_STRING_2_FLD, 0, (char *)"XTEST STR VAL", 0), EXSUCCEED);
0106     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 0, (char *)carr, len), EXSUCCEED);
0107     
0108     gen_load_ptr(p_ub, 0, 2, 1);    
0109     gen_load_ubf(p_ub, 0, 2, 1);
0110     gen_load_view(p_ub, 0, 2, 1);
0111     
0112 }
0113 
0114 /**
0115  * Test data used for Bfindlast
0116  * @param p_ub
0117  */
0118 void load_get_test_data_2(UBFH *p_ub)
0119 {
0120     short s = 88;
0121     long l = -1021;
0122     char c = 'c';
0123     float f = 17.31;
0124     double d = 12312.1111;
0125     char carr[] = "CARRAY1 TEST STRING DATA";
0126     BFLDLEN len = strlen(carr);
0127 
0128     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s, 0), EXSUCCEED);
0129     assert_equal(Bchg(p_ub, T_LONG_FLD, 1, (char *)&l, 0), EXSUCCEED);
0130     assert_equal(Bchg(p_ub, T_CHAR_FLD, 2, (char *)&c, 0), EXSUCCEED);
0131     assert_equal(Bchg(p_ub, T_FLOAT_FLD, 3, (char *)&f, 0), EXSUCCEED);
0132     assert_equal(Bchg(p_ub, T_DOUBLE_FLD, 4, (char *)&d, 0), EXSUCCEED);
0133     assert_equal(Bchg(p_ub, T_STRING_FLD, 5, (char *)"TEST STR VAL", 0), EXSUCCEED);
0134     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 6, (char *)carr, len), EXSUCCEED);
0135     
0136     gen_load_ptr(p_ub, 7, 2, 0);    
0137     gen_load_ubf(p_ub, 8, 2, 0);
0138     gen_load_view(p_ub, 9, 2, 0);
0139 
0140 }
0141 
0142 /**
0143  * This simply reads all field and adds them to another buffer, then do compare
0144  */
0145 Ensure(test_cbgetalloc)
0146 {
0147     char fb[2048];
0148     UBFH *p_ub = (UBFH *)fb;
0149     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0150     load_find_test_data(p_ub);
0151     short *s1,*s2,*s3,*s4,*s5,*s6,*s7,*s8,*s9,*s10;
0152     long *l1,*l2,*l3,*l4,*l5,*l6,*l7,*l8,*l9,*l10;
0153     char *c1,*c2,*c3,*c4,*c5,*c6,*c7,*c8,*c9,*c10;
0154     float *f1,*f2,*f3,*f4,*f5,*f6,*f7,*f8,*f9,*f10;
0155     double *d1,*d2,*d3,*d4,*d5,*d6,*d7,*d8,*d9,*d10;
0156     char *str1,*str2,*str3,*str4,*str5,*str6,*str7,*str8,*str9,*str10,*str11;
0157     char *carr1,*carr2,*carr3,*carr4,*carr5,*carr6,*carr7,*carr8,*carr9,*carr10;
0158     ndrx_longptr_t *p1,*p2,*p3,*p4,*p5,*p6,*p7,*p8,*p9,*p10;
0159     
0160     /* not supported modes: */
0161     UBFH *u1;
0162     BVIEWFLD *v1;
0163     char test_blob[5]={'A', 'B', 'C', 0x0, 'D'};
0164     BFLDLEN extra;
0165     BFLDLEN len=0;
0166 
0167     /* Test as short */
0168     assert_not_equal((s1=(short *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_SHORT, 0)), NULL);
0169     assert_not_equal((s2=(short *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_SHORT, 0)), NULL);
0170     assert_not_equal((s3=(short *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_SHORT, 0)), NULL);
0171     assert_not_equal((s4=(short *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_SHORT, 0)), NULL);
0172     assert_not_equal((s5=(short *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_SHORT, 0)), NULL);
0173     assert_not_equal((s6=(short *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_SHORT, 0)), NULL);
0174     assert_not_equal((s7=(short *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_SHORT, 0)), NULL);
0175     assert_not_equal((s8=(short *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_SHORT, 0)), NULL);
0176     assert_equal((s9=(short *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_SHORT, 0)), NULL);
0177     assert_equal(Berror, BEBADOP);
0178     assert_equal((s10=(short *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_SHORT, 0)), NULL);
0179     assert_equal(Berror, BEBADOP);
0180     
0181     assert_equal(*s1, 88);
0182     assert_equal(*s2, -1021);
0183     assert_equal(*s3, 99);
0184     assert_equal(*s4, 17);
0185     assert_equal(*s5, 12312);
0186     assert_equal(*s6, 0);
0187     assert_equal(*s7, 0);
0188     assert_equal(*s8, 9000);
0189 
0190     /* Free up memory */
0191     free(s1);free(s2);free(s3);free(s4);free(s5);free(s6);free(s7);free(s8);
0192 
0193     /* Test as long */
0194     assert_not_equal((l1=(long *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_LONG, 0)), NULL);
0195     assert_not_equal((l2=(long *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_LONG, 0)), NULL);
0196     assert_not_equal((l3=(long *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_LONG, 0)), NULL);
0197     assert_not_equal((l4=(long *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_LONG, 0)), NULL);
0198     assert_not_equal((l5=(long *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_LONG, 0)), NULL);
0199     assert_not_equal((l6=(long *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_LONG, 0)), NULL);
0200     assert_not_equal((l7=(long *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_LONG, 0)), NULL);
0201 
0202     assert_not_equal((l8=(long *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_LONG, 0)), NULL);
0203     assert_equal((l9=(long *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_LONG, 0)), NULL);
0204     assert_equal(Berror, BEBADOP);
0205     assert_equal((l10=(long *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_LONG, 0)), NULL);
0206     assert_equal(Berror, BEBADOP);
0207     
0208     assert_equal(*l1, 88);
0209     assert_equal(*l2, -1021);
0210     assert_equal(*l3, 99);
0211     assert_equal(*l4, 17);
0212     assert_equal(*l5, 12312);
0213     assert_equal(*l6, 0);
0214     assert_equal(*l7, 0);
0215     assert_equal(*l8, 9000);
0216 
0217     free(l1);free(l2);free(l3);free(l4);free(l5);free(l6);free(l7);free(l8);
0218 
0219     /* Test as char */
0220     assert_not_equal((c1=(char *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_CHAR, 0)), NULL);
0221     assert_not_equal((c2=(char *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_CHAR, 0)), NULL);
0222     assert_not_equal((c3=(char *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_CHAR, 0)), NULL);
0223     assert_not_equal((c4=(char *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_CHAR, 0)), NULL);
0224     assert_not_equal((c5=(char *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_CHAR, 0)), NULL);
0225     assert_not_equal((c6=(char *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_CHAR, 0)), NULL);
0226     assert_not_equal((c7=(char *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_CHAR, 0)), NULL);
0227 
0228     assert_not_equal((c8=(char *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_CHAR, 0)), NULL);
0229     assert_equal((c9=(char *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_CHAR, 0)), NULL);
0230     assert_equal(Berror, BEBADOP);
0231     assert_equal((c10=(char *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_CHAR, 0)), NULL);
0232     assert_equal(Berror, BEBADOP);
0233 
0234     assert_equal(*c1, 'X');
0235     assert_equal(*c2, 3); /* may be incorrect due to data size*/
0236     assert_equal(*c3, 'c');
0237     assert_equal(*c4, 17);
0238     assert_equal(*c5, 24); /* May be incorrect dute to data size*/
0239     assert_equal(*c6, 'T');
0240     assert_equal(*c7, 'C');
0241     assert_equal(*c8, 40); /* mod 256 */
0242 
0243     free(c1);free(c2);free(c3);free(c4);free(c5);free(c6);free(c7);free(c8);
0244 
0245     /* Test as float */
0246     assert_not_equal((f1=(float *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_FLOAT, 0)), NULL);
0247     assert_not_equal((f2=(float *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_FLOAT, 0)), NULL);
0248     assert_not_equal((f3=(float *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_FLOAT, 0)), NULL);
0249     assert_not_equal((f4=(float *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_FLOAT, 0)), NULL);
0250     assert_not_equal((f5=(float *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_FLOAT, 0)), NULL);
0251     assert_not_equal((f6=(float *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_FLOAT, 0)), NULL);
0252     assert_not_equal((f7=(float *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_FLOAT, 0)), NULL);
0253 
0254     assert_not_equal((f8=(float *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_FLOAT, 0)), NULL);
0255     assert_equal((f9=(float *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_FLOAT, 0)), NULL);
0256     assert_equal(Berror, BEBADOP);
0257     assert_equal((f10=(float *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_FLOAT, 0)), NULL);
0258     assert_equal(Berror, BEBADOP);
0259     
0260     assert_double_equal(*f1, 88);
0261     assert_double_equal(*f2, -1021);
0262     assert_double_equal(*f3, 99);
0263     assert_double_equal(*f4, 17.31);
0264     assert_double_equal(*f5, 12312.1111);
0265     assert_double_equal(*f6, 0);
0266     assert_double_equal(*f7, 0);
0267     assert_double_equal(*f8, 9000);
0268 
0269     free(f1);free(f2);free(f3);free(f4);free(f5);free(f6);free(f7);free(f8);
0270 
0271     assert_not_equal((d1=(double *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0272     assert_not_equal((d2=(double *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0273     assert_not_equal((d3=(double *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0274     assert_not_equal((d4=(double *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0275     assert_not_equal((d5=(double *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0276     assert_not_equal((d6=(double *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0277     assert_not_equal((d7=(double *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0278 
0279     assert_not_equal((d8=(double *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0280     assert_equal((d9=(double *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0281     assert_equal(Berror, BEBADOP);
0282     assert_equal((d10=(double *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0283     assert_equal(Berror, BEBADOP);
0284     
0285     /* Test as double */
0286     assert_double_equal(*d1, 88);
0287     assert_double_equal(*d2, -1021);
0288     assert_double_equal(*d3, 99);
0289     assert_double_equal(*d4, 17.31);
0290     assert_double_equal(*d5, 12312.1111);
0291     assert_double_equal(*d6, 0);
0292     assert_double_equal(*d7, 0);
0293     assert_double_equal(*d8, 9000);
0294 
0295     free(d1);free(d2);free(d3);free(d4);free(d5);free(d6);free(d7);free(d8);
0296 
0297     /* Test as string */
0298     assert_not_equal((str1=CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_STRING, 0)), NULL);
0299     assert_not_equal((str2=CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_STRING, 0)), NULL);
0300     assert_not_equal((str3=CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_STRING, 0)), NULL);
0301     assert_not_equal((str4=CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_STRING, 0)), NULL);
0302     assert_not_equal((str5=CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_STRING, 0)), NULL);
0303     assert_not_equal((str6=CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_STRING, 0)), NULL);
0304     assert_not_equal((str7=CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_STRING, 0)), NULL);
0305     assert_not_equal((str8=CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_STRING, 0)), NULL);
0306     assert_equal((str9=CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_STRING, 0)), NULL);
0307     assert_equal(Berror, BEBADOP);
0308     assert_equal((str10=CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_STRING, 0)), NULL);
0309     assert_equal(Berror, BEBADOP);
0310 
0311     /* Bug #666 return correctly terminated carray */
0312     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 3, (char *)test_blob, 5), EXSUCCEED);
0313     extra=100;
0314     assert_not_equal((str11=CBgetalloc(p_ub, T_CARRAY_FLD, 3, BFLD_STRING, &extra)), NULL);
0315     
0316     assert_string_equal(str1, "88");
0317     assert_string_equal(str2, "-1021");
0318     assert_string_equal(str3, "c");
0319     assert_equal(strncmp(str4, "17.3", 4), 0);
0320     assert_equal(strncmp(str5, "12312.1111", 10), 0);
0321     assert_string_equal(str6, "TEST STR VAL");
0322     assert_string_equal(str7, "CARRAY1 TEST STRING DATA");
0323     assert_string_equal(str8, "0x2328");
0324     /* Bug #666 fix: */
0325     assert_string_equal(str11, "ABC");
0326     assert_equal(extra, 4);
0327 
0328     free(str1);free(str2);free(str3);free(str4);free(str5);free(str6);free(str7);free(str8);free(str11);
0329 
0330     /* Test as carray */
0331     assert_not_equal((carr1=CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_CARRAY, 0)), NULL);
0332     assert_not_equal((carr2=CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_CARRAY, 0)), NULL);
0333     assert_not_equal((carr3=CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_CARRAY, 0)), NULL);
0334     assert_not_equal((carr4=CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_CARRAY, 0)), NULL);
0335     assert_not_equal((carr5=CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_CARRAY, 0)), NULL);
0336     assert_not_equal((carr6=CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_CARRAY, 0)), NULL);
0337     assert_not_equal((carr7=CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_CARRAY, 0)), NULL);
0338     
0339     assert_not_equal((carr8=CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_CARRAY, 0)), NULL);
0340     assert_equal((carr9=CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_CARRAY, 0)), NULL);
0341     assert_equal(Berror, BEBADOP);
0342     assert_equal((carr10=CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_CARRAY, 0)), NULL);
0343     assert_equal(Berror, BEBADOP);
0344 
0345     assert_equal(strncmp(carr1, "88", 2), 0);
0346     assert_equal(strncmp(carr2, "-1021", 5), 0);
0347     assert_equal(strncmp(carr3, "c", 1), 0);
0348     assert_equal(strncmp(carr4, "17.3", 4), 0);
0349     assert_equal(strncmp(carr5, "12312.1111", 10), 0);
0350     assert_equal(strncmp(carr6, "TEST STR VAL", 12), 0);
0351     assert_equal(strncmp(carr7, "CARRAY1 TEST STRING DATA", 24), 0);
0352     assert_equal(strncmp(carr8, "0x2328", 6), 0);
0353 
0354     free(carr1);free(carr2);free(carr3);free(carr4);free(carr5);free(carr6);free(carr7);free(carr8);
0355     
0356     /* Check ptr */
0357     
0358     assert_not_equal((p1=(ndrx_longptr_t *)CBgetalloc(p_ub, T_SHORT_FLD, 0, BFLD_PTR, 0)), NULL);
0359     assert_not_equal((p2=(ndrx_longptr_t *)CBgetalloc(p_ub, T_LONG_FLD, 0, BFLD_PTR, 0)), NULL);
0360     assert_not_equal((p3=(ndrx_longptr_t *)CBgetalloc(p_ub, T_CHAR_FLD, 0, BFLD_PTR, 0)), NULL);
0361     assert_not_equal((p4=(ndrx_longptr_t *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_PTR, 0)), NULL);
0362     assert_not_equal((p5=(ndrx_longptr_t *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_PTR, 0)), NULL);
0363     
0364     /* these will not parse: */
0365     assert_not_equal((p6=(ndrx_longptr_t *)CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_PTR, 0)), NULL);
0366     assert_not_equal((p7=(ndrx_longptr_t *)CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_PTR, 0)), NULL);
0367 
0368     assert_not_equal((p8=(ndrx_longptr_t *)CBgetalloc(p_ub, T_PTR_FLD, 0, BFLD_PTR, 0)), NULL);
0369     assert_equal((p9=(ndrx_longptr_t *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_PTR, 0)), NULL);
0370     assert_equal(Berror, BEBADOP);
0371     assert_equal((p10=(ndrx_longptr_t *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_PTR, 0)), NULL);
0372     assert_equal(Berror, BEBADOP);
0373     
0374     assert_equal(*p1, 88);
0375     assert_equal(*p2, -1021);
0376     assert_equal(*p3, 99);
0377     assert_equal(*p4, 17);
0378     assert_equal(*p5, 12312);
0379     assert_equal(*p6, 0);
0380     assert_equal(*p7, 0);
0381     assert_equal(*p8, 9000);
0382 
0383     free(p1);free(p2);free(p3);free(p4);free(p5);free(p6);free(p7);free(p8);
0384     
0385     /* Check ubf */
0386     assert_equal((u1=(UBFH *)CBgetalloc(p_ub, T_UBF_FLD, 0, BFLD_UBF, 0)), NULL);
0387     assert_equal(Berror, BEBADOP);
0388     
0389     /* Check view */
0390     assert_equal((v1=(BVIEWFLD *)CBgetalloc(p_ub, T_VIEW_FLD, 0, BFLD_VIEW, 0)), NULL);
0391     assert_equal(Berror, BEBADOP);
0392 
0393     /* Now test the thing that we have different pointers for each of the data type
0394      * also fields will cross match their types.
0395      */
0396     assert_not_equal((s1=(short *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_SHORT, 0)), NULL);
0397     assert_not_equal((l1=(long *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_LONG, 0)), NULL);
0398     assert_not_equal((c1=(char *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_CHAR, 0)), NULL);
0399     assert_not_equal((f1=(float *)CBgetalloc(p_ub, T_DOUBLE_FLD, 0, BFLD_FLOAT, 0)), NULL);
0400     assert_not_equal((d1=(double *)CBgetalloc(p_ub, T_FLOAT_FLD, 0, BFLD_DOUBLE, 0)), NULL);
0401     assert_not_equal((str1=CBgetalloc(p_ub, T_CARRAY_FLD, 0, BFLD_STRING, 0)), NULL);
0402     len=1024; /* allocate extra buffer also! */
0403     assert_not_equal((carr1=CBgetalloc(p_ub, T_STRING_FLD, 0, BFLD_CARRAY, &len)), NULL);
0404 
0405     /* Now compare the values */
0406     assert_equal(*s1, 17);
0407     assert_equal(*l1, 12312);
0408     assert_equal(*c1, 17);
0409     assert_double_equal(*f1, 12312.1111);
0410     assert_double_equal(*d1, 17.31);
0411     assert_string_equal(str1, "CARRAY1 TEST STRING DATA");
0412     assert_equal(len, 12);
0413     assert_equal(strncmp(carr1, "TEST STR VAL", len), 0);
0414 
0415     /* test that allocated buffer is using extra size! */
0416     strcpy(carr1, BIG_TEST_STRING);
0417     assert_equal(strcmp(carr1, BIG_TEST_STRING), 0);
0418 
0419     free(s1);free(l1);free(c1);free(f1);free(d1);free(str1);free(carr1);
0420 
0421     /* Now test the error case, when field is not found? */
0422     len = 0;
0423     assert_equal(CBgetalloc(p_ub, T_FLOAT_FLD, 10, BFLD_SHORT, &len), NULL);
0424     assert_equal(Berror, BNOTPRES);
0425 
0426     /* try to get data from other occurrance */
0427     assert_double_equal(*(d1=(double *)CBgetalloc(p_ub, T_LONG_FLD, 4, BFLD_DOUBLE, 0)), 888);
0428 
0429     /* Now play with big buffer data */
0430     assert_equal(Bchg(p_ub, T_CARRAY_2_FLD, 4, BIG_TEST_STRING, strlen(BIG_TEST_STRING)),EXSUCCEED);
0431     /* now match the string */
0432     assert_string_equal((str1=CBgetalloc(p_ub, T_CARRAY_2_FLD, 4, BFLD_STRING, 0)), BIG_TEST_STRING);
0433     free(d1);free(str1);
0434 }
0435 
0436 
0437 #define BGETALLOC_TEST_17      16384
0438 
0439 /**
0440  * Test Bgetalloc
0441  */
0442 Ensure(test_bgetalloc)
0443 {
0444     char fb[BGETALLOC_TEST_17+1024];
0445     UBFH *p_ub = (UBFH *)fb;
0446     short *s1;
0447     long *l1;
0448     char *c1;
0449     float *f1;
0450     double *d1;
0451     char *str1;
0452     char *carr1;
0453     char test17[BGETALLOC_TEST_17]; /* have some random memory data. */
0454     BFLDLEN len=0;
0455     ndrx_longptr_t *p1;
0456     BVIEWFLD *v1;
0457     UBFH *u1;
0458     
0459     randomize_test_data(test17, sizeof(test17));
0460 
0461     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0462     load_get_test_data(p_ub);
0463 
0464     /* Test as short */
0465     assert_not_equal((s1=(short *)Bgetalloc(p_ub, T_SHORT_FLD, 0, 0)), NULL);
0466     assert_equal(*s1, 88);
0467     /* Free up memory */
0468     free(s1);
0469 
0470     /* Test as long */
0471     assert_not_equal((l1=(long *)Bgetalloc(p_ub, T_LONG_FLD, 0, 0)), NULL);
0472     assert_equal(*l1, -1021);
0473 
0474     free(l1);
0475 
0476      /* Test as char */
0477     assert_not_equal((c1=(char *)Bgetalloc(p_ub, T_CHAR_FLD, 0, 0)), NULL);
0478     assert_equal(*c1, 'c');
0479 
0480     free(c1);
0481 
0482     /* Test as float */
0483     assert_not_equal((f1=(float *)Bgetalloc(p_ub, T_FLOAT_FLD, 0, 0)), NULL);
0484 
0485     assert_double_equal(*f1, 17.31);
0486 
0487     free(f1);
0488 
0489     /* Test as double */
0490     assert_not_equal((d1=(double *)Bgetalloc(p_ub, T_DOUBLE_FLD, 0, 0)), NULL);
0491 
0492     assert_double_equal(*d1, 12312.1111);
0493 
0494     free(d1);
0495 
0496     /* Test as string */
0497     assert_not_equal((str1=Bgetalloc(p_ub, T_STRING_FLD, 0, 0)), NULL);
0498     assert_string_equal(str1, "TEST STR VAL");
0499     free(str1);
0500 
0501     /* Test as carray */
0502     len = 1000;
0503     assert_not_equal((carr1=Bgetalloc(p_ub, T_CARRAY_FLD, 0, &len)), NULL);
0504     assert_equal(len, 24);
0505     assert_equal(strncmp(carr1, "CARRAY1 TEST STRING DATA", 24), 0);
0506 
0507     strcpy(carr1, BIG_TEST_STRING);
0508     assert_equal(strcmp(carr1, BIG_TEST_STRING), 0);
0509 
0510     free(carr1);
0511     
0512     /* test as ptr */
0513     len=100;
0514     assert_not_equal((p1=(ndrx_longptr_t *)Bgetalloc(p_ub, T_PTR_FLD, 0, &len)), NULL);
0515     gen_test_ptr_val_dbg(__FILE__, __LINE__, *p1,  0, &len);
0516     free(p1);
0517     
0518     /* test as ubf */
0519     len=100;
0520     assert_not_equal((u1=(UBFH *)Bgetalloc(p_ub, T_UBF_FLD, 0, &len)), NULL);
0521     gen_test_ubf_val_dbg(__FILE__, __LINE__, u1,  0, &len);
0522     
0523     /* check memory access beyond the data size */
0524     memset((char *)u1+len, 255, 100);
0525     free(u1);
0526     
0527     /* test as view */
0528     len=100;
0529     assert_not_equal((v1=(BVIEWFLD *)Bgetalloc(p_ub, T_VIEW_FLD, 0, &len)), NULL);
0530     gen_test_view_val_dbg(__FILE__, __LINE__, v1,  0, &len);
0531     memset((char *)v1+len, 255, 100);
0532     free(v1);
0533 
0534     /* Test the case when data is not found! */
0535     assert_equal((str1=Bgetalloc(p_ub, T_STRING_FLD, 20, 0)), NULL);
0536     assert_equal(Berror, BNOTPRES);
0537     assert_equal((str1=Bgetalloc(p_ub, T_STRING_FLD, 21, 0)), NULL);
0538     assert_equal(Berror, BNOTPRES);
0539     assert_equal((str1=Bgetalloc(p_ub, T_STRING_FLD, 22, 0)), NULL);
0540     assert_equal(Berror, BNOTPRES);
0541     assert_equal((str1=Bgetalloc(p_ub, T_STRING_FLD, 23, 0)), NULL);
0542     assert_equal(Berror, BNOTPRES);
0543     
0544     /* Test case for http://www.endurox.org/issues/17 */
0545     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0546     len = BGETALLOC_TEST_17;
0547     assert_equal(Bchg(p_ub, T_CARRAY_FLD, 0, test17, len), EXSUCCEED);
0548     assert_not_equal((carr1=Bgetalloc(p_ub, T_CARRAY_FLD, 0, &len)), NULL);
0549     assert_equal(len, BGETALLOC_TEST_17);
0550     assert_equal(memcmp(test17, carr1, BGETALLOC_TEST_17), 0);
0551     free(carr1);
0552     
0553 }
0554 
0555 /**
0556  * Test Bgetlast
0557  */
0558 Ensure(test_bgetlast)
0559 {
0560     char fb[2048];
0561     UBFH *p_ub = (UBFH *)fb;
0562     short s1;
0563     long l1;
0564     char c1;
0565     float f1;
0566     double d1;
0567     char str1[64];
0568     char carr1[64];
0569     BFLDLEN len;
0570     BFLDOCC occ;
0571     ndrx_longptr_t p1;
0572     struct UBTESTVIEW2 vdata;
0573     BVIEWFLD v1;
0574     char tmp[1024];
0575     UBFH *u1=(UBFH *)tmp;
0576 
0577     assert_equal(Binit(u1, sizeof(tmp)), EXSUCCEED);
0578     
0579     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0580     load_get_test_data_2(p_ub);
0581 
0582     /* Test as short */
0583     occ=-1;
0584     assert_not_equal(Bgetlast(p_ub, T_SHORT_FLD, &occ, (char *)&s1, 0), EXFAIL);
0585     assert_equal(s1, 88);
0586     assert_equal(occ, 0);
0587 
0588     /* Test as long */
0589     occ=-1;
0590     assert_not_equal(Bgetlast(p_ub, T_LONG_FLD, &occ, (char *)&l1, 0), EXFAIL);
0591     assert_equal(l1, -1021);
0592     assert_equal(occ, 1);
0593 
0594      /* Test as char */
0595     occ=-1;
0596     assert_not_equal(Bgetlast(p_ub, T_CHAR_FLD, &occ, (char *)&c1, 0), EXFAIL);
0597     assert_equal(c1, 'c');
0598     assert_equal(occ, 2);
0599 
0600     /* Test as float */
0601     occ=-1;
0602     assert_not_equal(Bgetlast(p_ub, T_FLOAT_FLD, &occ, (char *)&f1, 0), EXFAIL);
0603     assert_double_equal(f1, 17.31);
0604     assert_equal(occ, 3);
0605 
0606     /* Test as double */
0607     occ=-1;
0608     assert_not_equal(Bgetlast(p_ub, T_DOUBLE_FLD, &occ, (char *)&d1, 0), EXFAIL);
0609     assert_double_equal(d1, 12312.1111);
0610     assert_equal(occ, 4);
0611 
0612     /* Test as string */
0613     occ=-1;
0614     assert_not_equal(Bgetlast(p_ub, T_STRING_FLD, &occ, str1, 0), EXFAIL);
0615     assert_string_equal(str1, "TEST STR VAL");
0616     assert_equal(occ, 5);
0617 
0618     /* Test as carray */
0619     len = sizeof(carr1);
0620     occ=-1;
0621     assert_not_equal(Bgetlast(p_ub, T_CARRAY_FLD, &occ, carr1, &len), EXFAIL);
0622     assert_equal(len, 24);
0623     assert_equal(strncmp(carr1, "CARRAY1 TEST STRING DATA", 24), 0);
0624     assert_equal(occ, 6);
0625     
0626     
0627     /* test as ptr */
0628     occ=-1;
0629     assert_not_equal(Bgetlast(p_ub, T_PTR_FLD, &occ, (char *)&p1, &len), EXFAIL);
0630     assert_equal(occ, 7);
0631     gen_test_ptr_val_dbg(__FILE__, __LINE__, p1, 2, &len);
0632     
0633     /* test as ubf */
0634     occ=-1;
0635     len=sizeof(tmp);
0636     assert_not_equal(Bgetlast(p_ub, T_UBF_FLD, &occ, (char *)u1, &len), EXFAIL);
0637     assert_equal(occ, 8);
0638     gen_test_ubf_val_dbg(__FILE__, __LINE__, u1,  2, &len);
0639     
0640     /* test as view */
0641     v1.data=(char *)&vdata;
0642     occ=-1;
0643     len=sizeof(vdata);
0644     assert_not_equal(Bgetlast(p_ub, T_VIEW_FLD, &occ, (char *)&v1, &len), EXFAIL);
0645     assert_equal(occ, 9);
0646     gen_test_view_val_dbg(__FILE__, __LINE__, &v1,  2, &len);
0647     
0648     /* Test the case when data is not found! */
0649     occ=-1;
0650     assert_equal(Bgetlast(p_ub, T_STRING_2_FLD, &occ, str1, 0), EXFAIL);
0651     assert_equal(Berror, BNOTPRES);
0652     assert_equal(occ, -1);
0653 }
0654 
0655 
0656 /**
0657  * Test Test cached fields
0658  */
0659 Ensure(test_cached_flds)
0660 {
0661     char fb[1024];
0662     UBFH *p_ub = (UBFH *)fb;
0663     short s1;
0664     long l1;
0665 
0666     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0667 
0668     s1 = 144;
0669     
0670     assert_equal(Bchg(p_ub, T_SHORT_FLD, 0, (char *)&s1, 0), EXSUCCEED);
0671     assert_equal(Bchg(p_ub, T_SHORT_FLD, 1, (char *)&s1, 0), EXSUCCEED);
0672     assert_equal(Bchg(p_ub, T_SHORT_FLD, 2, (char *)&s1, 0), EXSUCCEED);
0673     
0674     assert_equal(Boccur(p_ub, T_SHORT_FLD), 3);
0675     assert_equal(Bdel(p_ub, T_SHORT_FLD, 2), EXSUCCEED);
0676     
0677     assert_equal(Boccur(p_ub, T_SHORT_FLD), 2);
0678     assert_equal(Bdel(p_ub, T_SHORT_FLD, 1), EXSUCCEED);
0679     
0680     assert_equal(Boccur(p_ub, T_SHORT_FLD), 1);
0681     assert_equal(Bdel(p_ub, T_SHORT_FLD, 0), EXSUCCEED);
0682     
0683     
0684     assert_equal(Binit(p_ub, sizeof(fb)), EXSUCCEED);
0685 
0686     l1 = 144;
0687     
0688     assert_equal(Bchg(p_ub, T_LONG_FLD, 0, (char *)&l1, 0), EXSUCCEED);
0689     assert_equal(Bdel(p_ub, T_LONG_FLD, 0), EXSUCCEED);
0690     assert_equal(Boccur(p_ub, T_LONG_FLD), 0);
0691         
0692 }
0693 
0694 TestSuite *ubf_get_tests(void)
0695 {
0696     TestSuite *suite = create_test_suite();
0697 
0698     add_test(suite, test_cbgetalloc);
0699     add_test(suite, test_bgetalloc);
0700     add_test(suite, test_bgetlast);
0701     
0702     add_test(suite, test_cached_flds);
0703 
0704     return suite;
0705 }
0706 /* 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!