source/ubftest/test_genbuf.c

0001 /**
0002  *
0003  * @file test_genbuf.c
0004  */
0005 /* -----------------------------------------------------------------------------
0006  * Enduro/X Middleware Platform for Distributed Transaction Processing
0007  * Copyright (C) 2009-2016, ATR Baltic, Ltd. All Rights Reserved.
0008  * Copyright (C) 2017-2023, Mavimax, Ltd. All Rights Reserved.
0009  * This software is released under one of the following licenses:
0010  * AGPL (with Java and Go exceptions) or Mavimax's license for commercial use.
0011  * See LICENSE file for full text.
0012  * -----------------------------------------------------------------------------
0013  * AGPL license:
0014  *
0015  * This program is free software; you can redistribute it and/or modify it under
0016  * the terms of the GNU Affero General Public License, version 3 as published
0017  * by the Free Software Foundation;
0018  *
0019  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
0020  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
0021  * PARTICULAR PURPOSE. See the GNU Affero General Public License, version 3
0022  * for more details.
0023  *
0024  * You should have received a copy of the GNU Affero General Public License along
0025  * with this program; if not, write to the Free Software Foundation, Inc.,
0026  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0027  *
0028  * -----------------------------------------------------------------------------
0029  * A commercial use license is available from Mavimax, Ltd
0030  * contact@mavimax.com
0031  * -----------------------------------------------------------------------------
0032  */
0033
0034 #include <stdio.h>
0035 #include <stdlib.h>
0036 #include <cgreen/cgreen.h>
0037 #include <ubf.h>
0038 #include <ndrstandard.h>
0039 #include <string.h>
0040 #include "test.fd.h"
0041 #include "ubfunit1.h"
0042 #include "fdatatype.h"
0043
0044 /**
0045  * Bcpy tests.
0046  */
0047 Ensure(test_Bcpy)
0048 {
0049     char buf1[1550];
0050     char buf2[200];
0051     char data_buf[480];
0052
0053     BFLDLEN len;
0054     UBFH *p_ub_src = (UBFH *)buf1;
0055     UBFH *p_ub_dst = (UBFH *)buf2;
0056
0057     assert_equal(Binit(p_ub_src, sizeof(buf1)), EXSUCCEED);
0058     assert_equal(Binit(p_ub_dst, sizeof(buf2)), EXSUCCEED);
0059
0060     /* Having no data it should copy OK */
0061     assert_equal(Bcpy(p_ub_dst, p_ub_src), EXSUCCEED);
0062     /* Set up some 300 bytes */
0063     len = sizeof(buf2);
0064     assert_equal(CBchg(p_ub_src, T_CARRAY_FLD, 0, data_buf, sizeof(data_buf), BFLD_CARRAY), EXSUCCEED);
0065
0066     /* Now copy should fail, because of no space in buffer! */
0067     assert_equal_with_message(Bcpy(p_ub_dst, p_ub_src), EXFAIL, "Dest have no space!");
0068 }
0069
0070 /**
0071  * Test user type conversation function
0072  * which dynamically allocates the buffer.
0073  */
0074 Ensure(test_btypcvt)
0075 {
0076     BFLDLEN len;
0077     short s=-11;
0078     long l=111;
0079     char c='3';
0080     float f=1.33341;
0081     double d=5547;
0082     char *p;
0083     ndrx_longptr_t ptr;
0084     char tmp[128];
0085
0086     /* Convert to short validation */
0087     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&s, BFLD_SHORT, 0)), NULL);
0088     assert_equal(*((short *)p), -11);
0089     free(p);
0090     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&l, BFLD_LONG, 0)), NULL);
0091     assert_equal(*((short *)p), 111);
0092     free(p);
0093     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&c, BFLD_CHAR, 0)), NULL);
0094     assert_equal(*((short *)p), 51);
0095     free(p);
0096     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&f, BFLD_FLOAT, 0)), NULL);
0097     assert_equal(*((short *)p), 1);
0098     free(p);
0099     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0100     assert_equal(*((short *)p), 5547);
0101     free(p);
0102     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)"12701", BFLD_STRING, 0)), NULL);
0103     assert_equal(*((short *)p), 12701);
0104     assert_equal(len, 2);
0105     free(p);
0106     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)"12801", BFLD_CARRAY, 5)), NULL);
0107     assert_equal(*((short *)p), 12801);
0108     free(p);
0109
0110     ptr=66;
0111     assert_not_equal((p=Btypcvt(&len, BFLD_SHORT, (char *)&ptr, BFLD_PTR, 0)), NULL);
0112     assert_equal(*((short *)p), 66);
0113     free(p);
0114
0115     assert_equal(Btypcvt(&len, BFLD_SHORT, (char *)&ptr, BFLD_UBF, 0), NULL);
0116     assert_equal(Berror, BEBADOP);
0117
0118     assert_equal(Btypcvt(&len, BFLD_SHORT, (char *)&ptr, BFLD_VIEW, 0), NULL);
0119     assert_equal(Berror, BEBADOP);
0120
0121
0122     /* Convert to long validation */
0123     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&s, BFLD_SHORT, 0)), NULL);
0124     assert_equal(*((long *)p), -11);
0125     free(p);
0126     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&l, BFLD_LONG, 0)), NULL);
0127     assert_equal(*((long *)p), 111);
0128     free(p);
0129     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&c, BFLD_CHAR, 0)), NULL);
0130     assert_equal(*((long *)p), 51);
0131     free(p);
0132     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&f, BFLD_FLOAT, 0)), NULL);
0133     assert_equal(*((long *)p), 1);
0134     free(p);
0135     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0136     assert_equal(*((long *)p), 5547);
0137     free(p);
0138     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)"12701123", BFLD_STRING, 0)), NULL);
0139     assert_equal(*((long *)p), 12701123);
0140     /* fix for 32bit system */
0141     if (sizeof(long)==8)
0142         assert_equal(len, 8);
0143     else
0144         assert_equal(len, 4);
0145
0146     free(p);
0147     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)"12801123", BFLD_CARRAY, 8)), NULL);
0148     assert_equal(*((long *)p), 12801123);
0149     free(p);
0150
0151     ptr=66;
0152     assert_not_equal((p=Btypcvt(&len, BFLD_LONG, (char *)&ptr, BFLD_PTR, 0)), NULL);
0153     assert_equal(*((long *)p), 66);
0154     free(p);
0155
0156     assert_equal(Btypcvt(&len, BFLD_LONG, (char *)&ptr, BFLD_UBF, 0), NULL);
0157     assert_equal(Berror, BEBADOP);
0158
0159     assert_equal(Btypcvt(&len, BFLD_LONG, (char *)&ptr, BFLD_VIEW, 0), NULL);
0160     assert_equal(Berror, BEBADOP);
0161
0162     /* Convert to char validation */
0163     s=111;
0164     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&s, BFLD_SHORT, 0)), NULL);
0165     assert_equal(*((char *)p), 'o');
0166     free(p);
0167     s=-11;
0168
0169     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&l, BFLD_LONG, 0)), NULL);
0170     assert_equal(*((char *)p), 'o');
0171     free(p);
0172     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&c, BFLD_CHAR, 0)), NULL);
0173     assert_equal(*((char *)p), '3');
0174     free(p);
0175     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&f, BFLD_FLOAT, 0)), NULL);
0176     assert_equal(*((char *)p), 1);
0177     free(p);
0178     d=47;
0179     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0180     assert_equal(*((char *)p), '/');
0181     d=5547;
0182     free(p);
0183     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)"abc", BFLD_STRING, 0)), NULL);
0184     assert_equal(*((char *)p), 'a');
0185     assert_equal(len, 1);
0186     free(p);
0187     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)"cde", BFLD_CARRAY, 8)), NULL);
0188     assert_equal(*((char *)p), 'c');
0189     free(p);
0190
0191     ptr=66;
0192     assert_not_equal((p=Btypcvt(&len, BFLD_CHAR, (char *)&ptr, BFLD_PTR, 0)), NULL);
0193     assert_equal(*((char *)p), 66);
0194     free(p);
0195
0196     assert_equal(Btypcvt(&len, BFLD_CHAR, (char *)&ptr, BFLD_UBF, 0), NULL);
0197     assert_equal(Berror, BEBADOP);
0198
0199     assert_equal(Btypcvt(&len, BFLD_CHAR, (char *)&ptr, BFLD_VIEW, 0), NULL);
0200     assert_equal(Berror, BEBADOP);
0201
0202
0203
0204     /* Convert to float validation */
0205     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&s, BFLD_SHORT, 0)), NULL);
0206     assert_double_equal(*((float *)p), -11);
0207     free(p);
0208     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&l, BFLD_LONG, 0)), NULL);
0209     assert_double_equal(*((float *)p), 111);
0210     free(p);
0211     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&c, BFLD_CHAR, 0)), NULL);
0212     assert_double_equal(*((float *)p), 51);
0213     free(p);
0214     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&f, BFLD_FLOAT, 0)), NULL);
0215     assert_double_equal(*((float *)p), 1.33341);
0216     free(p);
0217     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0218     assert_double_equal(*((float *)p), 5547);
0219     free(p);
0220     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)"12701.1", BFLD_STRING, 0)), NULL);
0221     assert_double_equal(*((float *)p), 12701.1);
0222     assert_equal(len, 4);
0223     free(p);
0224     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)"128.1", BFLD_CARRAY, 5)), NULL);
0225     assert_double_equal(*((float *)p), 128.1);
0226     free(p);
0227
0228     ptr=66;
0229     assert_not_equal((p=Btypcvt(&len, BFLD_FLOAT, (char *)&ptr, BFLD_PTR, 0)), NULL);
0230     assert_double_equal(*((float *)p), (float)66);
0231     free(p);
0232
0233     assert_equal(Btypcvt(&len, BFLD_FLOAT, (char *)&ptr, BFLD_UBF, 0), NULL);
0234     assert_equal(Berror, BEBADOP);
0235
0236     assert_equal(Btypcvt(&len, BFLD_FLOAT, (char *)&ptr, BFLD_VIEW, 0), NULL);
0237     assert_equal(Berror, BEBADOP);
0238
0239
0240     /* Convert to double validation */
0241     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&s, BFLD_SHORT, 0)), NULL);
0242     assert_double_equal(*((double *)p), -11);
0243     free(p);
0244     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&l, BFLD_LONG, 0)), NULL);
0245     assert_double_equal(*((double *)p), 111);
0246     free(p);
0247     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&c, BFLD_CHAR, 0)), NULL);
0248     assert_double_equal(*((double *)p), 51);
0249     free(p);
0250     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&f, BFLD_FLOAT, 0)), NULL);
0251     assert_double_equal(*((double *)p), 1.33341);
0252     free(p);
0253     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0254     assert_double_equal(*((double *)p), 5547);
0255     free(p);
0256     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)"12701.1", BFLD_STRING, 0)), NULL);
0257     assert_double_equal(*((double *)p), 12701.1);
0258     assert_equal(len, 8);
0259     free(p);
0260     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)"128.1", BFLD_CARRAY, 5)), NULL);
0261     assert_double_equal(*((double *)p), 128.1);
0262     free(p);
0263
0264     ptr=66;
0265     assert_not_equal((p=Btypcvt(&len, BFLD_DOUBLE, (char *)&ptr, BFLD_PTR, 0)), NULL);
0266     assert_double_equal(*((double *)p), 66);
0267     free(p);
0268
0269     assert_equal(Btypcvt(&len, BFLD_DOUBLE, (char *)&ptr, BFLD_UBF, 0), NULL);
0270     assert_equal(Berror, BEBADOP);
0271
0272     assert_equal(Btypcvt(&len, BFLD_DOUBLE, (char *)&ptr, BFLD_VIEW, 0), NULL);
0273     assert_equal(Berror, BEBADOP);
0274
0275
0276     /* Convert to string validation */
0277     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&s, BFLD_SHORT, 0)), "-11");
0278     free(p);
0279     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&l, BFLD_LONG, 0)), "111");
0280     free(p);
0281     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&c, BFLD_CHAR, 0)), "3");
0282     free(p);
0283     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&f, BFLD_FLOAT, 0)), "1.33341");
0284     free(p);
0285     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&d, BFLD_DOUBLE, 0)), "5547.000000");
0286     free(p);
0287     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)"TEST STRING", BFLD_STRING, 0)), "TEST STRING");
0288     free(p);
0289     assert_string_equal((p=Btypcvt(&len, BFLD_STRING, (char *)"TEST CARRAY", BFLD_CARRAY, 11)), "TEST CARRAY");
0290     free(p);
0291
0292     ptr=66;
0293     assert_not_equal((p=Btypcvt(&len, BFLD_STRING, (char *)&ptr, BFLD_PTR, 0)), NULL);
0294
0295     /* check the output format 0x.... ? */
0296     snprintf(tmp, sizeof(tmp), "0x" NDRX_LONGPTR_HEX, (ndrx_longptr_t)66);
0297     assert_equal(len, strlen(tmp)+1);
0298
0299     assert_string_equal(p, tmp);
0300     free(p);
0301
0302     assert_equal(Btypcvt(&len, BFLD_STRING, (char *)&ptr, BFLD_UBF, 0), NULL);
0303     assert_equal(Berror, BEBADOP);
0304
0305     assert_equal(Btypcvt(&len, BFLD_STRING, (char *)&ptr, BFLD_VIEW, 0), NULL);
0306     assert_equal(Berror, BEBADOP);
0307
0308
0309     /* Convert to string validation */
0310     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&s, BFLD_SHORT, 0)), NULL);
0311     assert_equal(strncmp(p, "-11", 3), 0);
0312     free(p);
0313     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&l, BFLD_LONG, 0)), NULL);
0314     assert_equal(strncmp(p, "111", 3), 0);
0315     free(p);
0316     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&c, BFLD_CHAR, 0)), NULL);
0317     assert_equal(strncmp(p, "3", 1), 0);
0318     free(p);
0319     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&f, BFLD_FLOAT, 0)), NULL);
0320     assert_equal(strncmp(p, "1.33341", 7), 0);
0321     free(p);
0322     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0323     assert_equal(strncmp(p, "5547.000000", 11), 0);
0324     free(p);
0325     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)"TEST STRING", BFLD_STRING, 0)), NULL);
0326     assert_equal(strncmp(p, "TEST STRING", 11), 0);
0327     free(p);
0328     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)"TEST CARRAY", BFLD_CARRAY, 11)), NULL);
0329     assert_equal(strncmp(p, "TEST CARRAY", 11), 0);
0330     assert_equal(len, 11);
0331     free(p);
0332
0333     ptr=66;
0334     assert_not_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)&ptr, BFLD_PTR, 0)), NULL);
0335
0336     /* check the output format 0x.... ? */
0337     snprintf(tmp, sizeof(tmp), "0x" NDRX_LONGPTR_HEX, (ndrx_longptr_t)66);
0338     assert_equal(strncmp(p, tmp, strlen(tmp)), 0);
0339     assert_equal(len, strlen(tmp));
0340
0341     free(p);
0342
0343     assert_equal(Btypcvt(&len, BFLD_CARRAY, (char *)&ptr, BFLD_UBF, 0), NULL);
0344     assert_equal(Berror, BEBADOP);
0345
0346     assert_equal(Btypcvt(&len, BFLD_CARRAY, (char *)&ptr, BFLD_VIEW, 0), NULL);
0347     assert_equal(Berror, BEBADOP);
0348
0349     /* Convert to long validation */
0350     s=9999;
0351     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&s, BFLD_SHORT, 0)), NULL);
0352     assert_equal(*((ndrx_longptr_t *)p), 9999);
0353     free(p);
0354     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&l, BFLD_LONG, 0)), NULL);
0355     assert_equal(*((ndrx_longptr_t *)p), 111);
0356     free(p);
0357     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&c, BFLD_CHAR, 0)), NULL);
0358     assert_equal(*((ndrx_longptr_t *)p), 51);
0359     free(p);
0360     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&f, BFLD_FLOAT, 0)), NULL);
0361     assert_equal(*((ndrx_longptr_t *)p), 1);
0362     free(p);
0363     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&d, BFLD_DOUBLE, 0)), NULL);
0364     assert_equal(*((ndrx_longptr_t *)p), 5547);
0365     free(p);
0366     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)"0x12701123", BFLD_STRING, 0)), NULL);
0367     assert_equal(*((ndrx_longptr_t *)p), 0x12701123);
0368
0369     assert_equal(len, sizeof(ndrx_longptr_t));
0370
0371     free(p);
0372     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)"0x444441", BFLD_CARRAY, 8)), NULL);
0373     assert_equal(*((ndrx_longptr_t *)p), 0x444441);
0374     free(p);
0375
0376     ptr=66;
0377     assert_not_equal((p=Btypcvt(&len, BFLD_PTR, (char *)&ptr, BFLD_PTR, 0)), NULL);
0378     assert_equal(*((ndrx_longptr_t *)p), 66);
0379     free(p);
0380
0381     assert_equal(Btypcvt(&len, BFLD_PTR, (char *)&ptr, BFLD_UBF, 0), NULL);
0382     assert_equal(Berror, BEBADOP);
0383
0384     assert_equal(Btypcvt(&len, BFLD_PTR, (char *)&ptr, BFLD_VIEW, 0), NULL);
0385     assert_equal(Berror, BEBADOP);
0386
0387     /* test UBF (not supported) */
0388     assert_equal(Btypcvt(&len, BFLD_UBF, (char *)&ptr, BFLD_UBF, 0), NULL);
0389     assert_equal(Berror, BEBADOP);
0390
0391     /* test VIEW (not supported) */
0392     assert_equal(Btypcvt(&len, BFLD_VIEW, (char *)&ptr, BFLD_VIEW, 0), NULL);
0393     assert_equal(Berror, BEBADOP);
0394
0395     /* test invalid types */
0396     assert_equal((p=Btypcvt(&len, 12, (char *)"TEST CARRAY", BFLD_CARRAY, 11)), NULL);
0397     assert_equal(Berror, BTYPERR);
0398     assert_equal((p=Btypcvt(&len, BFLD_CARRAY, (char *)"TEST CARRAY", 12, 11)), NULL);
0399     assert_equal(Berror, BTYPERR);
0400     assert_equal((p=Btypcvt(&len, BFLD_CARRAY, NULL, 12, 11)), NULL);
0401     assert_equal(Berror, BEINVAL);
0402 }
0403
0404 /**
0405  * Common suite entry
0406  * @return
0407  */
0408 TestSuite *ubf_genbuf_tests(void)
0409 {
0410     TestSuite *suite = create_test_suite();
0411
0412     add_test(suite, test_Bcpy);
0413     add_test(suite, test_btypcvt);
0414
0415     return suite;
0416 }
0417 /* vim: set ts=4 sw=4 et smartindent: */