FreeCAD / tests /src /App /ComplexGeoData.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

13 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

#include <gtest/gtest.h>

#include <array>
#include <boost/core/ignore_unused.hpp>

#include <App/Application.h>
#include <App/ComplexGeoData.h>
#include <Base/BoundBox.h>
#include <Base/Writer.h>
#include <src/App/InitApplication.h>


class ConcreteComplexGeoDataForTesting: public Data::ComplexGeoData
{
public:
    std::vector<const char*> getElementTypes() const override
    {
        return {"EDGE"};
    }

    unsigned long countSubElements(const char* Type) const override
    {
        (void)Type;
        return 0;
    }

    Data::Segment* getSubElement(const char* Type, unsigned long number) const override
    {
        (void)number;
        (void)Type;
        return nullptr;
    }

    void setTransform(const Base::Matrix4D& rclTrf) override
    {
        (void)rclTrf;
    }

    Base::Matrix4D getTransform() const override
    {
        return {};
    }

    void transformGeometry(const Base::Matrix4D& rclMat) override
    {
        (void)rclMat;
    }

    Base::BoundBox3d getBoundBox() const override
    {
        return Base::BoundBox3d();
    }
};

class ComplexGeoDataTest: public ::testing::Test
{
protected:
    static void SetUpTestSuite()
    {
        tests::initApplication();
    }

    void SetUp() override
    {
        _docName = App::GetApplication().getUniqueDocumentName("test");
        App::GetApplication().newDocument(_docName.c_str(), "testUser");
    }

    void TearDown() override
    {
        App::GetApplication().closeDocument(_docName.c_str());
    }

    ConcreteComplexGeoDataForTesting& cgd()
    {
        return _complexGeoData;
    }

    std::tuple<Data::IndexedName, Data::MappedName> createMappedName(const std::string& name)
    {
        auto elementMap = std::make_shared<Data::ElementMap>();
        cgd().resetElementMap(elementMap);
        auto mappedName = Data::MappedName(name.c_str());
        auto indexedName = Data::IndexedName(_complexGeoData.getElementTypes().front(), 1);
        elementMap->setElementName(indexedName, mappedName, 0);
        return std::make_tuple(indexedName, mappedName);
    }

private:
    ConcreteComplexGeoDataForTesting _complexGeoData;
    std::string _docName;
};

// NOLINTBEGIN(readability-magic-numbers)

TEST_F(ComplexGeoDataTest, getIndexedNameNoName)  // NOLINT
{
    // Arrange & Act
    auto result = cgd().getIndexedName(Data::MappedName());

    // Assert
    EXPECT_FALSE(result);
}

TEST_F(ComplexGeoDataTest, getIndexedNameNoElementMap)  // NOLINT
{
    // Arrange & Act
    auto result = cgd().getIndexedName(Data::MappedName("TestName"));

    // Assert
    EXPECT_TRUE(result);
}

TEST_F(ComplexGeoDataTest, getMappedNameNoElement)  // NOLINT
{
    // Arrange & Act
    auto result = cgd().getMappedName(Data::IndexedName {});

    // Assert
    EXPECT_FALSE(result);
}

TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedNoMap)  // NOLINT
{
    // Arrange & Act
    auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, false);

    // Assert
    EXPECT_FALSE(result);
}

TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedWithMap)  // NOLINT
{
    // Arrange
    auto elementMap = std::make_shared<Data::ElementMap>();
    cgd().resetElementMap(elementMap);
    auto mappedName = Data::MappedName("TestMappedName");
    auto indexedName = Data::IndexedName("EDGE", 1);
    elementMap->setElementName(indexedName, mappedName, 0);

    // Act
    auto result = cgd().getMappedName(indexedName, false);

    // Assert
    EXPECT_TRUE(result);
    EXPECT_EQ(mappedName, result);
}

TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedMissingFromMap)  // NOLINT
{
    // Arrange
    auto mappedName = Data::MappedName("NotTheTestName");
    cgd().getIndexedName(mappedName);  // Put it in the map

    // Act
    auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, false);

    // Assert
    EXPECT_FALSE(result);
}

TEST_F(ComplexGeoDataTest, getMappedNameAllowUnmapped)  // NOLINT
{
    // Arrange & Act
    auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, true);

    // Assert
    EXPECT_TRUE(result);
}

