Expand short type test coverage

Add comprehensive test cases for short data type operations
across multiple categories in the test suite.

- Add short variable assignment and arithmetic tests
- Include short pointer operations and dereferencing
- Add short array operations and compound assignments
- Expand compound literal tests with short type support
- Add short function parameters and return values

Test suite now validates short type functionality across
all major language features and both target architectures.

Author: hhhh1300

tests/driver.sh

@@ -476,6 +476,8 @@ declare -a variable_tests=(
     "10 int var; var = 10; return var;"
     "42 int va; int vb; va = 11; vb = 31; int vc; vc = va + vb; return vc;"
     "50 int v; v = 30; v = 50; return v;"
+    "25 short s; s = 25; return s;"
+    "50 short sa = 20; short sb = 30; short sc = sa + sb; return sc;"
 )
 
 run_items_tests variable_tests
@@ -493,6 +495,14 @@ int main() {
 }
 EOF
 
+try_ 42 << EOF
+typedef struct { short x; short y; } point_t;
+int main() {
+    point_t p = {42, 100};
+    return p.x;
+}
+EOF
+
 try_ 100 << EOF
 typedef struct { int x; int y; } point_t;
 int main() {
@@ -620,6 +630,15 @@ int main() {
 }
 EOF
 
+# Test: Array compound literal assigned to scalar short (non-standard)
+try_ 100 << EOF
+int main() {
+    /* Non-standard: Assigns first element of array to scalar short */
+    short x = (short[]){100, 200, 300};
+    return x;
+}
+EOF
+
 # Test: Array compound literal in arithmetic expression
 try_ 150 << EOF
 int main() {
@@ -630,6 +649,16 @@ int main() {
 }
 EOF
 
+# Test: Array compound literal in arithmetic expression
+try_ 150 << EOF
+int main() {
+    short a = 50;
+    /* Non-standard: Uses first element (100) in addition */
+    short b = a + (short[]){100, 200};
+    return b;
+}
+EOF
+
 # Test: Mixed scalar and array compound literals
 try_ 35 << EOF
 int main() {
@@ -905,6 +934,17 @@ int test_function() {
 }
 EOF
 
+# Test function with short parameters and return type
+try_ 35 << EOF
+short add_shorts(short a, short b) {
+    return a + b;
+}
+
+int main() {
+    return add_shorts(15, 20);
+}
+EOF
+
 # Test other large values
 try_large 1000 << EOF
 int test_function() {
@@ -998,6 +1038,7 @@ items 3 "int x; int *y; x = 3; y = &x; return y[0];"
 items 5 "int b; int *a; b = 10; a = &b; a[0] = 5; return b;"
 items 2 "int x[2]; int y; x[1] = 2; y = *(x + 1); return y;"
 items 2 "int x; int *y; int z; z = 2; y = &z; x = *y; return x;"
+items 2 "short x; short *y; short z; z = 2; y = &z; x = *y; return x;"
 
 # pointer dereference immediately after declaration
 items 42 "int x; x = 10; int *p; p = &x; p[0] = 42; exit(x);"
@@ -1464,6 +1505,35 @@ int main() {
 }
 EOF
 
+# Test short pointer
+try_ 150 << EOF
+int main() {
+    short value = 150;
+    short *ptr = &value;
+    return *ptr;
+}
+EOF
+
+# Test short pointer arithmetic
+try_ 20 << EOF
+int main() {
+    short arr[3] = {10, 20, 30};
+    short *p = arr;
+    p++;
+    return *p;
+}
+EOF
+
+# Test short pointer difference
+try_ 2 << EOF
+int main() {
+    short data[5] = {1, 2, 3, 4, 5};
+    short *start = data + 1;
+    short *end = data + 3;
+    return end - start;
+}
+EOF
+
 # Category: Function Pointers
 begin_category "Function Pointers" "Testing function pointer declarations and calls"
 
@@ -1525,6 +1595,14 @@ int main() {
 }
 EOF
 
+# Test short array
+try_ 25 << EOF
+int main() {
+    short arr[4] = {10, 15, 20, 25};
+    return arr[3];
+}
+EOF
+
 # 2D Array Tests
 # with proper row-major indexing for multi-dimensional arrays
 try_ 78 << EOF
@@ -1986,6 +2064,9 @@ items 4 "int a; a = 2; a <<= 1; return a;"
 items 2 "int a; a = 4; a >>= 1; return a;"
 items 1 "int a; a = 1; a ^= 0; return a;"
 items 20 "int *p; int a[3]; a[0] = 10; a[1] = 20; a[2] = 30; p = a; p+=1; return p[0];"
+items 8 "short s; s = 5; s += 3; return s;"
+items 15 "short s; s = 20; s -= 5; return s;"
+items 24 "short s; s = 6; s *= 4; return s;"
 
 # Category: Sizeof Operator
 begin_category "Sizeof Operator" "Testing sizeof operator on various types"
@@ -1994,16 +2075,19 @@ begin_category "Sizeof Operator" "Testing sizeof operator on various types"
 expr 0 "sizeof(void)";
 expr 1 "sizeof(_Bool)";
 expr 1 "sizeof(char)";
+expr 2 "sizeof(short)";
 expr 4 "sizeof(int)";
 # sizeof pointers
 expr 4 "sizeof(void*)";
 expr 4 "sizeof(_Bool*)";
 expr 4 "sizeof(char*)";
+expr 4 "sizeof(short*)";
 expr 4 "sizeof(int*)";
 # sizeof multi-level pointer
 expr 4 "sizeof(void**)";
 expr 4 "sizeof(_Bool**)";
 expr 4 "sizeof(char**)";
+expr 4 "sizeof(short**)";
 expr 4 "sizeof(int**)";
 # sizeof struct
 try_ 4 << EOF
@@ -4974,6 +5058,15 @@ EOF
 # Type Casting Tests
 echo "Testing type casting functionality..."
 
+declare -a cast_tests=(
+    "42 int var; var = (int)42; return var;"
+    "10 int var; var = (short)10; return var;"
+    "5 short s; s = (short)5; return s;"
+    "20 short s; s = (int)20; return s;"
+    "15 short sa = 10; short sb = (short)5; return sa + sb;"
+    "30 int ia = 10; int ib = (int)20; return ia + ib;"
+)
+
 # Basic int to char cast
 try_ 65 << EOF
 int main() {