react-native-nitro-xlsx 0.1.4 → 0.2.6

package/thirdparty/OpenXLSX/Tests/testXLCellValueProxy.cpp

@@ -0,0 +1,255 @@
+//
+// Created by Kenneth Balslev on 26/08/2021.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLCellValueProxy Tests", "[XLCellValue]")
+{
+    SECTION("XLCellValueProxy conversion to XLCellValue (XLCellValue constructor)")
+    {
+        XLDocument doc;
+        doc.create("./testXLCellValueProxy.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+
+        {
+            wks.cell("A1").value() = "Hello OpenXLSX!";
+            XLCellValue 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;
+            XLCellValue 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;
+            XLCellValue 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;
+            XLCellValue 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("XLCellValueProxy conversion to XLCellValue (XLCellValue assignment operator)")
+    {
+        XLCellValue value;
+        XLDocument doc;
+        doc.create("./testXLCellValueProxy.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);
+
+        wks.cell("A1").value().setError("#N/A");
+        value = wks.cell("A1").value();
+        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>());
+
+        wks.cell("A1").value().clear();
+        value = wks.cell("A1").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>());
+
+        wks.cell("A1").value() = std::numeric_limits<double>::quiet_NaN();
+        value = wks.cell("A1").value();
+        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>());
+
+        wks.cell("A1").value() = std::numeric_limits<double>::infinity();
+        value                  = wks.cell("A1").value();
+        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("XLCellValueProxy copy assignment")
+    {
+        XLCellValue value;
+        XLDocument doc;
+        doc.create("./testXLCellValueProxy.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+
+        wks.cell("A1").value() = "Hello OpenXLSX!";
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::String);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "string");
+        REQUIRE(wks.cell("A2").value().get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A1").value() = 3.14159;
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Float);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "float");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE(wks.cell("A2").value().get<double>() == 3.14159);
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A1").value() = 42;
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Integer);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "integer");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE(wks.cell("A2").value().get<int>() == 42);
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A1").value() = true;
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Boolean);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "boolean");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE(wks.cell("A2").value().get<bool>() == true);
+
+        wks.cell("A1").value().setError("#N/A");
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Error);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "error");
+        REQUIRE(wks.cell("A2").value().get<std::string>() == "#N/A");
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+//        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A1").value().clear();
+        wks.cell("A2").value() = wks.cell("A1").value();
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Empty);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "empty");
+        REQUIRE(wks.cell("A2").value().get<std::string>().empty());
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+    }
+
+    SECTION("XLCellValueProxy set functions")
+    {
+        XLCellValue value;
+        XLDocument doc;
+        doc.create("./testXLCellValueProxy.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+
+        wks.cell("A2").value().set("Hello OpenXLSX!");
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::String);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "string");
+        REQUIRE(wks.cell("A2").value().get<std::string>() == "Hello OpenXLSX!");
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A2").value().set(3.14159);
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Float);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "float");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE(wks.cell("A2").value().get<double>() == 3.14159);
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A2").value().set(42);
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Integer);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "integer");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE(wks.cell("A2").value().get<int>() == 42);
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+        wks.cell("A2").value().set(true);
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Boolean);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "boolean");
+        REQUIRE_THROWS(wks.cell("A2").value().get<std::string>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE(wks.cell("A2").value().get<bool>() == true);
+
+        wks.cell("A2").value().setError("#N/A");
+        REQUIRE(wks.cell("A2").value().type() == XLValueType::Error);
+        REQUIRE(wks.cell("A2").value().typeAsString() == "error");
+        REQUIRE(wks.cell("A2").value().get<std::string>() == "#N/A");
+        REQUIRE_THROWS(wks.cell("A2").value().get<int>());
+//        REQUIRE_THROWS(wks.cell("A2").value().get<double>());
+        REQUIRE_THROWS(wks.cell("A2").value().get<bool>());
+
+    }
+}

package/thirdparty/OpenXLSX/Tests/testXLColor.cpp

