react-native-nitro-xlsx 0.2.5 → 0.2.6

package/thirdparty/OpenXLSX/Tests/testXLCellReference.cpp

@@ -0,0 +1,160 @@
+//
+// Created by Kenneth Balslev on 19/09/2021.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLCellReference Tests", "[XLCell]")
+{
+    SECTION("Constructors") {
+
+        auto ref = XLCellReference();
+        REQUIRE(ref.address() == "A1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 1);
+
+        ref = XLCellReference("B2");
+        REQUIRE(ref.address() == "B2");
+        REQUIRE(ref.row() == 2);
+        REQUIRE(ref.column() == 2);
+
+        ref = XLCellReference(3,3);
+        REQUIRE(ref.address() == "C3");
+        REQUIRE(ref.row() == 3);
+        REQUIRE(ref.column() == 3);
+
+        ref = XLCellReference(4, "D");
+        REQUIRE(ref.address() == "D4");
+        REQUIRE(ref.row() == 4);
+        REQUIRE(ref.column() == 4);
+
+        ref = XLCellReference("AA1");
+        REQUIRE(ref.address() == "AA1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 27);
+
+        ref = XLCellReference(1,27);
+        REQUIRE(ref.address() == "AA1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 27);
+
+        ref = XLCellReference("XFD1");
+        REQUIRE(ref.address() == "XFD1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == MAX_COLS);
+
+        ref = XLCellReference("A1048576");
+        REQUIRE(ref.address() == "A1048576");
+        REQUIRE(ref.row() == MAX_ROWS);
+        REQUIRE(ref.column() == 1);
+
+        REQUIRE_THROWS(XLCellReference(0,0));
+        REQUIRE_THROWS(XLCellReference("XFE1"));
+        REQUIRE_THROWS(XLCellReference("A1048577"));
+        REQUIRE_THROWS(XLCellReference(MAX_ROWS + 1,MAX_COLS + 1));
+        REQUIRE_THROWS(XLCellReference(MAX_ROWS + 1,"XFE"));
+
+        ref = XLCellReference("B2");
+        auto c_ref = ref;
+        REQUIRE(c_ref.address() == "B2");
+        REQUIRE(c_ref.row() == 2);
+        REQUIRE(c_ref.column() == 2);
+
+        ref = XLCellReference("C3");
+        c_ref = ref;
+        REQUIRE(c_ref.address() == "C3");
+        REQUIRE(c_ref.row() == 3);
+        REQUIRE(c_ref.column() == 3);
+
+        ref = XLCellReference("B2");
+        auto m_ref = std::move(ref);
+        REQUIRE(m_ref.address() == "B2");
+        REQUIRE(m_ref.row() == 2);
+        REQUIRE(m_ref.column() == 2);
+
+        ref = XLCellReference("C3");
+        m_ref = std::move(ref);
+        REQUIRE(m_ref.address() == "C3");
+        REQUIRE(m_ref.row() == 3);
+        REQUIRE(m_ref.column() == 3);
+
+    }
+
+    SECTION("Increment and Decrement") {
+
+        auto ref = XLCellReference();
+        REQUIRE(ref.address() == "A1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 1);
+
+        ++ref;
+        REQUIRE(ref.address() == "B1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 2);
+
+        ref++;
+        REQUIRE(ref.address() == "C1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 3);
+
+        --ref;
+        REQUIRE(ref.address() == "B1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 2);
+
+        ref--;
+        REQUIRE(ref.address() == "A1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 1);
+
+        --ref;
+        REQUIRE(ref.address() == "XFD1048576");
+        REQUIRE(ref.row() == MAX_ROWS);
+        REQUIRE(ref.column() == MAX_COLS);
+
+        ++ref;
+        REQUIRE(ref.address() == "A1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == 1);
+
+        ref = XLCellReference(1, MAX_COLS);
+
+        ++ref;
+        REQUIRE(ref.address() == "A2");
+        REQUIRE(ref.row() == 2);
+        REQUIRE(ref.column() == 1);
+
+        --ref;
+        REQUIRE(ref.address() == "XFD1");
+        REQUIRE(ref.row() == 1);
+        REQUIRE(ref.column() == MAX_COLS);
+
+
+    }
+
+    SECTION("Comparison operators") {
+
+        auto ref1 = XLCellReference("B2");
+        auto ref2 = XLCellReference("B2");
+        auto ref3 = XLCellReference("C3");
+
+        REQUIRE(ref1 == ref2);
+        REQUIRE_FALSE(ref1 == ref3);
+        REQUIRE(ref1 != ref3);
+        REQUIRE_FALSE(ref1 != ref2);
+        REQUIRE(ref1 < ref3);
+        REQUIRE_FALSE(ref1 > ref3);
+        REQUIRE(ref3 > ref1);
+        REQUIRE_FALSE(ref3 < ref1);
+        REQUIRE(ref1 <= ref2);
+        REQUIRE(ref1 <= ref3);
+        REQUIRE_FALSE(ref3 <= ref1);
+        REQUIRE(ref2 >= ref1);
+        REQUIRE(ref3 >= ref1);
+        REQUIRE_FALSE(ref1 >= ref3);
+    }
+}

package/thirdparty/OpenXLSX/Tests/testXLCellValue.cpp

@@ -0,0 +1,366 @@
+//
+// Created by Troldal on 2019-01-12.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+/**
+ * @brief The purpose of this test case is to test the creation of XLDocument objects. Each section section
+ * tests document creation using a different method. In addition, saving, closing and copying is tested.
+ */
+TEST_CASE("XLCellValue Tests", "[XLCellValue]")
+{
+    SECTION("Default Constructor")
+    {
+        XLCellValue value;
+
+        REQUIRE(value.type() == XLValueType::Empty);
+        REQUIRE(value.typeAsString() == "empty");
+        REQUIRE(value.get<std::string>().empty());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Float Constructor")
+    {
+        XLCellValue value(3.14159);
+
+        REQUIRE(value.type() == XLValueType::Float);
+        REQUIRE(value.typeAsString() == "float");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE(value.get<double>() == 3.14159);
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Integer Constructor")
+    {
+        XLCellValue value(42);
+
+        REQUIRE(value.type() == XLValueType::Integer);
+        REQUIRE(value.typeAsString() == "integer");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE(value.get<int>() == 42);
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Boolean Constructor")
+    {
+        XLCellValue value(true);
+
+        REQUIRE(value.type() == XLValueType::Boolean);
+        REQUIRE(value.typeAsString() == "boolean");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE(value.get<bool>() == true);
+    }
+
+    SECTION("String Constructor")
+    {
+        XLCellValue value("Hello OpenXLSX!");
+
+        REQUIRE(value.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(value.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Copy Constructor")
+    {
+        XLCellValue value("Hello OpenXLSX!");
+        auto        copy = value;
+
+        REQUIRE(copy.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(copy.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(copy.get<int>());
+        REQUIRE_THROWS(copy.get<double>());
+        REQUIRE_THROWS(copy.get<bool>());
+    }
+
+    SECTION("Move Constructor")
+    {
+        XLCellValue value("Hello OpenXLSX!");
+        auto        copy = std::move(value);
+
+        REQUIRE(copy.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(copy.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(copy.get<int>());
+        REQUIRE_THROWS(copy.get<double>());
+        REQUIRE_THROWS(copy.get<bool>());
+    }
+
+    SECTION("Copy Assignment")
+    {
+        XLCellValue value("Hello OpenXLSX!");
+        XLCellValue copy(1);
+        copy = value;
+
+        REQUIRE(copy.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(copy.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(copy.get<int>());
+        REQUIRE_THROWS(copy.get<double>());
+        REQUIRE_THROWS(copy.get<bool>());
+    }
+
+    SECTION("Move Assignment")
+    {
+        XLCellValue value("Hello OpenXLSX!");
+        XLCellValue copy(1);
+        copy = std::move(value);
+
+        REQUIRE(copy.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(copy.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(copy.get<int>());
+        REQUIRE_THROWS(copy.get<double>());
+        REQUIRE_THROWS(copy.get<bool>());
+    }
+
+    SECTION("Float Assignment")
+    {
+        XLCellValue value;
+        value = 3.14159;
+
+        REQUIRE(value.type() == XLValueType::Float);
+        REQUIRE(value.typeAsString() == "float");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE(value.get<double>() == 3.14159);
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Integer Assignment")
+    {
+        XLCellValue value;
+        value = 42;
+
+        REQUIRE(value.type() == XLValueType::Integer);
+        REQUIRE(value.typeAsString() == "integer");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE(value.get<int>() == 42);
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Boolean Assignment")
+    {
+        XLCellValue value;
+        value = true;
+
+        REQUIRE(value.type() == XLValueType::Boolean);
+        REQUIRE(value.typeAsString() == "boolean");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE(value.get<bool>() == true);
+    }
+
+    SECTION("String Assignment")
+    {
+        XLCellValue value;
+        value = "Hello OpenXLSX!";
+
+        REQUIRE(value.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(value.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("XLCellValueProxy Assignment")
+    {
+        XLCellValue value;
+        XLDocument doc;
+        doc.create("./testXLCellValue.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+
+        wks.cell("A1").value() = "Hello OpenXLSX!";
+        value = wks.cell("A1").value();
+        REQUIRE(value.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(value.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+
+        wks.cell("A1").value() = 3.14159;
+        value = wks.cell("A1").value();
+        REQUIRE(value.type() == XLValueType::Float);
+        REQUIRE(value.typeAsString() == "float");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE(value.get<double>() == 3.14159);
+        REQUIRE_THROWS(value.get<bool>());
+
+        wks.cell("A1").value() = 42;
+        value = wks.cell("A1").value();
+        REQUIRE(value.type() == XLValueType::Integer);
+        REQUIRE(value.typeAsString() == "integer");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE(value.get<int>() == 42);
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+
+        wks.cell("A1").value() = true;
+        value = wks.cell("A1").value();
+        REQUIRE(value.type() == XLValueType::Boolean);
+        REQUIRE(value.typeAsString() == "boolean");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE(value.get<bool>() == true);
+    }
+
+    SECTION("Set Float ")
+    {
+        XLCellValue value;
+        value.set(3.14159);
+
+        REQUIRE(value.type() == XLValueType::Float);
+        REQUIRE(value.typeAsString() == "float");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE(value.get<double>() == 3.14159);
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Set Nan Float")
+    {
+        XLCellValue value;
+        value.set(std::numeric_limits<double>::quiet_NaN());
+
+        REQUIRE(value.type() == XLValueType::Error);
+        REQUIRE(value.typeAsString() == "error");
+        REQUIRE(value.get<std::string>() == "#NUM!");
+        REQUIRE_THROWS(value.get<int>());
+//        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+        SECTION("Set Inf Float")
+    {
+        XLCellValue value;
+        value.set(std::numeric_limits<double>::infinity());
+
+        REQUIRE(value.type() == XLValueType::Error);
+        REQUIRE(value.typeAsString() == "error");
+        REQUIRE(value.get<std::string>() == "#NUM!");
+        REQUIRE_THROWS(value.get<int>());
+//        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Set Integer")
+    {
+        XLCellValue value;
+        value.set(42);
+
+        REQUIRE(value.type() == XLValueType::Integer);
+        REQUIRE(value.typeAsString() == "integer");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE(value.get<int>() == 42);
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Set Boolean")
+    {
+        XLCellValue value;
+        value.set(true);
+
+        REQUIRE(value.type() == XLValueType::Boolean);
+        REQUIRE(value.typeAsString() == "boolean");
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE(value.get<bool>() == true);
+    }
+
+    SECTION("Set String")
+    {
+        XLCellValue value;
+        value.set("Hello OpenXLSX!");
+
+        REQUIRE(value.type() == XLValueType::String);
+        REQUIRE(value.typeAsString() == "string");
+        REQUIRE(value.get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Clear")
+    {
+        XLCellValue value;
+        value.set("Hello OpenXLSX!");
+        value.clear();
+
+        REQUIRE(value.type() == XLValueType::Empty);
+        REQUIRE(value.typeAsString() == "empty");
+        REQUIRE(value.get<std::string>().empty());
+        REQUIRE_THROWS(value.get<int>());
+        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Set Error")
+    {
+        XLCellValue value;
+        value.set("Hello OpenXLSX!");
+        value.setError("#N/A");
+
+        REQUIRE(value.type() == XLValueType::Error);
+        REQUIRE(value.typeAsString() == "error");
+        REQUIRE(value.get<std::string>() == "#N/A");
+        REQUIRE_THROWS(value.get<int>());
+//        REQUIRE_THROWS(value.get<double>());
+        REQUIRE_THROWS(value.get<bool>());
+    }
+
+    SECTION("Implicit conversion to supported types")
+    {
+        XLCellValue value;
+
+        value ="Hello OpenXLSX!";
+        auto result1 = value.get<std::string>();
+        REQUIRE(result1 == "Hello OpenXLSX!");
+        REQUIRE_THROWS(static_cast<int>(value));
+        REQUIRE_THROWS(static_cast<double>(value));
+        REQUIRE_THROWS(static_cast<bool>(value));
+
+        value = 42;
+        auto result2 = static_cast<int>(value);
+        REQUIRE(result2 == 42);
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(static_cast<double>(value));
+        REQUIRE_THROWS(static_cast<bool>(value));
+
+        value = 3.14159;
+        auto result3 = static_cast<double>(value);
+        REQUIRE(result3 == 3.14159);
+        REQUIRE_THROWS(static_cast<int>(value));
+        REQUIRE_THROWS(value.get<std::string>());
+        REQUIRE_THROWS(static_cast<bool>(value));
+
+        value = true;
+        auto result4 = static_cast<bool>(value);
+        REQUIRE(result4 == true);
+        REQUIRE_THROWS(static_cast<int>(value));
+        REQUIRE_THROWS(static_cast<double>(value));
+        REQUIRE_THROWS(value.get<std::string>());
+
+    }
+}