Tests: add more unit tests for Points module

src/Mod/Points/App/PointsAlgos.cpp

@@ -197,6 +197,8 @@ AscReader::AscReader() = default;
 void AscReader::read(const std::string& filename)
 {
     points.load(filename.c_str());
+    this->height = 1;
+    this->width = points.size();
 }
 
 // ----------------------------------------------------------------------------
@@ -546,8 +548,6 @@ PlyReader::PlyReader() = default;
 void PlyReader::read(const std::string& filename)
 {
     clear();
-    this->width = 1;
-    this->height = 0;
 
     Base::FileInfo fi(filename);
     Base::ifstream inp(fi, std::ios::in | std::ios::binary);
@@ -559,6 +559,9 @@ void PlyReader::read(const std::string& filename)
     std::size_t offset = 0;
     Eigen::Index numPoints = Eigen::Index(readHeader(inp, format, offset, fields, types, sizes));
 
+    this->width = numPoints;
+    this->height = 1;
+
     Eigen::MatrixXd data(numPoints, fields.size());
     if (format == "ascii") {
         readAscii(inp, offset, data);
@@ -1021,8 +1024,8 @@ PcdReader::PcdReader() = default;
 void PcdReader::read(const std::string& filename)
 {
     clear();
-    this->width = -1;
-    this->height = -1;
+    this->width = 0;
+    this->height = 1;
 
     Base::FileInfo fi(filename);
     Base::ifstream inp(fi, std::ios::in | std::ios::binary);
@@ -1788,6 +1791,8 @@ void E57Reader::read(const std::string& filename)
         normals = reader.getNormals();
         colors = reader.getColors();
         intensity = reader.getItensity();
+        width = points.size();
+        height = 1;
     }
     catch (const Base::BadFormatError&) {
         throw;

src/Mod/Points/App/PointsAlgos.h

@@ -45,7 +45,7 @@ public:
     static void LoadAscii(PointKernel&, const char* FileName);
 };
 
-class Reader
+class PointsExport Reader
 {
 public:
     Reader();
@@ -76,19 +76,19 @@ protected:
     std::vector<float> intensity;
     std::vector<App::Color> colors;
     std::vector<Base::Vector3f> normals;
-    int width {};
-    int height {};
+    int width {0};
+    int height {1};
     // NOLINTEND
 };
 
-class AscReader: public Reader
+class PointsExport AscReader: public Reader
 {
 public:
     AscReader();
     void read(const std::string& filename) override;
 };
 
-class PlyReader: public Reader
+class PointsExport PlyReader: public Reader
 {
 public:
     PlyReader();
@@ -110,7 +110,7 @@ private:
                     Eigen::MatrixXd& data);
 };
 
-class PcdReader: public Reader
+class PointsExport PcdReader: public Reader
 {
 public:
     PcdReader();
@@ -130,7 +130,7 @@ private:
                     Eigen::MatrixXd& data);
 };
 
-class E57Reader: public Reader
+class PointsExport E57Reader: public Reader
 {
 public:
     E57Reader(bool Color, bool State, double Distance);
@@ -141,7 +141,7 @@ protected:
     double minDistance;
 };
 
-class Writer
+class PointsExport Writer
 {
 public:
     explicit Writer(const PointKernel&);
@@ -171,21 +171,21 @@ protected:
     // NOLINTEND
 };
 
-class AscWriter: public Writer
+class PointsExport AscWriter: public Writer
 {
 public:
     explicit AscWriter(const PointKernel&);
     void write(const std::string& filename) override;
 };
 
-class PlyWriter: public Writer
+class PointsExport PlyWriter: public Writer
 {
 public:
     explicit PlyWriter(const PointKernel&);
     void write(const std::string& filename) override;
 };
 