@@ -0,0 +1,75 @@
+//
+// Created by I22696 on 21-09-2021.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLColor", "[XLColor]")
+{
+    SECTION("Constructors") {
+
+        XLColor color;
+        REQUIRE(color.alpha() == 255);
+        REQUIRE(color.red() == 0);
+        REQUIRE(color.green() == 0);
+        REQUIRE(color.blue() == 0);
+        REQUIRE(color.hex() == "ff000000");
+
+        color = XLColor(128, 128, 128);
+        REQUIRE(color.alpha() == 255);
+        REQUIRE(color.red() == 128);
+        REQUIRE(color.green() == 128);
+        REQUIRE(color.blue() == 128);
+        REQUIRE(color.hex() == "ff808080");
+
+        color = XLColor(128, 128, 128, 128);
+        REQUIRE(color.alpha() == 128);
+        REQUIRE(color.red() == 128);
+        REQUIRE(color.green() == 128);
+        REQUIRE(color.blue() == 128);
+        REQUIRE(color.hex() == "80808080");
+
+        color = XLColor("80808080");
+        REQUIRE(color.alpha() == 128);
+        REQUIRE(color.red() == 128);
+        REQUIRE(color.green() == 128);
+        REQUIRE(color.blue() == 128);
+        REQUIRE(color.hex() == "80808080");
+
+        color = XLColor("ffffff");
+        REQUIRE(color.alpha() == 255);
+        REQUIRE(color.red() == 255);
+        REQUIRE(color.green() == 255);
+        REQUIRE(color.blue() == 255);
+        REQUIRE(color.hex() == "ffffffff");
+
+        color.set("808080");
+        REQUIRE(color.alpha() == 255);
+        REQUIRE(color.red() == 128);
+        REQUIRE(color.green() == 128);
+        REQUIRE(color.blue() == 128);
+        REQUIRE(color.hex() == "ff808080");
+
+        color.set(255, 255, 255);
+        REQUIRE(color.alpha() == 255);
+        REQUIRE(color.red() == 255);
+        REQUIRE(color.green() == 255);
+        REQUIRE(color.blue() == 255);
+        REQUIRE(color.hex() == "ffffffff");
+
+        color.set(0, 0, 0, 0);
+        REQUIRE(color.alpha() == 0);
+        REQUIRE(color.red() == 0);
+        REQUIRE(color.green() == 0);
+        REQUIRE(color.blue() == 0);
+        REQUIRE(color.hex() == "00000000");
+
+        REQUIRE_THROWS(XLColor("ffff"));
+        REQUIRE_THROWS(XLColor("ffffffffff"));
+
+    }
+}

package/thirdparty/OpenXLSX/Tests/testXLDateTime.cpp

