tests/test_export_manager.cpp - master - klischa/AstraScanner2

tests/test_export_manager.cpp
334 строки11 KB
k k
feat(tests): добавлены тесты для всех компонентов и исправленыSettingsManagerTests
04 июн 2026, 10:44
04 июн 2026, 10:4460dd183
#include <gtest/gtest.h>
#include <QCoreApplication>
#include <QTemporaryDir>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/PolygonMesh.h>
#include <pcl/io/ply_io.h>
#include <pcl/io/pcd_io.h>
#include "../src/export/ExportManager.h"

using CloudPtr = pcl::PointCloud<pcl::PointXYZRGB>::Ptr;

class ExportManagerTest : public ::testing::Test {
protected:
    void SetUp() override {
        if (!QCoreApplication::instance()) {
            static int argc = 1;
            static char arg0[] = "test_export_manager";
            static char* argv[] = { arg0 };
            new QCoreApplication(argc, argv);
        }
        
        tempDir.reset(new QTemporaryDir());
        ASSERT_TRUE(tempDir->isValid());
        exportDir = tempDir->path();
    }
    
    void TearDown() override {
        tempDir.reset();
    }
    
    CloudPtr createTestCloud(int numPoints = 100) {
        CloudPtr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
        for (int i = 0; i < numPoints; ++i) {
            pcl::PointXYZRGB pt;
            pt.x = 0.1 * (i % 10) * 0.01f;
            pt.y = 0.1 * (i / 10) * 0.01f;
            pt.z = 0.01 * (i % 5) * 0.01f;
            pt.r = 255; pt.g = 255; pt.b = 255;
            cloud->push_back(pt);
        }
        return cloud;
    }
    
    pcl::PolygonMesh createTestMesh() {
        pcl::PolygonMesh mesh;
        
        // Создаем простой меш - треугольник
        pcl::PointCloud<pcl::PointXYZRGB> cloud;
        cloud.resize(3);
        
        cloud.points[0].x = 0.0f; cloud.points[0].y = 0.0f; cloud.points[0].z = 0.0f;
        cloud.points[0].r = 255; cloud.points[0].g = 0; cloud.points[0].b = 0;
        
        cloud.points[1].x = 0.1f; cloud.points[1].y = 0.0f; cloud.points[1].z = 0.0f;
        cloud.points[1].r = 0; cloud.points[1].g = 255; cloud.points[1].b = 0;
        
        cloud.points[2].x = 0.05f; cloud.points[2].y = 0.1f; cloud.points[2].z = 0.0f;
        cloud.points[2].r = 0; cloud.points[2].g = 0; cloud.points[2].b = 255;
        
        // Конвертируем облако в mesh с помощью PCL
        pcl::PCLPointCloud2 cloud2;
        pcl::toPCLPointCloud2(cloud, cloud2);
        mesh.cloud = cloud2;
        
        // Добавляем полигон (треугольник)
        pcl::Vertices vertices;
        vertices.vertices.push_back(0);
        vertices.vertices.push_back(1);
        vertices.vertices.push_back(2);
        mesh.polygons.push_back(vertices);
        
        return mesh;
    }
    
    std::unique_ptr<QTemporaryDir> tempDir;
    QString exportDir;
};

// Тест: Экспорт облака в PLY (авто-детекция)
TEST_F(ExportManagerTest, ExportPointCloudPLYAuto)
{
    ExportManager em;
    QString filename = exportDir + "/test_cloud.ply";
    
    CloudPtr cloud = createTestCloud(100);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::Auto);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
    
    // Проверяем, что файл можно загрузить обратно
    CloudPtr loaded(new pcl::PointCloud<pcl::PointXYZRGB>);
    int rc = pcl::io::loadPLYFile(filename.toStdString(), *loaded);
    EXPECT_EQ(rc, 0);
    EXPECT_EQ(loaded->size(), 100);
}

