Moved and improved test cases for Issue #1462.

Fixed an old test case for unsigned enum bit-fields that are supposed to be int-promoted.

test/val/bug1462-2.c

@@ -0,0 +1,51 @@
+
+/* issue #1462 - Bit-fields are still broken */
+/* even the = operation is buggy in certain ways */
+
+#include <stdio.h>
+
+typedef struct {
+    signed int a : 3;
+    signed int b : 3;
+    signed int c : 3;
+} T;
+
+int failures = 0;
+
+T *f(T *t)
+{
+    t->a = 0;
+    t->c = 0;
+    return t;
+}
+
+void test(void)
+{
+    T a = { 7, 0, 7 };
+    T *p = &a;
+
+    a.b = f(p)->a;
+
+    if (a.a != 0) {
+        ++failures;
+    }
+    printf("%d\n", a.a);
+
+    if (p->b != 0) {
+        ++failures;
+    }
+    printf("%d\n", p->b);
+
+    if ((&a)->c != 0) {
+        ++failures;
+    }
+    printf("%d\n", (&a)->c);
+
+    printf("Failures: %d\n", failures);
+}
+
+int main(void)
+{
+    test();
+    return failures;
+}

test/val/bug1462-3.c

@@ -0,0 +1,95 @@
+
+/* issue #1462 - Bit-fields are still broken */
+/* More tests on "op= expression result value" that a naive fix might fail with */
+
+#include <stdio.h>
+
+typedef struct {
+    signed   int a : 3;
+    unsigned int b : 3;
+    signed   int c : 3;
+    unsigned int d : 3;
+} T1;
+
+typedef struct {
+    signed int a : 3;
+    signed int b : 3;
+    signed int c : 3;
+    signed int d : 3;
+} T2;
+
+
+int failures1 = 0;
+int failures2 = 0;
+
+void test1(void)
+{
+    T1 a = { 3, 3, 3, 3 };
+    int i;
+
+    i = a.a -= a.b + a.c;
+    if (i != -3 || a.a != -3) {
+        ++failures1;
+    }
+    printf("i = %d, a.a = %d\n", i, a.a);
+
+    a.b = i = a.b / -1;
+    if (i != -3 || a.b != 5) {
+        ++failures1;
+    }
+    printf("i = %d, a.b = %d\n", i, a.b);
+
+    i = a.c = 0;
+    if (i != 0 || a.c != 0) {
+        ++failures1;
+    }
+    printf("i = %d, a.c = %d\n", i, a.c);
+
+    i = a.d /= -1;
+    if (i != 5 || a.d != 5) {
+        ++failures1;
+    }
+    printf("i = %d, a.d = %d\n", i, a.d);
+
+    printf("Failures: %d\n", failures1);
+}
+
+void test2(void)
+{
+    T2 b = { 3, 3, 4, 4 };
+    int i;
+
+    i = b.a++;
+    if (i != 3 || b.a != -4) {
+        ++failures2;
+    }
+    printf("i = %d, b.a = %d\n", i, b.a);
+
+    i = ++b.b;
+    if (i != -4 || b.b != -4) {
+        ++failures2;
+    }
+    printf("i = %d, b.b = %d\n", i, b.b);
+
+    i = b.c--;
+    if (i != -4 || b.c != 3) {
+        ++failures2;
+    }
+    printf("i = %d, b.c = %d\n", i, b.c);
+
+    i = --b.d;
+    if (i != 3 || b.d != 3) {
+        ++failures2;
+    }
+    printf("i = %d, b.d = %d\n", i, b.d);
+
+    printf("Failures: %d\n", failures2);
+}
+
+int main(void)
+{
+    test1();
+    test2();
+    return failures1 + failures2;
+}
+

test/val/bug1462-4.c

@@ -0,0 +1,85 @@
+
+/* issue #1462 - Bit-fields are still broken */
+/* More tests on "op= expression result value" that a naive fix might fail with */
+
+#include <stdio.h>
+#include <limits.h>
+
+#define SMALL_WIDTH 4
+#define LARGE_WIDTH (CHAR_BIT * sizeof (unsigned int))
+
+typedef struct {
+    unsigned int a : SMALL_WIDTH;
+    unsigned int b : SMALL_WIDTH;
+    unsigned int c : SMALL_WIDTH;
+    unsigned int d : SMALL_WIDTH;
+} T1;
+
+typedef struct {
+    unsigned int a : LARGE_WIDTH;
+    unsigned int b : LARGE_WIDTH;
+    unsigned int c : LARGE_WIDTH;
+    unsigned int d : LARGE_WIDTH;
+} T2;
+
+
+int failures1 = 0;
+int failures2 = 0;
+
+void test1(void)
+{
+    T1 a = { 0, 0, 0, 0 };
+
+    printf("\nunsigned int : %d\n", SMALL_WIDTH);
+    if (!(~a.a < 0)) {
+        ++failures1;
+    }
+    printf("~a.a < 0 : %d\n", ~a.a < 0);
+    if (!(0 > ~a.b)) {
+        ++failures1;
+    }
+    printf("0 > ~a.b : %d\n",0 > ~a.b);
+    if (!(a.c > -1)) {
+        ++failures1;
+    }
+    printf("a.c > -1 : %d\n", a.c > -1);
+    if (!(-1 < a.d)) {
+        ++failures1;
+    }
+    printf("-1 < a.d : %d\n", -1 < a.d);
+
+    printf("Failures: %d\n", failures1);
+}
+
+void test2(void)
+{
+    T1 b = { 0, 0, 0, 0 };
+
+    printf("\nunsigned int : %d\n", LARGE_WIDTH);
+    if (!(~b.a < 0)) {
+        ++failures2;
+    }
+    printf("~b.a < 0 : %d\n", ~b.a < 0);
+    if (!(0 > ~b.b)) {
+        ++failures2;
+    }
+    printf("0 > ~b.b : %d\n", 0 > ~b.b);
+    if (!(b.c > -1)) {
+        ++failures2;
+    }
+    printf("b.c > -1 : %d\n", b.c > -1);
+    if (!(-1 < b.d)) {
+        ++failures2;
+    }
+    printf("-1 < b.d : %d\n", -1 < b.d);
+
+    printf("Failures: %d\n", failures2);
+}
+
+int main(void)
+{
+    test1();
+    test2();
+    return failures1 + failures2;
+}
+