@@ -0,0 +1,229 @@
+//
+// Created by Kenneth Balslev on 29/08/2021.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLDateTime Tests", "[XLFormula]")
+{
+
+    SECTION("Default construction")
+    {
+        XLDateTime dt;
+
+        REQUIRE(dt.serial() == Approx(1.0));
+
+        auto tm = dt.tm();
+        REQUIRE(tm.tm_year == 0);
+        REQUIRE(tm.tm_mon == 0);
+        REQUIRE(tm.tm_mday == 1);
+        REQUIRE(tm.tm_yday == 0);
+        REQUIRE(tm.tm_wday == 0);
+        REQUIRE(tm.tm_hour == 0);
+        REQUIRE(tm.tm_min == 0);
+        REQUIRE(tm.tm_sec == 0);
+    }
+
+    SECTION("Constructor (serial number)")
+    {
+        REQUIRE_THROWS(XLDateTime(0.0));
+
+        XLDateTime dt (6069.86742);
+
+        REQUIRE(dt.serial() == Approx(6069.86742));
+
+        auto tm = dt.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+//        REQUIRE(tm.tm_yday == 0);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("Constructor (serial number, seconds rounding)")
+    {
+        REQUIRE_THROWS(XLDateTime(0.0));
+
+        const double serial = 6069.000008;
+        XLDateTime dt (serial);
+
+        REQUIRE(dt.serial() == Approx(serial));
+
+        auto tm = dt.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 0);
+        REQUIRE(tm.tm_min == 0);
+        REQUIRE(tm.tm_sec == 1);
+    }
+
+    SECTION("Constructor (std::tm object)")
+    {
+        std::tm tmo;
+
+        tmo.tm_year = -1;
+        tmo.tm_mon = 0;
+        tmo.tm_mday = 0;
+        tmo.tm_yday = 0;
+        tmo.tm_wday = 0;
+        tmo.tm_hour = 0;
+        tmo.tm_min = 0;
+        tmo.tm_sec = 0;
+        REQUIRE_THROWS(XLDateTime(tmo));
+
+        tmo.tm_year = 89;
+        tmo.tm_mon = 13;
+        REQUIRE_THROWS(XLDateTime(tmo));
+
+        tmo.tm_mon = -1;
+        REQUIRE_THROWS(XLDateTime(tmo));
+
+        tmo.tm_mon = 11;
+        tmo.tm_mday = 0;
+        REQUIRE_THROWS(XLDateTime(tmo));
+
+        tmo.tm_mday = 32;
+        REQUIRE_THROWS(XLDateTime(tmo));
+
+        tmo.tm_mday = 30;
+        tmo.tm_hour = 17;
+        tmo.tm_min = 6;
+        tmo.tm_sec = 28;
+        tmo.tm_wday = 6;
+
+        XLDateTime dt(tmo);
+
+        REQUIRE(dt.serial() == Approx(32872.7128));
+    }
+
+    SECTION("Copy Constructor")
+    {
+        XLDateTime dt (6069.86742);
+        XLDateTime dt2 = dt;
+
+        auto tm = dt2.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("Move Constructor")
+    {
+        XLDateTime dt (6069.86742);
+        XLDateTime dt2 = std::move(dt);
+
+        auto tm = dt2.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("Copy Assignment")
+    {
+        XLDateTime dt (6069.86742);
+        XLDateTime dt2;
+        dt2 = dt;
+
+        auto tm = dt2.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("Move Assignment")
+    {
+        XLDateTime dt (6069.86742);
+        XLDateTime dt2;
+        dt2 = std::move(dt);
+
+        auto tm = dt2.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("Serial Assignment")
+    {
+        XLDateTime dt (1.0);
+        dt = 6069.86742;
+
+        auto tm = dt.tm();
+        REQUIRE(tm.tm_year == 16);
+        REQUIRE(tm.tm_mon == 7);
+        REQUIRE(tm.tm_mday == 12);
+        REQUIRE(tm.tm_wday == 6);
+        REQUIRE(tm.tm_hour == 20);
+        REQUIRE(tm.tm_min == 49);
+        REQUIRE(tm.tm_sec == 5);
+    }
+
+    SECTION("std::tm Assignment")
+    {
+        std::tm tmo;
+        tmo.tm_year = 16;
+        tmo.tm_mon = 7;
+        tmo.tm_mday = 12;
+        tmo.tm_wday = 6;
+        tmo.tm_hour = 20;
+        tmo.tm_min = 49;
+        tmo.tm_sec = 5;
+
+        XLDateTime dt (1.0);
+        dt = tmo;
+
+        REQUIRE(dt.serial() == Approx(6069.86742));
+    }
+
+    SECTION("Implicit conversion")
+    {
+        std::tm tmo;
+        tmo.tm_year = 16;
+        tmo.tm_mon = 7;
+        tmo.tm_mday = 12;
+        tmo.tm_wday = 6;
+        tmo.tm_hour = 20;
+        tmo.tm_min = 49;
+        tmo.tm_sec = 5;
+
+        XLDateTime dt (1.0);
+        dt = tmo;
+
+        double serial = dt;
+        std::tm result = dt;
+
+        REQUIRE(serial == Approx(6069.86742));
+        REQUIRE(result.tm_year == 16);
+        REQUIRE(result.tm_mon == 7);
+        REQUIRE(result.tm_mday == 12);
+        REQUIRE(result.tm_wday == 6);
+        REQUIRE(result.tm_hour == 20);
+        REQUIRE(result.tm_min == 49);
+        REQUIRE(result.tm_sec == 5);
+    }
+}
+