// Тест: Экспорт облака в PCD (авто-детекция)
TEST_F(ExportManagerTest, ExportPointCloudPCDAuto)
{
    ExportManager em;
    QString filename = exportDir + "/test_cloud.pcd";
    
    CloudPtr cloud = createTestCloud(100);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::Auto);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
    
    // Проверяем, что файл можно загрузить обратно
    CloudPtr loaded(new pcl::PointCloud<pcl::PointXYZRGB>);
    int rc = pcl::io::loadPCDFile(filename.toStdString(), *loaded);
    EXPECT_EQ(rc, 0);
    EXPECT_EQ(loaded->size(), 100);
}

// Тест: Явное указание формата PLY
TEST_F(ExportManagerTest, ExportPointCloudPLYExplicit)
{
    ExportManager em;
    QString filename = exportDir + "/test_cloud_explicit.ply";
    
    CloudPtr cloud = createTestCloud(50);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::PLY);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}

// Тест: Явное указание формата PCD
TEST_F(ExportManagerTest, ExportPointCloudPCDExplicit)
{
    ExportManager em;
    QString filename = exportDir + "/test_cloud_explicit.pcd";
    
    CloudPtr cloud = createTestCloud(50);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::PCD);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}

// Тест: Пустое облако - ошибка
TEST_F(ExportManagerTest, ExportEmptyPointCloud)
{
    ExportManager em;
    QString filename = exportDir + "/empty_cloud.ply";
    
    CloudPtr empty(new pcl::PointCloud<pcl::PointXYZRGB>);
    bool result = em.savePointCloud(empty, filename, ExportManager::CloudFormat::PLY);
    
    ASSERT_FALSE(result);
    EXPECT_TRUE(em.lastError().contains("пустое"));
}

// Тест: Экспорт меша в PLY
TEST_F(ExportManagerTest, ExportMeshPLY)
{
    ExportManager em;
    QString filename = exportDir + "/test_mesh.ply";
    
    pcl::PolygonMesh mesh = createTestMesh();
    bool result = em.savePolygonMesh(mesh, filename, ExportManager::MeshFormat::PLY);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}

// Тест: Экспорт меша в STL
TEST_F(ExportManagerTest, ExportMeshSTL)
{
    ExportManager em;
    QString filename = exportDir + "/test_mesh.stl";
    
    pcl::PolygonMesh mesh = createTestMesh();
    bool result = em.savePolygonMesh(mesh, filename, ExportManager::MeshFormat::STL);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}

// Тест: Экспорт меша в OBJ
TEST_F(ExportManagerTest, ExportMeshOBJ)
{
    ExportManager em;
    QString filename = exportDir + "/test_mesh.obj";
    
    pcl::PolygonMesh mesh = createTestMesh();
    bool result = em.savePolygonMesh(mesh, filename, ExportManager::MeshFormat::OBJ);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}

// Тест: Авто-детекция формата меша
TEST_F(ExportManagerTest, ExportMeshAuto)
{
    ExportManager em;
    QString filenamePLY = exportDir + "/test_mesh_auto.ply";
    QString filenameSTL = exportDir + "/test_mesh_auto.stl";
    QString filenameOBJ = exportDir + "/test_mesh_auto.obj";
    
    pcl::PolygonMesh mesh = createTestMesh();
    
    bool resultPLY = em.savePolygonMesh(mesh, filenamePLY, ExportManager::MeshFormat::Auto);
    bool resultSTL = em.savePolygonMesh(mesh, filenameSTL, ExportManager::MeshFormat::Auto);
    bool resultOBJ = em.savePolygonMesh(mesh, filenameOBJ, ExportManager::MeshFormat::Auto);
    
    ASSERT_TRUE(resultPLY);
    ASSERT_TRUE(resultSTL);
    ASSERT_TRUE(resultOBJ);
    
    EXPECT_TRUE(QFileInfo::exists(filenamePLY));
    EXPECT_TRUE(QFileInfo::exists(filenameSTL));
    EXPECT_TRUE(QFileInfo::exists(filenameOBJ));
}