TEST_F(ComplexGeoDataTest, getElementNameGivenIndexedName)  // NOLINT
{
    // Arrange
    const char* name {"EDGE123"};
    auto indexedName = cgd().getIndexedName(Data::MappedName(name));

    // Act
    auto result = cgd().getElementName(name);

    // Assert
    EXPECT_EQ(result.index, indexedName);
}

TEST_F(ComplexGeoDataTest, getElementNameGivenMappedName)  // NOLINT
{
    // Arrange
    const char* name {"EDGE123"};
    auto mappedName = cgd().getMappedName(Data::IndexedName(name));

    // Act
    auto result = cgd().getElementName(name);

    // Assert
    EXPECT_EQ(result.name, mappedName);
}

TEST_F(ComplexGeoDataTest, getElementMappedNamesNoMapNoUnmapped)  // NOLINT
{
    // Arrange
    // Do not create an element map
    auto indexedName = Data::IndexedName("EDGE1");

    // Act
    auto result = cgd().getElementMappedNames(indexedName, false);

    // Assert
    EXPECT_TRUE(result.empty());
}

TEST_F(ComplexGeoDataTest, getElementMappedNamesWithMapNoUnmapped)  // NOLINT
{
    // Arrange
    auto elementMap = std::make_shared<Data::ElementMap>();
    cgd().resetElementMap(elementMap);
    auto mappedName = Data::MappedName("TestMappedName");
    auto indexedName = Data::IndexedName("EDGE", 1);
    elementMap->setElementName(indexedName, mappedName, 0);

    // Act
    auto result = cgd().getElementMappedNames(indexedName, false);

    // Assert
    EXPECT_FALSE(result.empty());
    EXPECT_EQ(result[0].first, mappedName);
}

TEST_F(ComplexGeoDataTest, getElementMappedNamesNoMapWithUnmapped)  // NOLINT
{
    // Do not create an element map
    auto indexedName = Data::IndexedName("EDGE1");

    // Act
    auto result = cgd().getElementMappedNames(indexedName, true);

    // Assert
    EXPECT_FALSE(result.empty());
}


TEST_F(ComplexGeoDataTest, getElementMappedNamesWithMapWithUnmapped)  // NOLINT
{
    // Arrange
    Data::MappedName mappedName;
    Data::IndexedName indexedName;
    std::tie(indexedName, mappedName) = createMappedName("TestMappedName");
    auto unmappedName = Data::IndexedName("EDGE", 2);

    // Act
    auto result = cgd().getElementMappedNames(unmappedName, true);

    // Assert
    EXPECT_FALSE(result.empty());
    EXPECT_NE(result[0].first, mappedName);
}

TEST_F(ComplexGeoDataTest, elementTypeValidIndexName)  // NOLINT
{
    // Arrange
    auto indexedName = Data::IndexedName("EDGE", 1);

    // Act
    char elementType = cgd().elementType(indexedName);

    // Assert
    EXPECT_EQ(elementType, 'E');
}

TEST_F(ComplexGeoDataTest, elementTypeInvalidIndexedName)  // NOLINT
{
    // Arrange
    auto indexedName = Data::IndexedName("INVALID", 1);  // Not in the element type list

    // Act
    char elementType = cgd().elementType(indexedName);

    // Assert
    EXPECT_EQ(elementType, 0);
}

TEST_F(ComplexGeoDataTest, elementTypeCharEmptyName)  // NOLINT
{
    // Arrange & Act
    char elementType = cgd().elementType(nullptr);

    // Assert
    EXPECT_EQ(elementType, 0);
}

TEST_F(ComplexGeoDataTest, elementTypeCharIndexedName)  // NOLINT
{
    // Arrange & Act
    char elementType = cgd().elementType("EDGE1");

    // Assert
    EXPECT_EQ(elementType, 'E');
}

TEST_F(ComplexGeoDataTest, elementTypeCharMappedNameNoPrefix)  // NOLINT
{
    // Arrange
    int size {0};
    Data::MappedName mappedName;
    Data::IndexedName indexedName;
    std::tie(indexedName, mappedName) = createMappedName("TestMappedName:;");

    // Act
    char elementType = cgd().elementType(mappedName.toConstString(0, size));

    // Assert
    EXPECT_EQ(elementType, 'E');
}

