react-native-nitro-xlsx 0.1.4 → 0.2.6

package/thirdparty/OpenXLSX/Tests/catch/catch_reporter_teamcity.hpp

@@ -0,0 +1,212 @@
+/*
+ *  Created by Phil Nash on 19th December 2014
+ *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <cstring>
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch
+{
+    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter>
+    {
+        TeamCityReporter(ReporterConfig const& _config) : StreamingReporterBase(_config)
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+        }
+
+        static std::string escape(std::string const& str)
+        {
+            std::string escaped = str;
+            replaceInPlace(escaped, "|", "||");
+            replaceInPlace(escaped, "'", "|'");
+            replaceInPlace(escaped, "\n", "|n");
+            replaceInPlace(escaped, "\r", "|r");
+            replaceInPlace(escaped, "[", "|[");
+            replaceInPlace(escaped, "]", "|]");
+            return escaped;
+        }
+        ~TeamCityReporter() override;
+
+        static std::string getDescription()
+        {
+            return "Reports test results as TeamCity service messages";
+        }
+
+        void skipTest(TestCaseInfo const& /* testInfo */) override {}
+
+        void noMatchingTestCases(std::string const& /* spec */) override {}
+
+        void testGroupStarting(GroupInfo const& groupInfo) override
+        {
+            StreamingReporterBase::testGroupStarting(groupInfo);
+            stream << "##teamcity[testSuiteStarted name='" << escape(groupInfo.name) << "']\n";
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override
+        {
+            StreamingReporterBase::testGroupEnded(testGroupStats);
+            stream << "##teamcity[testSuiteFinished name='" << escape(testGroupStats.groupInfo.name) << "']\n";
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override
+        {
+            AssertionResult const& result = assertionStats.assertionResult;
+            if (!result.isOk()) {
+                ReusableStringStream msg;
+                if (!m_headerPrintedForThisSection) printSectionHeader(msg.get());
+                m_headerPrintedForThisSection = true;
+
+                msg << result.getSourceInfo() << "\n";
+
+                switch (result.getResultType()) {
+                    case ResultWas::ExpressionFailed:
+                        msg << "expression failed";
+                        break;
+                    case ResultWas::ThrewException:
+                        msg << "unexpected exception";
+                        break;
+                    case ResultWas::FatalErrorCondition:
+                        msg << "fatal error condition";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        msg << "no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        msg << "explicit failure";
+                        break;
+
+                    // We shouldn't get here because of the isOk() test
+                    case ResultWas::Ok:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                        CATCH_ERROR("Internal error in TeamCity reporter");
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        CATCH_ERROR("Not implemented");
+                }
+                if (assertionStats.infoMessages.size() == 1) msg << " with message:";
+                if (assertionStats.infoMessages.size() > 1) msg << " with messages:";
+                for (auto const& messageInfo : assertionStats.infoMessages) msg << "\n  \"" << messageInfo.message << "\"";
+
+                if (result.hasExpression()) {
+                    msg << "\n  " << result.getExpressionInMacro()
+                        << "\n"
+                           "with expansion:\n"
+                        << "  " << result.getExpandedExpression() << "\n";
+                }
+
+                if (currentTestCaseInfo->okToFail()) {
+                    msg << "- failure ignore as test marked as 'ok to fail'\n";
+                    stream << "##teamcity[testIgnored"
+                           << " name='" << escape(currentTestCaseInfo->name) << "'"
+                           << " message='" << escape(msg.str()) << "'"
+                           << "]\n";
+                }
+                else {
+                    stream << "##teamcity[testFailed"
+                           << " name='" << escape(currentTestCaseInfo->name) << "'"
+                           << " message='" << escape(msg.str()) << "'"
+                           << "]\n";
+                }
+            }
+            stream.flush();
+            return true;
+        }
+
+        void sectionStarting(SectionInfo const& sectionInfo) override
+        {
+            m_headerPrintedForThisSection = false;
+            StreamingReporterBase::sectionStarting(sectionInfo);
+        }
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override
+        {
+            m_testTimer.start();
+            StreamingReporterBase::testCaseStarting(testInfo);
+            stream << "##teamcity[testStarted name='" << escape(testInfo.name) << "']\n";
+            stream.flush();
+        }
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override
+        {
+            StreamingReporterBase::testCaseEnded(testCaseStats);
+            if (!testCaseStats.stdOut.empty())
+                stream << "##teamcity[testStdOut name='" << escape(testCaseStats.testInfo.name) << "' out='" << escape(testCaseStats.stdOut)
+                       << "']\n";
+            if (!testCaseStats.stdErr.empty())
+                stream << "##teamcity[testStdErr name='" << escape(testCaseStats.testInfo.name) << "' out='" << escape(testCaseStats.stdErr)
+                       << "']\n";
+            stream << "##teamcity[testFinished name='" << escape(testCaseStats.testInfo.name) << "' duration='"
+                   << m_testTimer.getElapsedMilliseconds() << "']\n";
+            stream.flush();
+        }
+
+    private:
+        void printSectionHeader(std::ostream& os)
+        {
+            assert(!m_sectionStack.empty());
+
+            if (m_sectionStack.size() > 1) {
+                os << getLineOfChars<'-'>() << "\n";
+
+                std::vector<SectionInfo>::const_iterator it = m_sectionStack.begin() + 1,    // Skip first section (test case)
+                    itEnd                                   = m_sectionStack.end();
+                for (; it != itEnd; ++it) printHeaderString(os, it->name);
+                os << getLineOfChars<'-'>() << "\n";
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            os << lineInfo << "\n";
+            os << getLineOfChars<'.'>() << "\n\n";
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        static void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0)
+        {
+            std::size_t i = _string.find(": ");
+            if (i != std::string::npos)
+                i += 2;
+            else
+                i = 0;
+            os << Column(_string).indent(indent + i).initialIndent(indent) << "\n";
+        }
+
+    private:
+        bool  m_headerPrintedForThisSection = false;
+        Timer m_testTimer;
+    };
+
+#ifdef CATCH_IMPL
+    TeamCityReporter::~TeamCityReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER("teamcity", TeamCityReporter)
+
+}    // end namespace Catch
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+#endif    // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

package/thirdparty/OpenXLSX/Tests/main.cpp

@@ -0,0 +1,55 @@
+//
+// Created by Troldal on 2019-01-10.
+//
+
+// this tells catch to provide a main()
+// only do this in one cpp file
+
+#ifndef OPENXLSX_TESTMAIN_H
+#define OPENXLSX_TESTMAIN_H
+
+#define CATCH_CONFIG_RUNNER
+
+#include <catch.hpp>
+#include <OpenXLSX.hpp>
+#include <cstdio>
+
+using namespace OpenXLSX;
+
+void PrepareDocument(std::string name)
+{
+    XLDocument doc;
+    std::remove(name.c_str());
+    doc.create(name);
+    doc.save();
+    doc.close();
+}
+
+int main(int argc, char* argv[])
+{
+    // Global Setup
+    //    XLDocument doc;
+    //
+    //    std::remove("./TestDocumentCreation.xlsx");
+    //    std::remove("./TestDocumentCreationNew.xlsx");
+    //
+    //    PrepareDocument("./TestDocumentProperties.xlsx");
+    //    PrepareDocument("./TestWorkbook.xlsx");
+    //    PrepareDocument("./TestSheet.xlsx");
+    //    PrepareDocument("./TestWorksheet.xlsx");
+    //    PrepareDocument("./TestCellReference.xlsx");
+    //    PrepareDocument("./TestCell.xlsx");
+    // Global Setup Complete
+
+    // Run Test Suite
+    int result = Catch::Session().run(argc, argv);
+    // Run Test Suite Complete
+
+    // Global Clean-up
+    // ...
+    // Global Setup Complete
+
+    return result;
+}
+
+#endif    // OPENXLSX_TESTMAIN_H

package/thirdparty/OpenXLSX/Tests/testXLCell.cpp

@@ -0,0 +1,176 @@
+//
+// Created by Troldal on 2019-01-12.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLCell Tests", "[XLCell]")
+{
+    SECTION("Default Constructor")
+    {
+        XLCell cell;
+        REQUIRE_FALSE(cell);
+        REQUIRE_THROWS(cell.cellReference());
+        REQUIRE_FALSE(cell.hasFormula());
+        REQUIRE_THROWS(cell.formula());
+        REQUIRE_THROWS(cell.formula().set("=1+1"));
+        REQUIRE_THROWS(cell.value());
+
+        const auto copy = cell;
+        REQUIRE_FALSE(copy);
+        REQUIRE_THROWS(copy.cellReference());
+        REQUIRE_FALSE(copy.hasFormula());
+        REQUIRE_THROWS(copy.formula());
+        REQUIRE_THROWS(copy.value());
+
+
+    }
+
+    SECTION("Create from worksheet")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.value() = 42;
+
+        REQUIRE(cell);
+        REQUIRE(cell.cellReference().address() == "A1");
+        REQUIRE_FALSE(cell.hasFormula());
+        REQUIRE(cell.value().get<int>() == 42);
+
+    }
+
+    SECTION("Copy constructor")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.value() = 42;
+
+        auto copy = cell;
+
+        REQUIRE(copy);
+        REQUIRE(copy.cellReference().address() == "A1");
+        REQUIRE_FALSE(copy.hasFormula());
+        REQUIRE(copy.value().get<int>() == 42);
+
+    }
+
+    SECTION("Move constructor")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.value() = 42;
+
+        XLCell copy = std::move(cell);
+
+        REQUIRE(copy);
+        REQUIRE(copy.cellReference().address() == "A1");
+        REQUIRE_FALSE(copy.hasFormula());
+        REQUIRE(copy.value().get<int>() == 42);
+
+    }
+
+    SECTION("Copy assignment operator")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.value() = 42;
+
+        XLCell copy;
+        copy = cell;
+
+        REQUIRE(copy);
+        REQUIRE(copy.cellReference().address() == "A1");
+        REQUIRE_FALSE(copy.hasFormula());
+        REQUIRE(copy.value().get<int>() == 42);
+
+    }
+
+    SECTION("Move assignment operator")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.value() = 42;
+
+        XLCell copy;
+        copy = std::move(cell);
+
+        REQUIRE(copy);
+        REQUIRE(copy.cellReference().address() == "A1");
+        REQUIRE_FALSE(copy.hasFormula());
+        REQUIRE(copy.value().get<int>() == 42);
+
+
+
+    }
+
+    SECTION("Setters and Getters")
+    {
+        XLDocument doc;
+        doc.create("./testXLCell.xlsx");
+        XLWorksheet wks = doc.workbook().sheet(1);
+        auto cell = wks.cell("A1");
+        cell.formula().set("=1+1");
+        cell.value() = 42;
+
+        REQUIRE(cell.hasFormula());
+        REQUIRE(cell.formula().get() == "=1+1");
+        REQUIRE(cell.value().get<int>() == 42);
+
+
+        const auto copy = cell;
+        REQUIRE(copy.hasFormula());
+        REQUIRE(copy.formula().get() == "=1+1");
+        REQUIRE(copy.value().get<int>() == 42);
+
+    }
+
+    SECTION("Relational operators")
+    {
+        auto doc = XLDocument();
+        doc.create("./testXLCell.xlsx");
+        auto wks = doc.workbook().worksheet("Sheet1");
+
+        auto cell1 = wks.cell("B2");
+        auto cell2 = wks.cell("B2");
+        auto cell3 = wks.cell("C3");
+
+        REQUIRE(cell1 == cell2);
+        REQUIRE_FALSE(cell1 == cell3);
+        REQUIRE(cell1 != cell3);
+        REQUIRE_FALSE(cell1 != cell2);
+    }
+
+    SECTION("Offset function")
+    {
+        auto doc = XLDocument();
+        doc.create("./testXLCell.xlsx");
+        auto wks = doc.workbook().worksheet("Sheet1");
+
+        auto cell1 = wks.cell("B2");
+        cell1.value() = "Value1";
+
+        auto cell2 = cell1.offset(1,1);
+        cell2.value() = "Value2";
+
+        REQUIRE(cell1.value().get<std::string>() == "Value1");
+        REQUIRE(cell2.value().get<std::string>() == "Value2");
+        REQUIRE(cell2.cellReference().address() == "C3");
+
+        doc.save();
+    }
+
+}