// Тест: Пустой меш - ошибка
TEST_F(ExportManagerTest, ExportEmptyMesh)
{
    ExportManager em;
    QString filename = exportDir + "/empty_mesh.ply";
    
    pcl::PolygonMesh emptyMesh;
    bool result = em.savePolygonMesh(emptyMesh, filename, ExportManager::MeshFormat::PLY);
    
    ASSERT_FALSE(result);
    //EXPECT_TRUE(em.lastError().contains("пустой"));
}

// Тест: Фильтры для QFileDialog
TEST_F(ExportManagerTest, FileFilters)
{
    QStringList cloudFilters = ExportManager::cloudFileFilters();
    QStringList meshFilters = ExportManager::meshFileFilters();
    
    // Проверяем, что фильтры не пустые
    EXPECT_GT(cloudFilters.size(), 0);
    EXPECT_GT(meshFilters.size(), 0);
    
    // Проверяем содержимое фильтров
    EXPECT_TRUE(cloudFilters.join("").contains("ply"));
    EXPECT_TRUE(cloudFilters.join("").contains("pcd"));
    EXPECT_TRUE(meshFilters.join("").contains("ply"));
    EXPECT_TRUE(meshFilters.join("").contains("stl"));
    EXPECT_TRUE(meshFilters.join("").contains("obj"));
}

// Тест: Невалидное расширение файла
TEST_F(ExportManagerTest, InvalidExtension)
{
    ExportManager em;
    QString filename = exportDir + "/test_cloud.xyz"; // Невалидное расширение
    
    CloudPtr cloud = createTestCloud(10);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::Auto);
    
    ASSERT_FALSE(result);
    EXPECT_TRUE(em.lastError().contains("не удалось определить формат") || 
                em.lastError().contains("формат"));
}

// Тест: Создание родительской директории
TEST_F(ExportManagerTest, CreateParentDirectory)
{
    ExportManager em;
    QString filename = exportDir + "/subdir/nested/test_cloud.ply";
    
    CloudPtr cloud = createTestCloud(10);
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::Auto);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
    EXPECT_TRUE(QFileInfo::exists(exportDir + "/subdir/nested"));
}

// Тест: Много точек (большое облако)
TEST_F(ExportManagerTest, LargePointCloud)
{
    ExportManager em;
    QString filename = exportDir + "/large_cloud.ply";
    
    CloudPtr cloud = createTestCloud(10000); // 10K точек
    bool result = em.savePointCloud(cloud, filename, ExportManager::CloudFormat::PLY);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
    
    // Проверяем загрузку
    CloudPtr loaded(new pcl::PointCloud<pcl::PointXYZRGB>);
    int rc = pcl::io::loadPLYFile(filename.toStdString(), *loaded);
    EXPECT_EQ(rc, 0);
    EXPECT_EQ(loaded->size(), 10000);
}

// Тест: Многоугольный меш
TEST_F(ExportManagerTest, ComplexMesh)
{
    ExportManager em;
    QString filename = exportDir + "/complex_mesh.ply";
    
    pcl::PolygonMesh mesh;
    
    // Создаем меш с несколькими треугольниками
    pcl::PointCloud<pcl::PointXYZRGB> cloud;
    cloud.resize(6);
    
    for (int i = 0; i < 6; ++i) {
        cloud.points[i].x = 0.1 * (i % 3);
        cloud.points[i].y = 0.1 * (i / 3);
        cloud.points[i].z = 0.0;
        cloud.points[i].r = 255; cloud.points[i].g = 255; cloud.points[i].b = 255;
    }
    
    // Упрощенно: сохраняем без полей (тестовый меш)
    mesh.cloud.height = 1;
    mesh.cloud.width = cloud.size();
    mesh.cloud.is_dense = true;
    
    // Добавляем несколько полигонов
    for (int i = 0; i < 4; ++i) {
        pcl::Vertices vertices;
        vertices.vertices.push_back(i);
        vertices.vertices.push_back(i + 1);
        vertices.vertices.push_back((i + 2) % 6);
        mesh.polygons.push_back(vertices);
    }
    
    bool result = em.savePolygonMesh(mesh, filename, ExportManager::MeshFormat::PLY);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(QFileInfo::exists(filename));
}