Add const qualifier test coverage

Extended const pointer test suite with additional test cases:
- const local variables and initialization
- const pointer to non-const data
- Function returning const pointer
- const in nested expressions
- const with conditional operator
- const cast from non-const
- const with multiple indirection levels
- const parameter with pointer arithmetic
- const struct pointer parameter
- const array elements access
- const pointer with multiple dereferences
- const pointer increment in loop
- const pointer reference passing

Author: jserv

tests/driver.sh

@@ -2088,6 +2088,209 @@ int main() {
 }
 EOF
 
+# Test const local variables
+try_ 50 << EOF
+int main() {
+    const int x = 50;
+    return x;
+}
+EOF
+
+# Test const local variable initialization
+try_ 75 << EOF
+int main() {
+    int y = 25;
+    const int x = y + 50;
+    return x;
+}
+EOF
+
+# Test const pointer to non-const data (pointer itself is const)
+try_ 42 << EOF
+int main() {
+    int x = 42;
+    int * const p = &x;
+    return *p;
+}
+EOF
+
+# Test function returning const pointer (using global instead of static)
+try_ 100 << EOF
+int global_value = 100;
+
+const int *get_ptr() {
+    return &global_value;
+}
+
+int main() {
+    const int *p = get_ptr();
+    return *p;
+}
+EOF
+
+# Test const in nested expressions
+try_ 30 << EOF
+int compute(const int *a, const int *b) {
+    return (*a) * 2 + (*b) * 3;
+}
+
+int main() {
+    int x = 6;
+    int y = 6;
+    return compute(&x, &y);  /* 6*2 + 6*3 = 30 */
+}
+EOF
+
+# Test const with conditional operator
+try_ 25 << EOF
+int choose_value(int cond, const int *a, const int *b) {
+    return cond ? *a : *b;
+}
+
+int main() {
+    int x = 25;
+    int y = 50;
+    return choose_value(1, &x, &y);
+}
+EOF
+
+# Test const cast from non-const
+try_ 88 << EOF
+int use_const(const int *p) {
+    return *p;
+}
+
+int main() {
+    int val = 88;
+    int *p = &val;
+    return use_const((const int *)p);
+}
+EOF
+
+# Test const with multiple indirection levels
+try_ 33 << EOF
+int get_deep_value(const int * const * const *ppp) {
+    return ***ppp;
+}
+
+int main() {
+    int val = 33;
+    int *p = &val;
+    int **pp = &p;
+    int ***ppp = &pp;
+    return get_deep_value(ppp);
+}
+EOF
+
+# Test const parameter with pointer arithmetic
+try_ 15 << EOF
+int sum_range(const int *start, const int *end) {
+    int sum = 0;
+    const int *p = start;
+    while (p < end) {
+        sum += *p;
+        p++;
+    }
+    return sum;
+}
+
+int main() {
+    int arr[3] = {5, 5, 5};
+    return sum_range(arr, arr + 3);
+}
+EOF
+
+# Test const with simple function call
+try_ 10 << EOF
+int double_value(int n) {
+    return n * 2;
+}
+
+int apply_double(const int *x) {
+    return double_value(*x);
+}
+
+int main() {
+    int val = 5;
+    return apply_double(&val);
+}
+EOF
+
+# Test const struct pointer parameter
+try_ 150 << EOF
+typedef struct {
+    int x;
+    int y;
+} Point;
+
+int point_sum(const Point *p) {
+    return p->x + p->y;
+}
+
+int main() {
+    Point pt = {75, 75};
+    return point_sum(&pt);
+}
+EOF
+
+# Test const array elements access
+try_ 21 << EOF
+int sum_const_array(const int arr[3]) {
+    return arr[0] + arr[1] + arr[2];
+}
+
+int main() {
+    int data[3] = {7, 7, 7};
+    return sum_const_array(data);
+}
+EOF
+
+# Test const pointer with multiple dereferences
+try_ 40 << EOF
+int process(const int *x, const int *y) {
+    int val1 = *x;
+    int val2 = *y;
+    return val2;  /* returns second value */
+}
+
+int main() {
+    int a = 30;
+    int b = 40;
+    return process(&a, &b);
+}
+EOF
+
+# Test const pointer increment in loop
+try_ 3 << EOF
+int count_until(const int *arr, int target) {
+    const int *p = arr;
+    int count = 0;
+    while (*p != target) {
+        count++;
+        p++;
+    }
+    return count;
+}
+
+int main() {
+    int data[5] = {1, 2, 3, 10, 5};
+    return count_until(data, 10);  /* returns 3 */
+}
+EOF
+
+# Test const pointer reference passing
+try_ 7 << EOF
+int sum_via_ptr(const int *a, const int *b) {
+    return *a + *b;
+}
+
+int main() {
+    int x = 3;
+    int y = 4;
+    return sum_via_ptr(&x, &y);
+}
+EOF
+
 # Category: Ternary Operator
 begin_category "Ternary Operator" "Testing conditional ?: operator"