test/val/bug1462.c

@@ -0,0 +1,67 @@
+
+/* issue #1462 - Bit-fields are still broken */
+
+#include <stdio.h>
+
+typedef struct {
+    signed int a : 3;
+    signed int b : 3;
+    signed int c : 3;
+} T;
+
+int failures = 0;
+
+void test()
+{
+    T a = {2, 5, -1};
+    T b = {1, 4, -1};
+    T m[1] = {{6, 3, -1}};
+    T *p = &a;
+
+    a.c += b.a;
+    p->c += b.b;
+    m->c += b.c;
+
+    if (a.c != -4) {
+        ++failures;
+    }
+    printf("%d\n", a.c);
+
+    if (p->c != -4) {
+        ++failures;
+    }
+    printf("%d\n", p->c);
+
+    if (m->c != -2) {
+        ++failures;
+    }
+    printf("%d\n", m->c);
+
+    ++a.a;
+    p->b++;
+    m->c--;
+
+    if (a.a != 3) {
+        ++failures;
+    }
+    printf("%d\n", a.a);
+
+    if (p->b != -2) {
+        ++failures;
+    }
+    printf("%d\n", p->b);
+
+    if (m->c != -3) {
+        ++failures;
+    }
+    printf("%d\n", m->c);
+
+    printf("Failures: %d\n", failures);
+}
+
+int main(void)
+{
+    test();
+    return failures;
+}
+

test/val/enum-bitfield.c

@@ -23,6 +23,7 @@
 */
 
 #include <stdio.h>
+#include <limits.h>
 
 static unsigned char failures = 0;
 
@@ -35,7 +36,7 @@ enum e10u {
 static struct enum_bitfield_uint {
     enum e10u x : 1;
     enum e10u y : 8;
-    enum e10u z : 16;
+    enum e10u z : CHAR_BIT * sizeof (enum e10u);
 } e10ubf = {0, E10U_200, E10U_1000};
 
 static void test_enum_bitfield_uint(void)
@@ -68,11 +69,11 @@ static void test_enum_bitfield_uint(void)
         failures++;
     }
 
-    /* Check signedness, should be unsigned. */
+    /* Check signedness, should be signed. */
     {
         long v = e10ubf.x - 2;
-        if (v < 0) {
-            printf ("Got negative v = %ld, expected large positive.\n", v);
+        if (v >= 0) {
+            printf ("Got non-negative v (= e10ubf.x - 2) = %ld, expected negative.\n", v);
             failures++;
         }
     }
@@ -85,6 +86,15 @@ static void test_enum_bitfield_uint(void)
         printf ("Got e10ubf.z = %u, expected 1023.\n", e10ubf.z);
         failures++;
     }
+
+    /* Check signedness, should be unsigned. */
+    {
+        long v = e10ubf.z - 1024;
+        if (v < 0) {
+            printf ("Got negative v (= e10ubf.z - 1024) = %ld, expected positive.\n", v);
+            failures++;
+        }
+    }
 }
 
 /* Enum with underlying type signed int. */
@@ -97,7 +107,7 @@ enum e11i {
 static struct enum_bitfield_int {
     enum e11i x : 2;
     enum e11i y : 8;
-    enum e11i z : 16;
+    enum e11i z : CHAR_BIT * sizeof (enum e11i);
 } e11ibf = {E11I_M1, E11I_100, E11I_1000};
 
 static void test_enum_bitfield_int(void)
@@ -133,8 +143,8 @@ static void test_enum_bitfield_int(void)
     /* Check signedness, should be signed. */
     {
         long v = e11ibf.x - 2;
-        if (v > 0) {
-            printf ("Got positive v = %ld, expected negative.\n", v);
+        if (v >= 0) {
+            printf ("Got non-negative v (= e11ibf.x - 2) = %ld, expected negative.\n", v);
             failures++;
         }
     }
@@ -147,6 +157,15 @@ static void test_enum_bitfield_int(void)
         printf ("Got e11ibf.z = %d, expected 1023.\n", e11ibf.z);
         failures++;
     }
+
+    /* Check signedness, should be signed. */
+    {
+        long v = e11ibf.z - 1024;
+        if (v >= 0) {
+            printf ("Got non-negative v (= e11ibf.z - 1024) = %ld, expected negative.\n", v);
+            failures++;
+        }
+    }
 }
 
 /* Enum with underlying type unsigned char. */
@@ -157,7 +176,7 @@ enum e7uc {
 static struct enum_bitfield_uchar {
     enum e7uc x : 1;
     enum e7uc y : 4;
-    enum e7uc z : 8;
+    enum e7uc z : CHAR_BIT;
 } e7ucbf = {0, 10, E7UC_100};
 
 static void test_enum_bitfield_uchar(void)
@@ -212,7 +231,7 @@ enum e8sc {
 static struct enum_bitfield_char {
     enum e8sc x : 1;
     enum e8sc y : 4;
-    enum e8sc z : 8;
+    enum e8sc z : CHAR_BIT;
 } e8scbf = {0, 5, E8SC_100};
 
 static void test_enum_bitfield_char(void)