Add tests

tests/src/literals/constants/InfTests.cpp

@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+
+#include "fintamath/literals/constants/Inf.hpp"
+#include "fintamath/literals/constants/Pi.hpp"
+
+using namespace fintamath;
+
+const Inf c;
+
+TEST(InfTests, toStringTest) {
+  EXPECT_EQ(c.toString(), "Inf");
+}
+
+TEST(InfTests, callTest) {
+  EXPECT_EQ(c()->toString(), "Inf");
+}
+
+TEST(InfTests, equalsTest) {
+  EXPECT_EQ(c, c);
+  EXPECT_EQ(c, Inf());
+  EXPECT_EQ(Inf(), c);
+  EXPECT_EQ(c, cast<IMathObject>(Inf()));
+  EXPECT_EQ(cast<IMathObject>(Inf()), c);
+  EXPECT_NE(c, Pi());
+  EXPECT_NE(Pi(), c);
+}
+
+TEST(InfTests, getTypeIdTest) {
+  EXPECT_EQ(Inf::getTypeIdStatic(), MathObjectTypeId(MathObjectType::Inf));
+  EXPECT_EQ(Inf().getTypeId(), MathObjectTypeId(MathObjectType::Inf));
+}

tests/src/literals/constants/NegInfTests.cpp

@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+
+#include "fintamath/literals/constants/NegInf.hpp"
+#include "fintamath/literals/constants/Pi.hpp"
+
+using namespace fintamath;
+
+const NegInf c;
+
+TEST(NegInfTests, toStringTest) {
+  EXPECT_EQ(c.toString(), "-Inf");
+}
+
+TEST(NegInfTests, callTest) {
+  EXPECT_EQ(c()->toString(), "-Inf");
+}
+
+TEST(NegInfTests, equalsTest) {
+  EXPECT_EQ(c, c);
+  EXPECT_EQ(c, NegInf());
+  EXPECT_EQ(NegInf(), c);
+  EXPECT_EQ(c, cast<IMathObject>(NegInf()));
+  EXPECT_EQ(cast<IMathObject>(NegInf()), c);
+  EXPECT_NE(c, Pi());
+  EXPECT_NE(Pi(), c);
+}
+
+TEST(NegInfTests, getTypeIdTest) {
+  EXPECT_EQ(NegInf::getTypeIdStatic(), MathObjectTypeId(MathObjectType::NegInf));
+  EXPECT_EQ(NegInf().getTypeId(), MathObjectTypeId(MathObjectType::NegInf));
+}

tests/src/literals/constants/UndefinedTests.cpp

@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+
+#include "fintamath/literals/constants/Pi.hpp"
+#include "fintamath/literals/constants/Undefined.hpp"
+
+using namespace fintamath;
+
+const Undefined c;
+
+TEST(UndefinedTests, toStringTest) {
+  EXPECT_EQ(c.toString(), "Undefined");
+}
+
+TEST(UndefinedTests, callTest) {
+  EXPECT_EQ(c()->toString(), "Undefined");
+}
+
+TEST(UndefinedTests, equalsTest) {
+  EXPECT_EQ(c, c);
+  EXPECT_EQ(c, Undefined());
+  EXPECT_EQ(Undefined(), c);
+  EXPECT_EQ(c, cast<IMathObject>(Undefined()));
+  EXPECT_EQ(cast<IMathObject>(Undefined()), c);
+  EXPECT_NE(c, Pi());
+  EXPECT_NE(Pi(), c);
+}
+
+TEST(UndefinedTests, getTypeIdTest) {
+  EXPECT_EQ(Undefined::getTypeIdStatic(), MathObjectTypeId(MathObjectType::Undefined));
+  EXPECT_EQ(Undefined().getTypeId(), MathObjectTypeId(MathObjectType::Undefined));
+}