refactor: organize test files

1 files changed, 122 insertions, 0 deletions

diff --git a/tests/operators.c b/tests/operators.c
new file mode 100644
index 0000000..9e9ba08
--- /dev/null
+++ b/tests/operators.c
@@ -0,0 +1,122 @@
+#include <helpers.h>
+
+int main() {
+    // arithmetic operators
+    ASSERT_EQ(42, 42);
+    ASSERT_EQ(21, 5 + 20 - 4);
+    ASSERT_EQ(26, 2 * 3 + 4 * 5);
+    ASSERT_EQ(197, (((3 + 5) / 2) + (5 * (9 - 6)) * (5 + 6 * 7)) % 256);
+    ASSERT_EQ(30, (-10 + 20 * -3) + 100);
+
+    // comparison operators
+    ASSERT_EQ(1, 0 == 0);
+    ASSERT_EQ(0, 123 != 123);
+    ASSERT_EQ(1, 123 != 456);
+    ASSERT_EQ(0, 123 == 124);
+    ASSERT_EQ(1, 123 < 567);
+    ASSERT_EQ(1, 123 <= 567);
+    ASSERT_EQ(1, 123 <= 123);
+    ASSERT_EQ(0, 123 < 123);
+
+    // bitwise operators
+    ASSERT_EQ(123, 0 | 123);
+    ASSERT_EQ(460, 12 | 456);
+
+    ASSERT_EQ(8, 1 << 3);
+    ASSERT_EQ(336, 21 << 4);
+    ASSERT_EQ(13, 111 >> 3);
+    ASSERT_EQ(0, 15 >> 14);
+
+    int a = 5;
+    int b = 3;
+    ASSERT_EQ(1, a & b);
+    ASSERT_EQ(7, a | b);
+    ASSERT_EQ(6, a ^ b);
+    ASSERT_EQ(4, 2 + 3 & 4);
+
+    int c = 1 + 2 & 3;
+    int d = 4 & 5 ^ 6;
+    int e = 1 ^ 2 | 3;
+    int f = 0 | 1 & 2;
+    ASSERT_EQ(3, c);
+    ASSERT_EQ(2, d);
+    ASSERT_EQ(3, e);
+    ASSERT_EQ(0, f);
+
+    ASSERT_EQ(-1, ~0);
+    ASSERT_EQ(-2, ~1);
+    ASSERT_EQ(-6, ~5);
+    ASSERT_EQ(0, ~(-1));
+    ASSERT_EQ(5, ~(-6));
+
+    int x = 10;
+    ASSERT_EQ(-11, ~x);
+    ASSERT_EQ(-1, ~(x & 0));
+    ASSERT_EQ(-16, ~(x | 5));
+
+    // assignment operators
+    int i = 0;
+    for (; i < 5; i += 1) {
+    }
+    ASSERT_EQ(5, i);
+
+    for (i = 5; i >= 0; i -= 1)
+        ;
+    ASSERT_EQ(-1, i);
+
+    x = 123;
+    x *= 456;
+    ASSERT_EQ(56088, x);
+
+    int y = 120;
+    y /= 5;
+    ASSERT_EQ(24, y);
+
+    int z = 17;
+    z %= 7;
+    ASSERT_EQ(3, z);
+
+    a = 0x05;
+    a |= 0x0A;
+    ASSERT_EQ(0x0F, a);
+
+    b = 0x0F;
+    b &= 0x0A;
+    ASSERT_EQ(0x0A, b);
+
+    c = 7;
+    c |= 8;
+    ASSERT_EQ(15, c);
+
+    d = 15;
+    d &= 6;
+    ASSERT_EQ(6, d);
+
+    e = 0x0F;
+    e ^= 0x05;
+    ASSERT_EQ(0x0A, e);
+
+    f = 3;
+    f <<= 2;
+    ASSERT_EQ(12, f);
+
+    int g = 16;
+    g >>= 2;
+    ASSERT_EQ(4, g);
+
+    int h = -16;
+    h >>= 2;
+    ASSERT_EQ(-4, h);
+
+    int j = 1;
+    j <<= 4;
+    ASSERT_EQ(16, j);
+
+    int k = 64;
+    k >>= 3;
+    ASSERT_EQ(8, k);
+
+    // ternary operator
+    ASSERT_EQ(2, 1 ? 2 : 3);
+    ASSERT_EQ(5, 0 ? 4 : 5);
+}