TEST_F(ComplexGeoDataTest, elementTypeCharMappedNameWithPrefix)  // NOLINT
{
    // Arrange
    int size {0};
    Data::MappedName mappedName;
    Data::IndexedName indexedName;
    std::string name(Data::ELEMENT_MAP_PREFIX);
    name.append("TestMappedElement:;");
    std::tie(indexedName, mappedName) = createMappedName(name);

    // Act
    char elementType = cgd().elementType(mappedName.toConstString(0, size));

    // Assert
    EXPECT_EQ(elementType, 'E');
}

TEST_F(ComplexGeoDataTest, resetElementMapNoArgument)  // NOLINT
{
    // Arrange & Act
    cgd().resetElementMap();

    // Assert
    EXPECT_EQ(cgd().getElementMapSize(), 0);
}

TEST_F(ComplexGeoDataTest, resetElementMapWithArgument)  // NOLINT
{
    // Arrange
    auto elementMap = std::make_shared<Data::ElementMap>();
    auto mappedName = Data::MappedName("TestMappedName");
    auto indexedName = Data::IndexedName("EDGE", 1);
    elementMap->setElementName(indexedName, mappedName, 0);

    // Act
    cgd().resetElementMap(elementMap);

    // Assert
    EXPECT_EQ(cgd().getElementMapSize(), 1);
}

TEST_F(ComplexGeoDataTest, setAndGetElementMap)  // NOLINT
{
    // Arrange
    auto elementMap = std::make_shared<Data::ElementMap>();
    cgd().resetElementMap(elementMap);
    std::vector<Data::MappedElement> vecMappedElements;
    auto mappedNameA = Data::MappedName("TestMappedNameA");
    auto indexedNameA = Data::IndexedName("EDGE", 1);
    vecMappedElements.emplace_back(indexedNameA, mappedNameA);
    auto mappedNameB = Data::MappedName("TestMappedNameB");
    auto indexedNameB = Data::IndexedName("EDGE", 2);
    vecMappedElements.emplace_back(indexedNameB, mappedNameB);

    // Act
    auto emptyElementMap = cgd().getElementMap();
    cgd().setElementMap(vecMappedElements);
    auto resultingElementMap = cgd().getElementMap();

    // Assert
    EXPECT_TRUE(emptyElementMap.empty());
    EXPECT_EQ(resultingElementMap.size(), vecMappedElements.size());
}

TEST_F(ComplexGeoDataTest, getElementMapSize)  // NOLINT
{
    // Arrange
    auto elementMap = std::make_shared<Data::ElementMap>();
    auto mappedName = Data::MappedName("TestMappedName");
    auto indexedName = Data::IndexedName("EDGE", 1);
    elementMap->setElementName(indexedName, mappedName, 0);
    cgd().resetElementMap(elementMap);

    // Act
    auto result = cgd().getElementMapSize();

    // Assert
    EXPECT_EQ(result, 1);
}

TEST_F(ComplexGeoDataTest, flushElementMap)  // NOLINT
{
    // Does nothing in the base class
}

TEST_F(ComplexGeoDataTest, saveWithNoElementMap)  // NOLINT
{
    // Arrange
    Base::StringWriter writer;
    cgd().resetElementMap();

    // Act
    cgd().Save(writer);

    // Assert - With no element map, that element of the XML is empty
    EXPECT_TRUE(writer.getString().find("<ElementMap/>") != std::string::npos);
}

TEST_F(ComplexGeoDataTest, saveWithElementMap)
{
    // Arrange
    Base::StringWriter writer;
    auto map = createMappedName("SomeElement");

    // Act
    cgd().Save(writer);

    // Assert
    EXPECT_TRUE(writer.getString().find("<ElementMap ") != std::string::npos);
    EXPECT_TRUE(writer.getString().find("<ElementMap2 ") != std::string::npos);
    EXPECT_TRUE(writer.getString().find(" file=") == std::string::npos);  // No persistence name set
    // TODO: assert that the elementmap was written in "raw" mode
}

TEST_F(ComplexGeoDataTest, saveWithPersistenceFilename)
{
    // Arrange
    Base::StringWriter writer;
    auto map = createMappedName("SomeElement");
    cgd().setPersistenceFileName("some_file_name.txt");

    // Act
    cgd().Save(writer);

    // Assert
    EXPECT_TRUE(writer.getString().find(" file=") != std::string::npos);
    EXPECT_TRUE(writer.getString().find("some_file_name.txt") != std::string::npos);
}

