react-native-nitro-xlsx 0.1.4 → 0.2.6

package/thirdparty/pugixml/tests/main.cpp

@@ -0,0 +1,218 @@
+#include "test.hpp"
+#include "allocator.hpp"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <float.h>
+#include <assert.h>
+
+#include <string>
+
+#ifndef PUGIXML_NO_EXCEPTIONS
+#   include <exception>
+#endif
+
+#ifdef _WIN32_WCE
+#   undef DebugBreak
+#   pragma warning(disable: 4201) // nonstandard extension used: nameless struct/union
+#   include <windows.h>
+#endif
+
+test_runner* test_runner::_tests = 0;
+size_t test_runner::_memory_fail_threshold = 0;
+bool test_runner::_memory_fail_triggered = false;
+jmp_buf test_runner::_failure_buffer;
+const char* test_runner::_failure_message;
+const char* test_runner::_temp_path;
+
+static size_t g_memory_total_size = 0;
+static size_t g_memory_total_count = 0;
+static size_t g_memory_fail_triggered = false;
+
+static void* custom_allocate(size_t size)
+{
+	if (test_runner::_memory_fail_threshold > 0 && test_runner::_memory_fail_threshold < g_memory_total_size + size)
+	{
+		g_memory_fail_triggered = true;
+		test_runner::_memory_fail_triggered = true;
+
+		return 0;
+	}
+	else
+	{
+		void* ptr = memory_allocate(size);
+		if (!ptr) return 0;
+
+		g_memory_total_size += memory_size(ptr);
+		g_memory_total_count++;
+
+		return ptr;
+	}
+}
+
+#ifndef PUGIXML_NO_EXCEPTIONS
+static void* custom_allocate_throw(size_t size)
+{
+	void* result = custom_allocate(size);
+
+	if (!result)
+		throw std::bad_alloc();
+
+	return result;
+}
+#endif
+
+static void custom_deallocate(void* ptr)
+{
+	assert(ptr);
+
+	g_memory_total_size -= memory_size(ptr);
+	g_memory_total_count--;
+
+	memory_deallocate(ptr);
+}
+
+static void replace_memory_management()
+{
+	// create some document to touch original functions
+	{
+		pugi::xml_document doc;
+		doc.append_child().set_name(STR("node"));
+	}
+
+	// replace functions
+	pugi::set_memory_management_functions(custom_allocate, custom_deallocate);
+}
+
+#if defined(_MSC_VER) && _MSC_VER > 1200 && _MSC_VER < 1400 && !defined(__INTEL_COMPILER) && !defined(__DMC__)
+#include <exception>
+
+namespace std
+{
+	_CRTIMP2 _Prhand _Raise_handler;
+	_CRTIMP2 void __cdecl _Throw(const exception&) {}
+}
+#endif
+
+static bool run_test(test_runner* test, const char* test_name, pugi::allocation_function allocate)
+{
+#ifndef PUGIXML_NO_EXCEPTIONS
+	try
+	{
+#endif
+		g_memory_total_size = 0;
+		g_memory_total_count = 0;
+		g_memory_fail_triggered = false;
+		test_runner::_memory_fail_threshold = 0;
+		test_runner::_memory_fail_triggered = false;
+
+		pugi::set_memory_management_functions(allocate, custom_deallocate);
+
+#ifdef _MSC_VER
+#	pragma warning(push)
+#	pragma warning(disable: 4611) // interaction between _setjmp and C++ object destruction is non-portable
+#   pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
+#endif
+
+		volatile int result = setjmp(test_runner::_failure_buffer);
+
+#ifdef _MSC_VER
+#	pragma warning(pop)
+#endif
+
+		if (result)
+		{
+			printf("Test %s failed: %s\n", test_name, test_runner::_failure_message);
+			return false;
+		}
+
+		test->run();
+
+		if (test_runner::_memory_fail_triggered)
+		{
+			printf("Test %s failed: unguarded memory fail triggered\n", test_name);
+			return false;
+		}
+
+		if (g_memory_total_size != 0 || g_memory_total_count != 0)
+		{
+			printf("Test %s failed: memory leaks found (%u bytes in %u allocations)\n", test_name, static_cast<unsigned int>(g_memory_total_size), static_cast<unsigned int>(g_memory_total_count));
+			return false;
+		}
+
+		return true;
+#ifndef PUGIXML_NO_EXCEPTIONS
+	}
+	catch (const std::exception& e)
+	{
+		printf("Test %s failed: exception %s\n", test_name, e.what());
+		return false;
+	}
+	catch (...)
+	{
+		printf("Test %s failed for unknown reason\n", test_name);
+		return false;
+	}
+#endif
+}
+
+#if defined(__CELLOS_LV2__) && defined(PUGIXML_NO_EXCEPTIONS) && !defined(__SNC__)
+#include <exception>
+
+void std::exception::_Raise() const
+{
+	abort();
+}
+#endif
+
+int main(int, char** argv)
+{
+#ifdef __BORLANDC__
+	_control87(MCW_EM | PC_53, MCW_EM | MCW_PC);
+#endif
+
+	// setup temp path as the executable folder
+	std::string temp = argv[0];
+	std::string::size_type slash = temp.find_last_of("\\/");
+	temp.erase((slash != std::string::npos) ? slash + 1 : 0);
+
+	test_runner::_temp_path = temp.c_str();
+
+	replace_memory_management();
+
+	unsigned int total = 0;
+	unsigned int passed = 0;
+
+	test_runner* test = 0; // gcc3 "variable might be used uninitialized in this function" bug workaround
+
+	for (test = test_runner::_tests; test; test = test->_next)
+	{
+		total++;
+		passed += run_test(test, test->_name, custom_allocate);
+
+		if (g_memory_fail_triggered)
+		{
+			// run tests that trigger memory failures twice - with an allocator that returns NULL and with an allocator that throws
+		#ifndef PUGIXML_NO_EXCEPTIONS
+			total++;
+			passed += run_test(test, (test->_name + std::string(" (throw)")).c_str(), custom_allocate_throw);
+		#endif
+		}
+	}
+
+	unsigned int failed = total - passed;
+
+	if (failed != 0)
+		printf("FAILURE: %u out of %u tests failed.\n", failed, total);
+	else
+		printf("Success: %u tests passed.\n", total);
+
+	return failed;
+}
+
+#ifdef _WIN32_WCE
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
+{
+	return main(0, NULL);
+}
+#endif

