Initial commit

1 files changed, 128 insertions, 0 deletions

diff --git a/test b/test
new file mode 100755
index 0000000..2930e89
--- /dev/null
+++ b/test
@@ -0,0 +1,128 @@
+#if 0
+
+cc=${CC:-g++}
+bin="$(mktemp)"
+${cc} -x c++ -std=c++20 -o "$bin" "$(realpath $0)"
+"$bin"
+
+exit 0
+#endif
+
+#include "zmodn.h"
+#include <concepts>
+#include <functional>
+#include <iostream>
+#include <optional>
+
+template<typename S, typename T>
+requires std::convertible_to<S, T> || std::convertible_to<T, S>
+void assert_equal(S actual, T expected) {
+        if (actual != expected) {
+                std::cout << "Error!" << std::endl;
+                std::cout << "Expected: " << expected << std::endl;
+                std::cout << "But got:  " << actual << std::endl;
+                exit(1);
+        }
+}
+
+class Test {
+public:
+        std::string name;
+        std::function<void()> f;
+} tests[] = {
+{
+        .name = "Constructor 2 mod 3",
+        .f = []() {
+                Zmod<3> two = Zmod<3>(2);
+                assert_equal(two.toint64(), INT64_C(2));
+        }
+},
+{
+        .name = "Constructor -7 mod 3",
+        .f = []() {
+                Zmod<3> z = -7;
+                assert_equal(z, Zmod<3>(2));
+        }
+},
+{
+        .name = "1+1 mod 2",
+        .f = []() {
+                auto oneplusone = Zmod<2>(1) + Zmod<2>(1);
+                assert_equal(oneplusone, Zmod<2>(0));
+        }
+},
+{
+        .name = "2 -= 5 (mod 4)",
+        .f = []() {
+                Zmod<4> z = 2;
+                auto diff = (z -= 5);
+                assert_equal(z, Zmod<4>(1));
+                assert_equal(diff, Zmod<4>(1));
+        }
+},
+{
+        .name = "Inverse of 0 mod 2",
+        .f = []() {
+                Zmod<2> z = 0;
+                auto inv = z.inverse();
+                assert_equal(inv.has_value(), false);
+        }
+},
+{
+        .name = "Inverse of 1 mod 2",
+        .f = []() {
+                Zmod<2> z = 1;
+                auto inv = z.inverse();
+                assert_equal(inv.has_value(), true);
+                assert_equal(inv.value(), Zmod<2>(1));
+        }
+},
+{
+        .name = "Inverse of 5 mod 7",
+        .f = []() {
+                Zmod<7> z = 5;
+                auto inv = z.inverse();
+                assert_equal(inv.has_value(), true);
+                assert_equal(inv.value(), Zmod<7>(3));
+        }
+},
+{
+        .name = "Inverse of 4 mod 12",
+        .f = []() {
+                Zmod<12> z = 4;
+                auto inv = z.inverse();
+                assert_equal(inv.has_value(), false);
+        }
+},
+{
+        .name = "4 / 7 (mod 12)",
+        .f = []() {
+                Zmod<12> n = 4;
+                Zmod<12> d = 7;
+                auto inv = n / d;
+                assert_equal(inv.has_value(), true);
+                assert_equal(inv.value(), Zmod<12>(4));
+        }
+},
+{
+        .name = "4 /= 7 (mod 12)",
+        .f = []() {
+                Zmod<12> n = 4;
+                Zmod<12> d = 7;
+                auto inv = (n /= d);
+                assert_equal(inv.has_value(), true);
+                assert_equal(inv.value(), Zmod<12>(4));
+                assert_equal(n, Zmod<12>(4));
+        }
+},
+};
+
+int main() {
+        for (auto t : tests) {
+                std::cout << t.name << ": ";
+                t.f();
+                std::cout << "OK" << std::endl;
+        }
+        std::cout << "All tests passed" << std::endl;
+        return 0;
+}