-class PcdWriter: public Writer
+class PointsExport PcdWriter: public Writer
 {
 public:
     explicit PcdWriter(const PointKernel&);

tests/src/Mod/Points/App/Points.cpp

@@ -1,12 +1,241 @@
 #include "gtest/gtest.h"
+#include <Base/FileInfo.h>
 #include <Mod/Points/App/Points.h>
+#include <Mod/Points/App/PointsAlgos.h>
 
 // NOLINTBEGIN(cppcoreguidelines-*,readability-*)
-TEST(Points, TestDefault)
+
+class PointsTest: public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        std::vector<Base::Vector3f> points;
+        points.emplace_back(0, 0, 0);
+        points.emplace_back(0, 0, 1);
+        points.emplace_back(0, 1, 0);
+        points.emplace_back(0, 1, 1);
+        points.emplace_back(1, 0, 0);
+        points.emplace_back(1, 0, 1);
+        points.emplace_back(1, 1, 0);
+        points.emplace_back(1, 1, 1);
+        kernel.setBasicPoints(points);
+
+        tmp.setFile(Base::FileInfo::getTempFileName());
+    }
+
+    void TearDown() override
+    {
+        tmp.deleteFile();
+    }
+
+    const Points::PointKernel& getKernel() const
+    {
+        return kernel;
+    }
+    std::string getFileName() const
+    {
+        return tmp.filePath();
+    }
+    std::vector<float> getIntensity() const
+    {
+        return {0.1F, 0.2F, 0.3F, 0.4F, 0.3F, 0.2F, 0.3F, 0.1F};
+    }
+    std::vector<Base::Vector3f> getNormals() const
+    {
+        std::vector<Base::Vector3f> vec(8, Base::Vector3f(0, 0, 1));
+        return vec;
+    }
+    std::vector<App::Color> getColors() const
+    {
+        std::vector<App::Color> col(8);
+        col[0].set(0, 0, 0);
+        col[1].set(0, 0, 1);
+        col[2].set(0, 1, 0);
+        col[3].set(0, 1, 1);
+        col[4].set(1, 0, 0);
+        col[5].set(1, 0, 1);
+        col[6].set(1, 1, 0);
+        col[7].set(1, 1, 1);
+        return col;
+    }
+
+private:
+    Points::PointKernel kernel;
+    Base::FileInfo tmp;
+};
+
+TEST_F(PointsTest, TestDefault)
 {
     Points::PointKernel kernel;
     std::vector<Points::PointKernel::value_type> points;
     kernel.setBasicPoints(points);
     EXPECT_EQ(kernel.size(), 0);
 }