TEST_F(ComplexGeoDataTest, saveDocFileWithNoElementMap)
{
    // Arrange
    Base::StringWriter writer;
    cgd().resetElementMap(nullptr);  // Force undefined map

    // Act
    cgd().SaveDocFile(writer);

    // Assert -- no element map tag if no element map
    EXPECT_TRUE(writer.getString().find("BeginElementMap") == std::string::npos);
}

TEST_F(ComplexGeoDataTest, saveDocFileWithElementMap)
{
    // Arrange
    Base::StringWriter writer;
    auto map = createMappedName("SomeElement");

    // Act
    cgd().SaveDocFile(writer);

    // Assert -- must begin a v1 ElementMap
    EXPECT_TRUE(writer.getString().find("BeginElementMap v1") != std::string::npos);
}

TEST_F(ComplexGeoDataTest, restoreStream)
{}

TEST_F(ComplexGeoDataTest, traceElement)
{  // This test barely scratches the surface; see the ToposhapeExtension traceElement test for more
    Data::MappedName mappedName;
    Data::IndexedName indexedName;
    std::string name(Data::ELEMENT_MAP_PREFIX);
    name.append("TestMappedElement:;");
    std::tie(indexedName, mappedName) = createMappedName(name);

    // Arrange
    Data::TraceCallback cb =
        [name](const Data::MappedName& elementname, int offset, long encodedTag, long tag) {
            boost::ignore_unused(offset);
            boost::ignore_unused(encodedTag);
            boost::ignore_unused(tag);
            EXPECT_STREQ(elementname.toString().c_str(), name.substr(1).c_str());
            return false;
        };
    // Act
    cgd().traceElement(mappedName, cb);
}

