494df1d169
* Part/Toponaming: tests for flushElementMap and resetElementMap * Added test for resetElementMap() * Added test for flushElementMap() * restored ComplexGeoData::resetElementMap to RT fork * modified TopoShape::resetElementMap to match the restored signature of ComplexGeoData::resetElementMap * added checks in TopoShape::makeShapeWithElementMap to avoid segfaults * added check in TopoShape::setElementComboName to avoid segfaults * restored testFindSubShapesForSourceWithTypeAndIndex * modified test saveDocFileWithNoElementMap to match the restored signature of ComplexGeoData::resetElementMap * Part/Toponaming: tests for flushElementMap and resetElementMap * Removed comments in ComplexGeoData::resetElementMap() * Changed TopoShape::resetElementMap():: from virtual to override * Removed comment in TopoShape::resetElementMap() * Added comments about differences between main and RT fork * Removed comment in test saveDocFileWithNoElementMap * Updated expected test result in makeElementCompoundTwoShapesGeneratesMap * Updated expected test result in resetElementMapTest * Fixed typo in test flushElementMapTest * Part/Toponaming: tests for flushElementMap and resetElementMap * updated expected tests results after previous methods modifications --------- Signed-off-by: CalligaroV <vincenzo.calligaro@gmail.com>
473 lines
12 KiB
C++
473 lines
12 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <array>
|
|
|
|
#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)
|
|
{}
|
|
|
|
// NOLINTEND(readability-magic-numbers)
|