package/thirdparty/pugixml/tests/test.cpp

@@ -0,0 +1,220 @@
+#define _SCL_SECURE_NO_WARNINGS
+#define _SCL_SECURE_NO_DEPRECATE
+
+#include "test.hpp"
+
+#include "writer_string.hpp"
+
+#include <math.h>
+#include <float.h>
+#include <string.h>
+#include <wchar.h>
+
+#include <algorithm>
+#include <vector>
+
+#ifndef PUGIXML_NO_XPATH
+static void build_document_order(std::vector<pugi::xpath_node>& result, pugi::xml_node root)
+{
+	result.push_back(pugi::xpath_node());
+
+	pugi::xml_node cur = root;
+
+	for (;;)
+	{
+		result.push_back(cur);
+
+		for (pugi::xml_attribute a = cur.first_attribute(); a; a = a.next_attribute())
+			result.push_back(pugi::xpath_node(a, cur));
+
+		if (cur.first_child())
+			cur = cur.first_child();
+		else if (cur.next_sibling())
+			cur = cur.next_sibling();
+		else
+		{
+			while (cur && !cur.next_sibling()) cur = cur.parent();
+			cur = cur.next_sibling();
+
+			if (!cur) break;
+		}
+	}
+}
+#endif
+
+bool test_string_equal(const pugi::char_t* lhs, const pugi::char_t* rhs)
+{
+	return (!lhs || !rhs) ? lhs == rhs :
+	#ifdef PUGIXML_WCHAR_MODE
+		wcscmp(lhs, rhs) == 0;
+	#else
+		strcmp(lhs, rhs) == 0;
+	#endif
+}
+
+bool test_node(const pugi::xml_node& node, const pugi::char_t* contents, const pugi::char_t* indent, unsigned int flags)
+{
+	xml_writer_string writer;
+
+	node.print(writer, indent, flags, get_native_encoding());
+
+	return writer.as_string() == contents;
+}
+
+bool test_double_nan(double value)
+{
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+	return _isnan(value) != 0;
+#else
+	return value != value;
+#endif
+}
+
+#ifndef PUGIXML_NO_XPATH
+static size_t strlength(const pugi::char_t* s)
+{
+#ifdef PUGIXML_WCHAR_MODE
+	return wcslen(s);
+#else
+	return strlen(s);
+#endif
+}
+
+bool test_xpath_string(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, const pugi::char_t* expected)
+{
+	pugi::xpath_query q(query, variables);
+	if (!q) return false;
+
+	const size_t capacity = 64;
+	pugi::char_t result[capacity];
+
+	size_t size = q.evaluate_string(result, capacity, node);
+
+	if (size != strlength(expected) + 1)
+		return false;
+
+	if (size <= capacity)
+		return test_string_equal(result, expected);
+
+	std::basic_string<pugi::char_t> buffer(size, ' ');
+
+	return q.evaluate_string(&buffer[0], size, node) == size && test_string_equal(buffer.c_str(), expected);
+}
+
+bool test_xpath_boolean(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, bool expected)
+{
+	pugi::xpath_query q(query, variables);
+	if (!q) return false;
+
+	return q.evaluate_boolean(node) == expected;
+}
+
+bool test_xpath_number(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, double expected)
+{
+	pugi::xpath_query q(query, variables);
+	if (!q) return false;
+
+	double value = q.evaluate_number(node);
+	double absolute_error = fabs(value - expected);
+
+	const double tolerance = 1e-15;
+	return absolute_error < tolerance || absolute_error < fabs(expected) * tolerance;
+}
+
+bool test_xpath_number_nan(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables)
+{
+	pugi::xpath_query q(query, variables);
+	if (!q) return false;
+
+	return test_double_nan(q.evaluate_number(node));
+}
+
+bool test_xpath_fail_compile(const pugi::char_t* query, pugi::xpath_variable_set* variables)
+{
+#ifdef PUGIXML_NO_EXCEPTIONS
+	return !pugi::xpath_query(query, variables);
+#else
+	try
+	{
+		pugi::xpath_query q(query, variables);
+		return false;
+	}
+	catch (const pugi::xpath_exception&)
+	{
+		return true;
+	}
+#endif
+}
+
+void xpath_node_set_tester::check(bool condition)
+{
+	if (!condition)
+	{
+		test_runner::_failure_message = message;
+		longjmp(test_runner::_failure_buffer, 1);
+	}
+}
+
+xpath_node_set_tester::xpath_node_set_tester(const pugi::xpath_node_set& set, const char* message_): last(0), message(message_)
+{
+	result = set;
+
+	// only sort unsorted sets so that we're able to verify reverse order for some axes
+	if (result.type() == pugi::xpath_node_set::type_unsorted) result.sort();
+
+	if (result.empty())
+	{
+		document_order = 0;
+		document_size = 0;
+	}
+	else
+	{
+		std::vector<pugi::xpath_node> order;
+		build_document_order(order, (result[0].attribute() ? result[0].parent() : result[0].node()).root());
+
+		document_order = new pugi::xpath_node[order.size()];
+		std::copy(order.begin(), order.end(), document_order);
+
+		document_size = order.size();
+	}
+}
+
+xpath_node_set_tester::~xpath_node_set_tester()
+{
+	// check that we processed everything
+	check(last == result.size());
+
+	delete[] document_order;
+}
+
+xpath_node_set_tester& xpath_node_set_tester::operator%(unsigned int expected)
+{
+	// check element count
+	check(last < result.size());
+
+	// check document order
+	check(expected < document_size);
+	check(result.begin()[last] == document_order[expected]);
+
+	// continue to the next element
+	last++;
+
+	return *this;
+}
+
+#endif
+
+bool is_little_endian()
+{
+	unsigned int ui = 1;
+	return *reinterpret_cast<char*>(&ui) == 1;
+}
+
+pugi::xml_encoding get_native_encoding()
+{
+#ifdef PUGIXML_WCHAR_MODE
+	return pugi::encoding_wchar;
+#else
+	return pugi::encoding_utf8;
+#endif
+}

