Automatic translation result from C# to C++ is added.

Author: uselessgoddess

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "RegularExpressions.Transformer.CSharpToCpp"]
-	path = RegularExpressions.Transformer.CSharpToCpp
-	url = https://github.com/linksplatform/RegularExpressions.Transformer.CSharpToCpp
 [submodule "CSharpToCppTranslator"]
 	path = CSharpToCppTranslator
-	url = https://github.com/linksplatform/CSharpToCppTranslator
+	url = https://github.com/linksplatform/CSharpToCppTranslator/

cpp/Platform.Data.Tests/HybridTests.cpp

@@ -0,0 +1,17 @@
+namespace Platform::Data::Tests
+{
+    TEST_CLASS(HybridTests)
+    {
+        public: TEST_METHOD(ObjectConstructorTest)
+        {
+            Assert::AreEqual(0, Hybrid<std::uint8_t>(unchecked((std::uint8_t)128)).AbsoluteValue);
+            Assert::AreEqual(0, Hybrid<std::uint8_t>((void*)128).AbsoluteValue);
+            Assert::AreEqual(1, Hybrid<std::uint8_t>(unchecked((std::uint8_t)-1)).AbsoluteValue);
+            Assert::AreEqual(1, Hybrid<std::uint8_t>((void*)-1).AbsoluteValue);
+            Assert::AreEqual(0, Hybrid<std::uint8_t>(unchecked((std::uint8_t)0)).AbsoluteValue);
+            Assert::AreEqual(0, Hybrid<std::uint8_t>((void*)0).AbsoluteValue);
+            Assert::AreEqual(1, Hybrid<std::uint8_t>(unchecked((std::uint8_t)1)).AbsoluteValue);
+            Assert::AreEqual(1, Hybrid<std::uint8_t>((void*)1).AbsoluteValue);
+        }
+    };
+}

cpp/Platform.Data.Tests/LinksConstantsTests.cpp

@@ -0,0 +1,38 @@
+namespace Platform::Data::Tests
+{
+    TEST_CLASS(LinksConstantsTests)
+    {
+        public: TEST_METHOD(ConstructorTest)
+        {
+            auto constants = LinksConstants<std::uint64_t>(enableExternalReferencesSupport: true);
+            Assert::AreEqual(Hybrid<std::uint64_t>.ExternalZero, constants.ExternalReferencesRange.Value.Minimum);
+            Assert::AreEqual(std::numeric_limits<std::uint64_t>::max(), constants.ExternalReferencesRange.Value.Maximum);
+        }
+
+        public: TEST_METHOD(ExternalReferencesTest)
+        {
+            TestExternalReferences<std::uint64_t, std::int64_t>();
+            TestExternalReferences<std::uint32_t, std::int32_t>();
+            TestExternalReferences<std::uint16_t, std::int16_t>();
+            TestExternalReferences<std::uint8_t, std::int8_t>();
+        }
+
+        private: static void TestExternalReferences<TUnsigned, TSigned>()
+        {
+            auto unsingedOne = 0(TUnsigned) + 1;
+            auto converter = UncheckedConverter<TSigned, TUnsigned>.Default;
+            auto half = converter.Convert(NumericType<TSigned>.MaxValue);
+            LinksConstants<TUnsigned> constants = LinksConstants<TUnsigned>({unsingedOne, half}, {half + unsingedOne, NumericType<TUnsigned>.MaxValue});
+
+            auto minimum = Hybrid<TUnsigned>(0, isExternal: true);
+            auto maximum = Hybrid<TUnsigned>(half, isExternal: true);
+
+            Assert::IsTrue(constants.IsExternalReference(minimum));
+            Assert::IsTrue(minimum.IsExternal);
+            Assert::IsFalse(minimum.IsInternal);
+            Assert::IsTrue(constants.IsExternalReference(maximum));
+            Assert::IsTrue(maximum.IsExternal);
+            Assert::IsFalse(maximum.IsInternal);
+        }
+    };
+}