pEpACIDgen/examples/lib/lib_test/main.c

#include "lib_test.h"
#include <stdio.h>
#include <assert.h>
#include <string.h>

int main() {
    printf("lib_test starting...\n");
    // It
    {
        printf("testing: func_V_args_V\n");
        func_V_args_V();
    }
    {
        printf("testing: func_Pi_args_V\n");
        int ret = func_Pi_args_V();
        assert(ret == 23);
    }
    {
        printf("testing: func_V_args_Pi\n");
        func_V_args_Pi(23);
    }
    {
        printf("testing: func_Pi_args_Pi\n");
        int ret = func_Pi_args_Pi(22);
        assert(ret == 23);
    }
    {
        printf("testing: func_V_args_pPi\n");
        unsigned int i = 22;
        func_V_args_pPi(&i);
        assert(i == 23);
    }
    {
        printf("testing: func_Pi_args_Pi_pPi_pPi\n");
        int i = 23;
        unsigned int j = 22;
        int k = 22;
        int ret = func_Pi_args_Pi_pPi_pPi(i,&j,&k);
        assert(ret == 23);
        assert(i == 23);
        assert(j == 23);
        assert(k == 23);
    }
    // Char
    {
        printf("testing: func_V_args_V\n");
        func_V_args_V();
    }
    {
        printf("testing: func_Pc_args_V\n");
        char ret = func_Pc_args_V();
        assert(ret == 'A');
    }
    {
        printf("testing: func_V_args_Pc\n");
        func_V_args_Pc('a');
    }
    {
        printf("testing: func_Pc_args_Pc\n");
        char ret = func_Pc_args_Pc('a');
        assert(ret == 'A');
    }
    {
        printf("testing: func_pPcStr_args_V\n");
        char* ret = func_pPcStr_args_V();
        assert(!strcmp(ret,"pEp"));
    }
    {
        printf("testing: func_V_args_pPcChr\n");
        char c = 'a';
        func_V_args_pPcChr(&c);
        assert(c == 'A');
    }
    {
        printf("testing: func_V_args_pPcStr\n");
        char c[4] = "pEp";
        func_V_args_pPcStr(c);
        assert(!strcmp(c,"PEP"));
    }
    {
        printf("testing: func_Pc_args_Pc_pPc_pPc\n");
        char i = 'A';
        char j = 'a';
        char k = 'a';
        char ret = func_Pc_args_Pc_pPc_pPc(i,&j,&k);
        assert(ret == 'A');
        assert(i == 'A');
        assert(j == 'A');
        assert(k == 'A');
    }

    // String-by-value (const char*)
    {
        printf("testing: func_pPcc_args_V\n");
        const char* ret = func_pPcc_args_V();
        assert(!strcmp(ret, "pEp"));
    }
    {
        printf("testing: func_V_args_pPcc\n");
        func_V_args_pPcc("pEp");
    }
    {
        printf("testing: func_pPcc_args_pPcc\n");
        const char* in = "pEp";
        const char* ret = func_pPcc_args_pPcc(in);
        assert(!strcmp(ret, in));
    }
    {
        printf("testing: func_pPcc_args_pPcc_pPcc\n");
        const char* in = "pEp";
        const char* in2 = "pEp";
        const char* ret = func_pPcc_args_pPcc_pPcc(in,in2);
        assert(!strcmp(ret, in));
    }

    // String-by-ref (char**)
    {
        printf("testing: func_ppPc_args_V\n");
        char** ret = func_ppPc_args_V();
        assert(!strcmp(*ret, "pEp"));
    }
    {
        printf("testing: func_ppPc_args_V\n");
        char*** ret = func_pppPc_args_V();
        assert(!strcmp(**ret, "pEp"));
    }
    {
        printf("testing: func_V_args_ppPc\n");
        char* inout = NULL;
        func_V_args_ppPc(&inout);
        assert(!strcmp(inout,"pEp"));
    }
    {
        printf("testing: func_pppPc_args_pppPc\n");
        char* inout = NULL;
        char **pp_inout = &inout;
        char*** ret = func_pppPc_args_pppPc(&pp_inout);
        assert(!strcmp(**ret,"pEp"));
        assert(!strcmp(inout,"pEp"));
    }
    {
        printf("testing: func_pppPc_args_pppPc_ppPc\n");
        char* in = NULL;
        char** pp_in = &in;
        char* in2 = NULL;
        char*** ret = func_pppPc_args_pppPc_ppPc(&pp_in,&in2);
        assert(!strcmp(**ret, "pEp"));
        assert(!strcmp(in, "pEp"));
        assert(!strcmp(in2, "pEp"));
    }
    {
        printf("testing: func__PS_args_V\n");
        struct _PS ret = func__PS_args_V();
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func__PS_args__PS\n");
        struct _PS in;
        struct _PS ret = func__PS_args__PS(in);
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_TTAPS_args_V\n");
        TTAPS ret = func_TTAPS_args_V();
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_TTAPS_args_TTAPS\n");
        TTAPS in;
        TTAPS ret = func_TTAPS_args_TTAPS(in);
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_pTAPS_args_V\n");
        TAPS* iret = func_pTAPS_args_V();
        TAPS ret = *iret;
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_ppTAPS_args_V\n");
        TAPS** iret = func_ppTAPS_args_V();
        TAPS ret = **iret;
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_pppTAPS_args_V\n");
        TAPS*** iret = func_pppTAPS_args_V();
        TAPS ret = ***iret;
        assert(ret.field__P_1 == 23);
        assert(ret.field__P_2 == 23);
    }
    {
        printf("testing: func_V_args_pTAPS\n");
        TAPS inout;
        func_V_args_pTAPS(&inout);
        assert(inout.field__P_1 == 23);
        assert(inout.field__P_2 == 23);
    }
    {
        printf("testing: func_ppTAPS_args_ppTAPS\n");
        TAPS* inout;
        TAPS** pp_ret = func_ppTAPS_args_ppTAPS(&inout);
        TAPS* ret = *pp_ret;
        assert(ret->field__P_1 == 23);
        assert(inout->field__P_1 == 23);
        assert(inout->field__P_2 == 23);
    }
    {
        printf("testing: func_pppTAPS_args_pppTAPS\n");
        TAPS* inout;
        TAPS** pp_inout = &inout;
        TAPS*** ppp_ret = func_pppTAPS_args_pppTAPS(&pp_inout);
        TAPS* ret = **ppp_ret;
        assert(ret->field__P_1 == 23);
        assert(inout->field__P_1 == 23);
        assert(inout->field__P_2 == 23);
    }
    {
        printf("testing: func_TTAPSa_args_V\n");
        TTAPSa ret = func_TTAPSa_args_V();
        assert(ret.field__P_1 == 23);
        assert(!strcmp(ret.field__Pa_1, "pEp"));
    }
    {
        printf("testing: func_TTAPSa_args_TTAPSa\n");
        TTAPSa in;
        TTAPSa ret = func_TTAPSa_args_TTAPSa(in);
        assert(ret.field__P_1 == 23);
        assert(!strcmp(ret.field__Pa_1, "pEp"));
    }
    {
        printf("testing: func_V_args_pTTAPSa\n");
        TTAPSa *inout = (TTPSa*)malloc(sizeof (TTPSa));
        func_V_args_pTTAPSa(inout);
        assert(inout->field__P_1 == 23);
        assert(!strcmp(inout->field__Pa_1, "pEp"));
    }
    {
        printf("testing: func_ppTTAPSa_args_ppTTAPSa\n");
        TTAPSa *inout = (TTPSa*)malloc(sizeof (TTPSa));
        TTPSa** pp_ret = func_ppTTAPSa_args_ppTTAPSa(&inout);
        TTAPSa* ret = *pp_ret;
        assert(ret->field__P_1 == 23);
        assert(!strcmp(ret->field__Pa_1, "pEp"));
        assert(inout->field__P_1 == 23);
        assert(!strcmp(inout->field__Pa_1, "pEp"));
    }
    {
        printf("testing: func_pppTTAPSa_args_pppTTAPSa\n");
        TTAPSa *inout = (TTPSa*)malloc(sizeof (TTPSa));
        TTPSa** pp_inout = &inout;
        TTPSa*** pp_ret = func_pppTTAPSa_args_pppTTAPSa(&pp_inout);
        TTAPSa* ret = **pp_ret;
        assert(ret->field__P_1 == 23);
        assert(!strcmp(ret->field__Pa_1, "pEp"));
        assert(inout->field__P_1 == 23);
        assert(!strcmp(inout->field__Pa_1, "pEp"));
    }
    {
        printf("testing: func_TACS_args_V\n");
        TACS ret = func_TACS_args_V();
        assert(ret.field__PS_1.field__P_1 = 23);
        assert(ret.field__PS_1.field__P_2 = 23);
        assert(ret.field_APS_1[0].field__P_1 = 23);
        assert(ret.field_APS_1[0].field__P_2 = 23);
    }

}