Renamed some testcases.

2022-09-30 09:41:54 +08:00
parent 702ec52161
commit f6003b8e8c
8 changed files with 0 additions and 0 deletions
--- a/test/val/type-char-promote.c
+++ b/test/val/type-char-promote.c
@@ -0,0 +1,176 @@
+/*
+  Copyright 2020 The cc65 Authors
+
+  This software is provided 'as-is', without any express or implied
+  warranty. In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/*
+  Tests of promotions of character types.
+*/
+
+#include <stdio.h>
+
+typedef unsigned char u8;
+
+static unsigned char failures = 0;
+
+void test_sub (void)
+{
+    const u8 one = 1, two = 2;
+
+    /* For any unsigned type other than unsigned char, (T) 1 - (T) 2 > 0. */
+    if (1U - 2U < 0) {
+        fprintf (stderr, "Expected 1U - 2U > 0\n");
+        failures++;
+    }
+
+    /* The unsigned chars get promoted to int, so this is negative. */
+    if (one - two > 0) {
+        fprintf (stderr, "Expected one - two < 0\n");
+        failures++;
+    }
+
+    /* Test the constant expression code paths. */
+    if ((u8) 1 - (u8) 2 > 0) {
+        fprintf (stderr, "Expected (u8) 1 - (u8) 2 < 0\n");
+        failures++;
+    }
+}
+
+void test_mul (void)
+{
+    const u8 two_fifty_five = 255;
+    const u8 sixteen = 16;
+    int x;
+
+    if (255U * 255U != 65025U) {
+        fprintf (stderr, "Expected 255U * 255U == 65025U\n");
+        failures++;
+    }
+#if 0
+    /* Disabled pending fix of #1310. */
+    if (255 * 255 != -511) {
+        fprintf (stderr, "Expected 255 * 255 == -511, got: %d\n", 255 * 255);
+        failures++;
+    }
+#endif
+
+    /* The unsigned chars get promoted to int, so this is -511.
+    ** We should also be able to observe that, due to optimizations from #1315, the generated code
+    ** uses umul, not mul.
+    */
+    if (two_fifty_five * two_fifty_five != -511) {
+        fprintf (stderr, "Expected two_fifty_five * two_fifty_five == -511\n");
+        failures++;
+    }
+#if 0
+    /* Disabled pending fix of #1310. */
+    if ((u8) 255 * (u8) 255 != -511) {
+        fprintf (stderr, "Expected (u8) 255 * (u8) 255 == -511, got: %d\n",
+                 (u8) 255 * (u8) 255);
+        failures++;
+    }
+#endif
+
+    /* This should compile to a shift. */
+    x = sixteen * 4;
+    if (x != 64) {
+        fprintf (stderr, "Expected sixteen * 4 == 64, got: %d\n", x);
+        failures++;
+    }
+}
+
+void test_div (void)
+{
+    const u8 seventeen = 17;
+    const u8 three = 3;
+    int x;
+
+    /* We should also be able to observe that, due to optimizations from #1315, the generated code
+    ** uses udiv, not div.
+    */
+    if (seventeen / three != 5) {
+        fprintf (stderr, "Expected seventeen / three == 5, got: %d\n", seventeen / three);
+        failures++;
+    }
+    if ((u8) 17 / (u8) 3 != 5) {
+        fprintf (stderr, "Expected (u8) 17 / (u8) 3 == 5, got: %d\n", (u8) 17 / (u8) 3);
+        failures++;
+    }
+
+    /* Ideally, this would compile to a logical shift, but that does not happen currently. */
+    x = seventeen / 4;
+    if (x != 4) {
+        fprintf (stderr, "Expected seventeen / 4 == 4, got: %d\n", x);
+        failures++;
+    }
+}
+
+void test_mod (void)
+{
+    const u8 seventeen = 17;
+    /* Ideally, this would compile to a bitwise and, but that does not happen currently. */
+    int x = seventeen % 4;
+    if (x != 1) {
+        fprintf (stderr, "Expected seventeen %% 4 == 1, got: %d\n", x);
+        failures++;
+    }
+}
+
+void test_shr (void)
+{
+    const unsigned int forty_two = 42;
+    const unsigned int two = 2;
+    int x;
+
+    /* We should also be able to observe that, due to optimizations from #1315, the generated code
+    ** uses shr, not asr.
+    */
+    if (forty_two >> two != 10) {
+        fprintf (stderr, "Expected forty_two >> two == 10, got: %d\n", forty_two >> two);
+        failures++;
+    }
+    if ((u8) 42 >> (u8) 2 != 10) {
+        fprintf (stderr, "Expected (u8) 42 >> (u8) 2 == 10, got: %d\n", (u8) 42 >> (u8) 3);
+        failures++;
+    }
+
+    /* Ideally, this would compile to a logical shift, but that does not happen currently. */
+    x = forty_two >> 2;
+    if (x != 10) {
+        fprintf (stderr, "Expected forty_two >> 2 == 10, got: %d\n", x);
+        failures++;
+    }
+
+    /* Ideally, this would compile to a logical shift, but that does not happen currently. */
+    x = 42 >> two;
+    if (x != 10) {
+        fprintf (stderr, "Expected 42 >> two == 10, got: %d\n", x);
+        failures++;
+    }
+}
+
+int main (void)
+{
+    test_sub ();
+    test_mul ();
+    test_div ();
+    test_mod ();
+    test_shr ();
+    printf ("failures: %u\n", failures);
+    return failures;
+}