+
+TEST_F(PointsTest, TestSize)
+{
+    Points::PointKernel kernel(20);
+    EXPECT_EQ(kernel.size(), 20);
+}
+
+TEST_F(PointsTest, TestCopy)
+{
+    Points::PointKernel kernel(20);
+    Points::PointKernel copy(kernel);  // NOLINT
+    EXPECT_EQ(copy.size(), 20);
+}
+
+TEST_F(PointsTest, TestMove)
+{
+    Points::PointKernel kernel(20);
+    Points::PointKernel move(std::move(kernel));
+    EXPECT_EQ(move.size(), 20);
+}
+
+TEST_F(PointsTest, TestAssign)
+{
+    Points::PointKernel kernel(20);
+    Points::PointKernel copy;
+    copy = kernel;
+    EXPECT_EQ(copy.size(), 20);
+}
+
+TEST_F(PointsTest, TestMoveAssign)
+{
+    Points::PointKernel kernel(20);
+    Points::PointKernel copy;
+    copy = std::move(kernel);
+    EXPECT_EQ(copy.size(), 20);
+}
+
+TEST_F(PointsTest, TestSwap)
+{
+    Points::PointKernel kernel;
+    std::vector<Points::PointKernel::value_type> points(20);
+    kernel.swap(points);
+    EXPECT_EQ(kernel.size(), 20);
+    EXPECT_EQ(points.size(), 0);
+    EXPECT_EQ(kernel.countValid(), 20);
+}
+
+TEST_F(PointsTest, TestASCII)
+{
+    std::string name = getFileName() + ".asc";
+    Points::AscWriter writer(getKernel());
+    writer.setIntensities(getIntensity());
+    writer.write(name);
+
+    Points::AscReader reader;
+    reader.read(name);
+
+    EXPECT_FALSE(reader.hasProperties());
+    EXPECT_FALSE(reader.hasIntensities());
+    EXPECT_FALSE(reader.hasColors());
+    EXPECT_FALSE(reader.hasNormals());
+    EXPECT_FALSE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 8);
+    EXPECT_EQ(reader.getHeight(), 1);
+}
+
+TEST_F(PointsTest, TestPlainPLY)
+{
+    std::string name = getFileName();
+    Points::PlyWriter writer(getKernel());
+    writer.write(name);
+
+    Points::PlyReader reader;
+    reader.read(name);
+
+    EXPECT_FALSE(reader.hasProperties());
+    EXPECT_FALSE(reader.hasIntensities());
+    EXPECT_FALSE(reader.hasColors());
+    EXPECT_FALSE(reader.hasNormals());
+    EXPECT_FALSE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 8);
+    EXPECT_EQ(reader.getHeight(), 1);
+}
+
+TEST_F(PointsTest, TestPLYWithProperties)
+{
+    std::string name = getFileName();
+    Points::PlyWriter writer(getKernel());
+    writer.setIntensities(getIntensity());
+    writer.setColors(getColors());
+    writer.setNormals(getNormals());
+    writer.write(name);
+
+    Points::PlyReader reader;
+    reader.read(name);
+
+    EXPECT_TRUE(reader.hasProperties());
+    EXPECT_TRUE(reader.hasIntensities());
+    EXPECT_TRUE(reader.hasColors());
+    EXPECT_TRUE(reader.hasNormals());
+    EXPECT_FALSE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 8);
+    EXPECT_EQ(reader.getHeight(), 1);
+}
+
+TEST_F(PointsTest, TestPlainPCD)
+{
+    std::string name = getFileName();
+    Points::PcdWriter writer(getKernel());
+    writer.write(name);
+
+    Points::PcdReader reader;
+    reader.read(name);
+
+    EXPECT_FALSE(reader.hasProperties());
+    EXPECT_FALSE(reader.hasIntensities());
+    EXPECT_FALSE(reader.hasColors());
+    EXPECT_FALSE(reader.hasNormals());
+    EXPECT_FALSE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 8);
+    EXPECT_EQ(reader.getHeight(), 1);
+}
+
+TEST_F(PointsTest, TestPCDWithProperties)
+{
+    std::string name = getFileName();
+    Points::PcdWriter writer(getKernel());
+    writer.setIntensities(getIntensity());
+    writer.setColors(getColors());
+    writer.setNormals(getNormals());
+    writer.write(name);
+
+    Points::PcdReader reader;
+    reader.read(name);
+
+    EXPECT_TRUE(reader.hasProperties());
+    EXPECT_TRUE(reader.hasIntensities());
+    EXPECT_TRUE(reader.hasColors());
+    EXPECT_TRUE(reader.hasNormals());
+    EXPECT_FALSE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 8);
+    EXPECT_EQ(reader.getHeight(), 1);
+}
+
+TEST_F(PointsTest, TestPCDStructured)
+{
+    std::string name = getFileName();
+    Points::PcdWriter writer(getKernel());
+    writer.setIntensities(getIntensity());
+    writer.setColors(getColors());
+    writer.setNormals(getNormals());
+    writer.setWidth(4);
+    writer.setHeight(2);
+    writer.write(name);
+
+    Points::PcdReader reader;
+    reader.read(name);
+
+    EXPECT_TRUE(reader.hasProperties());
+    EXPECT_TRUE(reader.hasIntensities());
+    EXPECT_TRUE(reader.hasColors());
+    EXPECT_TRUE(reader.hasNormals());
+    EXPECT_TRUE(reader.isStructured());
+    EXPECT_EQ(reader.getWidth(), 4);
+    EXPECT_EQ(reader.getHeight(), 2);
+}
 // NOLINTEND(cppcoreguidelines-*,readability-*)