package/thirdparty/OpenXLSX/Tests/testXLCellRange.cpp

@@ -0,0 +1,180 @@
+//
+// Created by Kenneth Balslev on 19/09/2021.
+//
+
+#include <OpenXLSX.hpp>
+#include <catch.hpp>
+#include <fstream>
+
+using namespace OpenXLSX;
+
+TEST_CASE("XLCellRange Tests", "[XLCellRange]")
+{
+    XLDocument doc;
+    doc.create("./testXLCellRange.xlsx");
+    auto wks = doc.workbook().worksheet("Sheet1");
+
+    SECTION("Constructor")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for (auto cl : rng) cl.value() = "Value";
+        doc.save();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("C2").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("D2").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("B3").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("C3").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("D3").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("B4").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("C4").value().get<std::string>() == "Value");
+        REQUIRE(wks.cell("D4").value().get<std::string>() == "Value");
+    }
+
+    SECTION("Copy Constructor")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for (auto cl : rng) cl.value() = "Value";
+        doc.save();
+
+        XLCellRange rng2 = rng;
+        for (auto cl : rng2) cl.value() = "Value2";
+        doc.save();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("C2").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("D2").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("B3").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("C3").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("D3").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("B4").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("C4").value().get<std::string>() == "Value2");
+        REQUIRE(wks.cell("D4").value().get<std::string>() == "Value2");
+    }
+
+    SECTION("Move Constructor")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for (auto cl : rng) cl.value() = "Value";
+        doc.save();
+
+        XLCellRange rng2 {std::move(rng)};
+        for (auto cl : rng2) cl.value() = "Value3";
+        doc.save();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("C2").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("D2").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("B3").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("C3").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("D3").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("B4").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("C4").value().get<std::string>() == "Value3");
+        REQUIRE(wks.cell("D4").value().get<std::string>() == "Value3");
+    }
+
+    SECTION("Copy Assignment")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for (auto cl : rng) cl.value() = "Value";
+        doc.save();
+
+        XLCellRange rng2 = wks.range();
+        rng2 = rng;
+        for (auto cl : rng2) cl.value() = "Value4";
+        doc.save();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("C2").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("D2").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("B3").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("C3").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("D3").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("B4").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("C4").value().get<std::string>() == "Value4");
+        REQUIRE(wks.cell("D4").value().get<std::string>() == "Value4");
+    }
+
+    SECTION("Move Assignment")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for (auto cl : rng) cl.value() = "Value";
+        doc.save();
+
+        XLCellRange rng2 = wks.range();
+        rng2 = std::move(rng);
+        for (auto cl : rng2) cl.value() = "Value5";
+        doc.save();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("C2").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("D2").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("B3").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("C3").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("D3").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("B4").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("C4").value().get<std::string>() == "Value5");
+        REQUIRE(wks.cell("D4").value().get<std::string>() == "Value5");
+    }
+
+    SECTION("Functions")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for(auto iter = rng.begin(); iter != rng.end(); iter++)
+            iter->value() = "Value";
+
+        doc.save();
+
+        REQUIRE(rng.numColumns() == 3);
+        REQUIRE(rng.numRows() == 3);
+
+        rng.clear();
+
+        REQUIRE(wks.cell("B2").value().get<std::string>().empty());
+        REQUIRE(wks.cell("C2").value().get<std::string>().empty());
+        REQUIRE(wks.cell("D2").value().get<std::string>().empty());
+        REQUIRE(wks.cell("B3").value().get<std::string>().empty());
+        REQUIRE(wks.cell("C3").value().get<std::string>().empty());
+        REQUIRE(wks.cell("D3").value().get<std::string>().empty());
+        REQUIRE(wks.cell("B4").value().get<std::string>().empty());
+        REQUIRE(wks.cell("C4").value().get<std::string>().empty());
+        REQUIRE(wks.cell("D4").value().get<std::string>().empty());
+    }
+
+    SECTION("XLCellIterator")
+    {
+        auto rng = wks.range(XLCellReference("B2"), XLCellReference("D4"));
+        for(auto iter = rng.begin(); iter != rng.end(); iter++)
+            iter->value() = "Value";
+
+        auto begin = rng.begin();
+        REQUIRE(begin->cellReference().address() == "B2");
+
+        auto iter2 = ++begin;
+        REQUIRE(iter2->cellReference().address() == "C2");
+
+        XLCellIterator iter3 = std::move(++begin) ;
+        REQUIRE(iter3->cellReference().address() == "D2");
+
+        auto iter4 = rng.begin();
+        iter4 = ++iter3;
+        REQUIRE(iter4->cellReference().address() == "B3");
+
+        auto iter5 = rng.begin();
+        iter5 = std::move(++iter3);
+        REQUIRE(iter5->cellReference().address() == "C3");
+
+        auto it1 = rng.begin();
+        auto it2 = rng.begin();
+        auto it3 = rng.end();
+
+        REQUIRE(it1 == it2);
+        REQUIRE_FALSE(it1 != it2);
+        REQUIRE(it1 != it3);
+        REQUIRE_FALSE(it1 == it3);
+
+        REQUIRE(std::distance(it1, it3) == 9);
+
+    }
+
+}