package/thirdparty/pugixml/tests/test.hpp

@@ -0,0 +1,175 @@
+#ifndef HEADER_TEST_TEST_HPP
+#define HEADER_TEST_TEST_HPP
+
+#include "../src/pugixml.hpp"
+
+#include <setjmp.h>
+
+#ifndef PUGIXML_NO_EXCEPTIONS
+#include <new>
+#endif
+
+struct test_runner
+{
+	test_runner(const char* name)
+	{
+		_name = name;
+		_next = _tests;
+		_tests = this;
+	}
+
+	virtual ~test_runner() {}
+
+	virtual void run() = 0;
+
+	const char* _name;
+	test_runner* _next;
+
+	static test_runner* _tests;
+	static size_t _memory_fail_threshold;
+	static bool _memory_fail_triggered;
+	static jmp_buf _failure_buffer;
+	static const char* _failure_message;
+
+	static const char* _temp_path;
+};
+
+bool test_string_equal(const pugi::char_t* lhs, const pugi::char_t* rhs);
+
+template <typename Node> inline bool test_node_name_value(const Node& node, const pugi::char_t* name, const pugi::char_t* value)
+{
+	return test_string_equal(node.name(), name) && test_string_equal(node.value(), value);
+}
+
+bool test_node(const pugi::xml_node& node, const pugi::char_t* contents, const pugi::char_t* indent, unsigned int flags);
+bool test_double_nan(double value);
+
+#ifndef PUGIXML_NO_XPATH
+bool test_xpath_string(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, const pugi::char_t* expected);
+bool test_xpath_boolean(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, bool expected);
+bool test_xpath_number(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, double expected);
+bool test_xpath_number_nan(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables);
+
+bool test_xpath_fail_compile(const pugi::char_t* query, pugi::xpath_variable_set* variables);
+
+struct xpath_node_set_tester
+{
+	pugi::xpath_node* document_order;
+	size_t document_size;
+
+	pugi::xpath_node_set result;
+	unsigned int last;
+	const char* message;
+
+	void check(bool condition);
+
+	xpath_node_set_tester(const pugi::xpath_node_set& set, const char* message);
+	~xpath_node_set_tester();
+
+	xpath_node_set_tester& operator%(unsigned int expected);
+};
+
+#endif
+
+struct dummy_fixture {};
+
+#define TEST_FIXTURE(name, fixture) \
+	struct test_runner_helper_##name: fixture \
+	{ \
+		void run(); \
+	}; \
+	static struct test_runner_##name: test_runner \
+	{ \
+		test_runner_##name(): test_runner(#name) {} \
+		\
+		virtual void run() PUGIXML_OVERRIDE \
+		{ \
+			test_runner_helper_##name helper; \
+			helper.run(); \
+		} \
+	} test_runner_instance_##name; \
+	void test_runner_helper_##name::run()
+
+#define TEST(name) TEST_FIXTURE(name, dummy_fixture)
+
+#define TEST_XML_FLAGS(name, xml, flags) \
+	struct test_fixture_##name \
+	{ \
+		pugi::xml_document doc; \
+		\
+		test_fixture_##name() \
+		{ \
+			CHECK(doc.load_string(PUGIXML_TEXT(xml), flags)); \
+		} \
+		\
+	private: \
+		test_fixture_##name(const test_fixture_##name&); \
+		test_fixture_##name& operator=(const test_fixture_##name&); \
+	}; \
+	\
+	TEST_FIXTURE(name, test_fixture_##name)
+
+#define TEST_XML(name, xml) TEST_XML_FLAGS(name, xml, pugi::parse_default)
+
+#define CHECK_JOIN(text, file, line) text " at " file ":" #line
+#define CHECK_JOIN2(text, file, line) CHECK_JOIN(text, file, line)
+#define CHECK_TEXT(condition, text) if (condition) ; else test_runner::_failure_message = CHECK_JOIN2(text, __FILE__, __LINE__), longjmp(test_runner::_failure_buffer, 1)
+#define CHECK_FORCE_FAIL(text) test_runner::_failure_message = CHECK_JOIN2(text, __FILE__, __LINE__), longjmp(test_runner::_failure_buffer, 1)
+
+#if (defined(_MSC_VER) && _MSC_VER == 1200) || defined(__MWERKS__) || (defined(__BORLANDC__) && __BORLANDC__ <= 0x540)
+#	define STRINGIZE(value) "??" // Some compilers have issues with stringizing expressions that contain strings w/escaping inside
+#else
+#	define STRINGIZE(value) #value
+#endif
+
+#define CHECK(condition) CHECK_TEXT(condition, STRINGIZE(condition) " is false")
+#define CHECK_STRING(value, expected) CHECK_TEXT(test_string_equal(value, expected), STRINGIZE(value) " is not equal to " STRINGIZE(expected))
+#define CHECK_DOUBLE(value, expected) CHECK_TEXT((value > expected ? value - expected : expected - value) < 1e-6, STRINGIZE(value) " is not equal to " STRINGIZE(expected))
+#define CHECK_DOUBLE_NAN(value) CHECK_TEXT(test_double_nan(value), STRINGIZE(value) " is not equal to NaN")
+#define CHECK_NAME_VALUE(node, name, value) CHECK_TEXT(test_node_name_value(node, name, value), STRINGIZE(node) " name/value do not match " STRINGIZE(name) " and " STRINGIZE(value))
+#define CHECK_NODE_EX(node, expected, indent, flags) CHECK_TEXT(test_node(node, expected, indent, flags), STRINGIZE(node) " contents does not match " STRINGIZE(expected))
+#define CHECK_NODE(node, expected) CHECK_NODE_EX(node, expected, PUGIXML_TEXT(""), pugi::format_raw)
+
+#ifndef PUGIXML_NO_XPATH
+#define CHECK_XPATH_STRING_VAR(node, query, variables, expected) CHECK_TEXT(test_xpath_string(node, query, variables, expected), STRINGIZE(query) " does not evaluate to " STRINGIZE(expected) " in context " STRINGIZE(node))
+#define CHECK_XPATH_BOOLEAN_VAR(node, query, variables, expected) CHECK_TEXT(test_xpath_boolean(node, query, variables, expected), STRINGIZE(query) " does not evaluate to " STRINGIZE(expected) " in context " STRINGIZE(node))
+#define CHECK_XPATH_NUMBER_VAR(node, query, variables, expected) CHECK_TEXT(test_xpath_number(node, query, variables, expected), STRINGIZE(query) " does not evaluate to " STRINGIZE(expected) " in context " STRINGIZE(node))
+#define CHECK_XPATH_NUMBER_NAN_VAR(node, query, variables) CHECK_TEXT(test_xpath_number_nan(node, query, variables), STRINGIZE(query) " does not evaluate to NaN in context " STRINGIZE(node))
+#define CHECK_XPATH_NODESET_VAR(node, query, variables) xpath_node_set_tester(pugi::xpath_query(query, variables).evaluate_node_set(node), CHECK_JOIN2(STRINGIZE(query) " does not evaluate to expected set in context " STRINGIZE(node), __FILE__, __LINE__))
+#define CHECK_XPATH_FAIL_VAR(query, variables) CHECK_TEXT(test_xpath_fail_compile(query, variables), STRINGIZE(query) " should not compile")
+
+#define CHECK_XPATH_STRING(node, query, expected) CHECK_XPATH_STRING_VAR(node, query, 0, expected)
+#define CHECK_XPATH_BOOLEAN(node, query, expected) CHECK_XPATH_BOOLEAN_VAR(node, query, 0, expected)
+#define CHECK_XPATH_NUMBER(node, query, expected) CHECK_XPATH_NUMBER_VAR(node, query, 0, expected)
+#define CHECK_XPATH_NUMBER_NAN(node, query) CHECK_XPATH_NUMBER_NAN_VAR(node, query, 0)
+#define CHECK_XPATH_NODESET(node, query) CHECK_XPATH_NODESET_VAR(node, query, 0)
+#define CHECK_XPATH_FAIL(query) CHECK_XPATH_FAIL_VAR(query, 0)
+#endif
+
+#ifdef PUGIXML_NO_EXCEPTIONS
+#define CHECK_ALLOC_FAIL(code) do { CHECK(!test_runner::_memory_fail_triggered); code; CHECK(test_runner::_memory_fail_triggered); test_runner::_memory_fail_triggered = false; } while (test_runner::_memory_fail_triggered)
+#else
+#define CHECK_ALLOC_FAIL(code) do { CHECK(!test_runner::_memory_fail_triggered); try { code; } catch (std::bad_alloc&) {} CHECK(test_runner::_memory_fail_triggered); test_runner::_memory_fail_triggered = false; } while (test_runner::_memory_fail_triggered)
+#endif
+
+#define STR(text) PUGIXML_TEXT(text)
+
+#if defined(__DMC__) || defined(__BORLANDC__)
+#define U_LITERALS // DMC does not understand \x01234 (it parses first three digits), but understands \u01234
+#endif
+
+#if (defined(_MSC_VER) && _MSC_VER == 1200) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER == 800) || defined(__BORLANDC__)
+// NaN comparison on MSVC6 is incorrect, see http://www.nabble.com/assertDoubleEquals,-NaN---Microsoft-Visual-Studio-6-td9137859.html
+// IC8 and BCC are also affected by the same bug
+#	define MSVC6_NAN_BUG
+#endif
+
+inline wchar_t wchar_cast(unsigned int value)
+{
+	return static_cast<wchar_t>(value); // to avoid C4310 on MSVC
+}
+
+bool is_little_endian();
+pugi::xml_encoding get_native_encoding();
+
+#endif