// NOLINTEND(readability-magic-numbers)

	// SPDX-License-Identifier: LGPL-2.1-or-later

	#include <gtest/gtest.h>

	#include <array>
	#include <boost/core/ignore_unused.hpp>

	#include <App/Application.h>
	#include <App/ComplexGeoData.h>
	#include <Base/BoundBox.h>
	#include <Base/Writer.h>
	#include <src/App/InitApplication.h>


	class ConcreteComplexGeoDataForTesting: public Data::ComplexGeoData
	{
	public:
	std::vector<const char*> getElementTypes() const override
	{
	return {"EDGE"};
	}

	unsigned long countSubElements(const char* Type) const override
	{
	(void)Type;
	return 0;
	}

	Data::Segment* getSubElement(const char* Type, unsigned long number) const override
	{
	(void)number;
	(void)Type;
	return nullptr;
	}

	void setTransform(const Base::Matrix4D& rclTrf) override
	{
	(void)rclTrf;
	}

	Base::Matrix4D getTransform() const override
	{
	return {};
	}

	void transformGeometry(const Base::Matrix4D& rclMat) override
	{
	(void)rclMat;
	}

	Base::BoundBox3d getBoundBox() const override
	{
	return Base::BoundBox3d();
	}
	};

	class ComplexGeoDataTest: public ::testing::Test
	{
	protected:
	static void SetUpTestSuite()
	{
	tests::initApplication();
	}

	void SetUp() override
	{
	_docName = App::GetApplication().getUniqueDocumentName("test");
	App::GetApplication().newDocument(_docName.c_str(), "testUser");
	}

	void TearDown() override
	{
	App::GetApplication().closeDocument(_docName.c_str());
	}

	ConcreteComplexGeoDataForTesting& cgd()
	{
	return _complexGeoData;
	}

	std::tuple<Data::IndexedName, Data::MappedName> createMappedName(const std::string& name)
	{
	auto elementMap = std::make_shared<Data::ElementMap>();
	cgd().resetElementMap(elementMap);
	auto mappedName = Data::MappedName(name.c_str());
	auto indexedName = Data::IndexedName(_complexGeoData.getElementTypes().front(), 1);
	elementMap->setElementName(indexedName, mappedName, 0);
	return std::make_tuple(indexedName, mappedName);
	}

	private:
	ConcreteComplexGeoDataForTesting _complexGeoData;
	std::string _docName;
	};

	// NOLINTBEGIN(readability-magic-numbers)

	TEST_F(ComplexGeoDataTest, getIndexedNameNoName) // NOLINT
	{
	// Arrange & Act
	auto result = cgd().getIndexedName(Data::MappedName());

	// Assert
	EXPECT_FALSE(result);
	}

	TEST_F(ComplexGeoDataTest, getIndexedNameNoElementMap) // NOLINT
	{
	// Arrange & Act
	auto result = cgd().getIndexedName(Data::MappedName("TestName"));

	// Assert
	EXPECT_TRUE(result);
	}

	TEST_F(ComplexGeoDataTest, getMappedNameNoElement) // NOLINT
	{
	// Arrange & Act
	auto result = cgd().getMappedName(Data::IndexedName {});

	// Assert
	EXPECT_FALSE(result);
	}

	TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedNoMap) // NOLINT
	{
	// Arrange & Act
	auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, false);

	// Assert
	EXPECT_FALSE(result);
	}

	TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedWithMap) // NOLINT
	{
	// Arrange
	auto elementMap = std::make_shared<Data::ElementMap>();
	cgd().resetElementMap(elementMap);
	auto mappedName = Data::MappedName("TestMappedName");
	auto indexedName = Data::IndexedName("EDGE", 1);
	elementMap->setElementName(indexedName, mappedName, 0);

	// Act
	auto result = cgd().getMappedName(indexedName, false);

	// Assert
	EXPECT_TRUE(result);
	EXPECT_EQ(mappedName, result);
	}

	TEST_F(ComplexGeoDataTest, getMappedNameDisallowUnmappedMissingFromMap) // NOLINT
	{
	// Arrange
	auto mappedName = Data::MappedName("NotTheTestName");
	cgd().getIndexedName(mappedName); // Put it in the map

	// Act
	auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, false);

	// Assert
	EXPECT_FALSE(result);
	}

	TEST_F(ComplexGeoDataTest, getMappedNameAllowUnmapped) // NOLINT
	{
	// Arrange & Act
	auto result = cgd().getMappedName(Data::IndexedName {"TestName"}, true);

	// Assert
	EXPECT_TRUE(result);
	}

	TEST_F(ComplexGeoDataTest, getElementNameGivenIndexedName) // NOLINT
	{
	// Arrange
	const char* name {"EDGE123"};
	auto indexedName = cgd().getIndexedName(Data::MappedName(name));

	// Act
	auto result = cgd().getElementName(name);

	// Assert
	EXPECT_EQ(result.index, indexedName);
	}

	TEST_F(ComplexGeoDataTest, getElementNameGivenMappedName) // NOLINT
	{
	// Arrange
	const char* name {"EDGE123"};
	auto mappedName = cgd().getMappedName(Data::IndexedName(name));

	// Act
	auto result = cgd().getElementName(name);

	// Assert
	EXPECT_EQ(result.name, mappedName);
	}

	TEST_F(ComplexGeoDataTest, getElementMappedNamesNoMapNoUnmapped) // NOLINT
	{
	// Arrange
	// Do not create an element map
	auto indexedName = Data::IndexedName("EDGE1");

	// Act
	auto result = cgd().getElementMappedNames(indexedName, false);

	// Assert
	EXPECT_TRUE(result.empty());
	}

	TEST_F(ComplexGeoDataTest, getElementMappedNamesWithMapNoUnmapped) // NOLINT
	{
	// Arrange
	auto elementMap = std::make_shared<Data::ElementMap>();
	cgd().resetElementMap(elementMap);
	auto mappedName = Data::MappedName("TestMappedName");
	auto indexedName = Data::IndexedName("EDGE", 1);
	elementMap->setElementName(indexedName, mappedName, 0);

	// Act
	auto result = cgd().getElementMappedNames(indexedName, false);

	// Assert
	EXPECT_FALSE(result.empty());
	EXPECT_EQ(result[0].first, mappedName);
	}

	TEST_F(ComplexGeoDataTest, getElementMappedNamesNoMapWithUnmapped) // NOLINT
	{
	// Do not create an element map
	auto indexedName = Data::IndexedName("EDGE1");

	// Act
	auto result = cgd().getElementMappedNames(indexedName, true);

	// Assert
	EXPECT_FALSE(result.empty());
	}


	TEST_F(ComplexGeoDataTest, getElementMappedNamesWithMapWithUnmapped) // NOLINT
	{
	// Arrange
	Data::MappedName mappedName;
	Data::IndexedName indexedName;
	std::tie(indexedName, mappedName) = createMappedName("TestMappedName");
	auto unmappedName = Data::IndexedName("EDGE", 2);

	// Act
	auto result = cgd().getElementMappedNames(unmappedName, true);

	// Assert
	EXPECT_FALSE(result.empty());
	EXPECT_NE(result[0].first, mappedName);
	}

	TEST_F(ComplexGeoDataTest, elementTypeValidIndexName) // NOLINT
	{
	// Arrange
	auto indexedName = Data::IndexedName("EDGE", 1);

	// Act
	char elementType = cgd().elementType(indexedName);

	// Assert
	EXPECT_EQ(elementType, 'E');
	}

	TEST_F(ComplexGeoDataTest, elementTypeInvalidIndexedName) // NOLINT
	{
	// Arrange
	auto indexedName = Data::IndexedName("INVALID", 1); // Not in the element type list

	// Act
	char elementType = cgd().elementType(indexedName);

	// Assert
	EXPECT_EQ(elementType, 0);
	}

	TEST_F(ComplexGeoDataTest, elementTypeCharEmptyName) // NOLINT
	{
	// Arrange & Act
	char elementType = cgd().elementType(nullptr);

	// Assert
	EXPECT_EQ(elementType, 0);
	}

	TEST_F(ComplexGeoDataTest, elementTypeCharIndexedName) // NOLINT
	{
	// Arrange & Act
	char elementType = cgd().elementType("EDGE1");

	// Assert
	EXPECT_EQ(elementType, 'E');
	}

	TEST_F(ComplexGeoDataTest, elementTypeCharMappedNameNoPrefix) // NOLINT
	{
	// Arrange
	int size {0};
	Data::MappedName mappedName;
	Data::IndexedName indexedName;
	std::tie(indexedName, mappedName) = createMappedName("TestMappedName:;");

	// Act
	char elementType = cgd().elementType(mappedName.toConstString(0, size));

	// Assert
	EXPECT_EQ(elementType, 'E');
	}

	TEST_F(ComplexGeoDataTest, elementTypeCharMappedNameWithPrefix) // NOLINT
	{
	// Arrange
	int size {0};
	Data::MappedName mappedName;
	Data::IndexedName indexedName;
	std::string name(Data::ELEMENT_MAP_PREFIX);
	name.append("TestMappedElement:;");
	std::tie(indexedName, mappedName) = createMappedName(name);

	// Act
	char elementType = cgd().elementType(mappedName.toConstString(0, size));

	// Assert
	EXPECT_EQ(elementType, 'E');
	}

	TEST_F(ComplexGeoDataTest, resetElementMapNoArgument) // NOLINT
	{
	// Arrange & Act
	cgd().resetElementMap();

	// Assert
	EXPECT_EQ(cgd().getElementMapSize(), 0);
	}

	TEST_F(ComplexGeoDataTest, resetElementMapWithArgument) // NOLINT
	{
	// Arrange
	auto elementMap = std::make_shared<Data::ElementMap>();
	auto mappedName = Data::MappedName("TestMappedName");
	auto indexedName = Data::IndexedName("EDGE", 1);
	elementMap->setElementName(indexedName, mappedName, 0);

	// Act
	cgd().resetElementMap(elementMap);

	// Assert
	EXPECT_EQ(cgd().getElementMapSize(), 1);
	}

	TEST_F(ComplexGeoDataTest, setAndGetElementMap) // NOLINT
	{
	// Arrange
	auto elementMap = std::make_shared<Data::ElementMap>();
	cgd().resetElementMap(elementMap);
	std::vector<Data::MappedElement> vecMappedElements;
	auto mappedNameA = Data::MappedName("TestMappedNameA");
	auto indexedNameA = Data::IndexedName("EDGE", 1);
	vecMappedElements.emplace_back(indexedNameA, mappedNameA);
	auto mappedNameB = Data::MappedName("TestMappedNameB");
	auto indexedNameB = Data::IndexedName("EDGE", 2);
	vecMappedElements.emplace_back(indexedNameB, mappedNameB);

	// Act
	auto emptyElementMap = cgd().getElementMap();
	cgd().setElementMap(vecMappedElements);
	auto resultingElementMap = cgd().getElementMap();

	// Assert
	EXPECT_TRUE(emptyElementMap.empty());
	EXPECT_EQ(resultingElementMap.size(), vecMappedElements.size());
	}

	TEST_F(ComplexGeoDataTest, getElementMapSize) // NOLINT
	{
	// Arrange
	auto elementMap = std::make_shared<Data::ElementMap>();
	auto mappedName = Data::MappedName("TestMappedName");
	auto indexedName = Data::IndexedName("EDGE", 1);
	elementMap->setElementName(indexedName, mappedName, 0);
	cgd().resetElementMap(elementMap);

	// Act
	auto result = cgd().getElementMapSize();

	// Assert
	EXPECT_EQ(result, 1);
	}

	TEST_F(ComplexGeoDataTest, flushElementMap) // NOLINT
	{
	// Does nothing in the base class
	}

	TEST_F(ComplexGeoDataTest, saveWithNoElementMap) // NOLINT
	{
	// Arrange
	Base::StringWriter writer;
	cgd().resetElementMap();

	// Act
	cgd().Save(writer);

	// Assert - With no element map, that element of the XML is empty
	EXPECT_TRUE(writer.getString().find("<ElementMap/>") != std::string::npos);
	}

	TEST_F(ComplexGeoDataTest, saveWithElementMap)
	{
	// Arrange
	Base::StringWriter writer;
	auto map = createMappedName("SomeElement");

	// Act
	cgd().Save(writer);

	// Assert
	EXPECT_TRUE(writer.getString().find("<ElementMap ") != std::string::npos);
	EXPECT_TRUE(writer.getString().find("<ElementMap2 ") != std::string::npos);
	EXPECT_TRUE(writer.getString().find(" file=") == std::string::npos); // No persistence name set
	// TODO: assert that the elementmap was written in "raw" mode
	}

	TEST_F(ComplexGeoDataTest, saveWithPersistenceFilename)
	{
	// Arrange
	Base::StringWriter writer;
	auto map = createMappedName("SomeElement");
	cgd().setPersistenceFileName("some_file_name.txt");

	// Act
	cgd().Save(writer);

	// Assert
	EXPECT_TRUE(writer.getString().find(" file=") != std::string::npos);
	EXPECT_TRUE(writer.getString().find("some_file_name.txt") != std::string::npos);
	}

	TEST_F(ComplexGeoDataTest, saveDocFileWithNoElementMap)
	{
	// Arrange
	Base::StringWriter writer;
	cgd().resetElementMap(nullptr); // Force undefined map

	// Act
	cgd().SaveDocFile(writer);

	// Assert -- no element map tag if no element map
	EXPECT_TRUE(writer.getString().find("BeginElementMap") == std::string::npos);
	}

	TEST_F(ComplexGeoDataTest, saveDocFileWithElementMap)
	{
	// Arrange
	Base::StringWriter writer;
	auto map = createMappedName("SomeElement");

	// Act
	cgd().SaveDocFile(writer);

	// Assert -- must begin a v1 ElementMap
	EXPECT_TRUE(writer.getString().find("BeginElementMap v1") != std::string::npos);
	}

	TEST_F(ComplexGeoDataTest, restoreStream)
	{}

	TEST_F(ComplexGeoDataTest, traceElement)
	{ // This test barely scratches the surface; see the ToposhapeExtension traceElement test for more
	Data::MappedName mappedName;
	Data::IndexedName indexedName;
	std::string name(Data::ELEMENT_MAP_PREFIX);
	name.append("TestMappedElement:;");
	std::tie(indexedName, mappedName) = createMappedName(name);

	// Arrange
	Data::TraceCallback cb =
	[name](const Data::MappedName& elementname, int offset, long encodedTag, long tag) {
	boost::ignore_unused(offset);
	boost::ignore_unused(encodedTag);
	boost::ignore_unused(tag);
	EXPECT_STREQ(elementname.toString().c_str(), name.substr(1).c_str());
	return false;
	};
	// Act
	cgd().traceElement(mappedName, cb);
	}

	// NOLINTEND(readability-magic-numbers)