ext/lib_test/tests - variations added for char and String-by-value (const char*)

examples/ext/lib_test/lib_test/gen/config.json

@@ -10,7 +10,16 @@
         "func_V_args_Pi",
         "func_Pi_args_Pi",
         "func_V_args_pPi",
-        "func_Pi_args_Pi_pPi_pPi"
+        "func_Pi_args_Pi_pPi_pPi",
+        "func_Pc_args_V",
+        "func_V_args_Pc",
+        "func_Pc_args_Pc",
+        "func_V_args_pPc",
+        "func_Pc_args_Pc_pPc_pPc",
+        "func_pPcc_args_V",
+        "func_V_args_pPcc",
+        "func_pPcc_args_pPcc",
+        "func_pPcc_args_pPcc_pPcc"
     ],
     "debug_ast" : "True",
     "debug_acid" : "True",

examples/ext/lib_test/tests/test_lib_test.py

@@ -6,6 +6,7 @@ import pytest
 import lib_test
 from lib_test import *
 
+# Int
 def test_func_V_args_V():
     (ret,) = func_V_args_V()
     assert(ret == None)
@@ -41,3 +42,65 @@ def test_func_Pi_args_Pi_pPi_pPi():
     assert (arg1 == 23)
     assert (arg2 == 23)
     assert (arg3 == 23)
+
+# Char
+def test_func_Pc_args_V():
+    (ret,) = func_Pc_args_V()
+    print("RESULT:", ret)
+    assert (ret == "A")
+
+def test_func_V_args_Pc():
+    (ret,arg1) = func_V_args_Pc('A')
+    print("RESULT:", ret, arg1)
+    assert(ret == None)
+    assert(arg1 == 'A')
+
+def test_func_Pc_args_Pc():
+    (ret,arg1) = func_Pc_args_Pc('a')
+    print("RESULT:", ret, arg1)
+    assert (ret == 'A')
+    assert (arg1 == 'a')
+
+# @pytest.mark.skip("")
+def test_func_V_args_pPc():
+    (ret,arg1) = func_V_args_pPc('a')
+    print("RESULT:", ret, arg1)
+    assert (ret == None)
+    assert (arg1 == 'A')
+
+def test_func_Pc_args_Pc_pPc_pPc():
+    (ret, arg1, arg2, arg3) = func_Pc_args_Pc_pPc_pPc('A', 'a','a')
+    print("RESULT:", ret, arg1, arg2, arg3)
+    assert (ret == 'A')
+    assert (arg1 == 'A')
+    assert (arg2 == 'A')
+    assert (arg3 == 'A')
+
+# String-by-value (const char*)
+def test_func_pPcc_args_V():
+    (ret,) = func_pPcc_args_V()
+    print("RESULT:", ret)
+    assert (ret == "pEp")
+
+def test_func_V_args_pPcc():
+    instr = "pEp"
+    (ret,arg1) = func_V_args_pPcc(instr)
+    print("RESULT:", ret,arg1)
+    assert (ret == None)
+    assert (arg1 == instr)
+
+def test_func_pPcc_args_pPcc():
+    instr = "pEp"
+    (ret,arg1) = func_pPcc_args_pPcc(instr)
+    print("RESULT:", ret,arg1)
+    assert (ret == instr)
+    assert (arg1 == instr)
+
+def test_func_pPcc_args_pPcc_pPcc():
+    instr = "pEp"
+    instr2 = "pEp"
+    (ret,arg1,arg2) = func_pPcc_args_pPcc_pPcc(instr,instr2)
+    print("RESULT:", ret,arg1,arg2)
+    assert (ret == instr)
+    assert (arg1 == instr)
+    assert (arg2 == instr)

examples/lib/lib_test/functions.h

@@ -10,6 +10,7 @@
 extern "C" {
 #endif
 
+//Int
 void func_V_args_V();
 
 int func_Pi_args_V();
@@ -22,6 +23,27 @@ void func_V_args_pPi(unsigned int* const arg1_pP);
 
 int func_Pi_args_Pi_pPi_pPi(int arg1_P,unsigned int* const arg2_pP, int* arg3_pP);
 
+// Char
+char func_Pc_args_V();
+
+void func_V_args_Pc(char arg1_Pc);
+
+char func_Pc_args_Pc(char arg1_Pc);
+
+void func_V_args_pPc(char* arg1_pPc);
+
+char func_Pc_args_Pc_pPc_pPc(char arg1_Pc,char* arg2_pPc,char* arg3_pPc);
+
+// String-by-value (const char*)
+const char* func_pPcc_args_V();
+
+void func_V_args_pPcc(const char* arg1_pPcc);
+
+const char* func_pPcc_args_pPcc(const char* arg1_pPcc);
+
+const char* func_pPcc_args_pPcc_pPcc(const char* arg1_pPcc,const char* arg2_pPcc);
+
+// String-by-ref (char**)
 
 
 

examples/lib/lib_test/lib_test.c

@@ -1,9 +1,12 @@
 #include "lib_test.h"
 
 #include<stdio.h>
-// FUNCTIONS
+#include<ctype.h>
+#include<string.h>
 
+// FUNCTIONS
 
+// Int
 void func_V_args_V() {
 
 }
@@ -17,7 +20,6 @@ void func_V_args_Pi(int arg1_P) {
 }
 
 int func_Pi_args_Pi(int arg1_P) {
-    printf("%i", arg1_P);
     return ++arg1_P;
 }
 
@@ -31,6 +33,47 @@ int func_Pi_args_Pi_pPi_pPi(int arg1_P,unsigned int* const arg2_pP, int* arg3_pP
     return *arg2_pP;
 }
 
+// Char
+char func_Pc_args_V() {
+    return 'A';
+}
+
+void func_V_args_Pc(char arg1_Pc) {
+    printf("%c", arg1_Pc);
+}
+
+char func_Pc_args_Pc(char arg1_Pc) {
+    return toupper(arg1_Pc);
+}
+
+void func_V_args_pPc(char* arg1_pPc) {
+    *arg1_pPc = toupper(*arg1_pPc);
+}
+
+char func_Pc_args_Pc_pPc_pPc(char arg1_Pc,char* arg2_pPc,char* arg3_pPc){
+    *arg2_pPc = toupper(*arg2_pPc);
+    *arg3_pPc = toupper(*arg3_pPc);
+    return 'A';
+}
+
+// String-by-value (const char*)
+const char* func_pPcc_args_V() {
+    return "pEp";
+}
+
+void func_V_args_pPcc(const char* arg1_pPcc) {
+    printf("%s", arg1_pPcc);
+}
+
+const char* func_pPcc_args_pPcc(const char* arg1_pPcc) {
+    return strdup(arg1_pPcc);
+}
+
+const char* func_pPcc_args_pPcc_pPcc(const char* arg1_pPcc,const char* arg2_pPcc) {
+    printf("%s", arg1_pPcc);
+    printf("%s", arg2_pPcc);
+    return strdup(arg1_pPcc);
+}
 
 // Variables
 // =========

examples/lib/lib_test/main.c

@@ -1,11 +1,11 @@
 #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();
@@ -41,4 +41,64 @@ int main() {
         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_V_args_pPc\n");
+        char c = 'a';
+        func_V_args_pPc(&c);
+        assert(c == 'A');
+    }
+    {
+        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));
+    }
 }