common.h

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
// An alternative to injecting asset locations as command line macros,
// is using a generated header.
#ifdef LA_TESTING_USE_CONFIG
    #include <lagrange/testing/public_config.h>
#endif
 
#include <lagrange/SurfaceMesh.h>
#include <lagrange/fs/filesystem.h>
#include <lagrange/io/load_mesh.h>
#ifdef LAGRANGE_ENABLE_LEGACY_FUNCTIONS
    #include <lagrange/io/legacy/load_mesh.h>
#endif
#include <lagrange/testing/api.h>
#include <lagrange/utils/assert.h>
 
#include <catch2/catch_test_macros.hpp>

#define LA_REQUIRE_THROWS(...)                                  \
    do {                                                        \
        bool __was_enabled = lagrange::is_breakpoint_enabled(); \
        lagrange::set_breakpoint_enabled(false);                \
        REQUIRE_THROWS(__VA_ARGS__);                            \
        lagrange::set_breakpoint_enabled(__was_enabled);        \
    } while (0)

#define LA_REQUIRE_THROWS_WITH(x, y)                            \
    do {                                                        \
        bool __was_enabled = lagrange::is_breakpoint_enabled(); \
        lagrange::set_breakpoint_enabled(false);                \
        REQUIRE_THROWS_WITH(x, y);                              \
        lagrange::set_breakpoint_enabled(__was_enabled);        \
    } while (0)

#define LA_CHECK_THROWS(...)                                    \
    do {                                                        \
        bool __was_enabled = lagrange::is_breakpoint_enabled(); \
        lagrange::set_breakpoint_enabled(false);                \
        CHECK_THROWS(__VA_ARGS__);                              \
        lagrange::set_breakpoint_enabled(__was_enabled);        \
    } while (0)
 
 
namespace lagrange {
namespace testing {

LA_TESTING_API fs::path get_data_dir();

LA_TESTING_API fs::path get_test_output_dir();

LA_TESTING_API fs::path get_data_path(const fs::path& relative_path);

LA_TESTING_API fs::path get_data_folder(const fs::path& relative_path);

LA_TESTING_API fs::path get_test_output_path(const fs::path& relative_path);

#ifdef LAGRANGE_ENABLE_LEGACY_FUNCTIONS
template <typename MeshType>
std::unique_ptr<MeshType> load_mesh(const fs::path& relative_path)
{
    auto result = lagrange::io::load_mesh<MeshType>(get_data_path(relative_path));
    REQUIRE(result);
    return result;
}
extern template LA_TESTING_API std::unique_ptr<TriangleMesh3D> load_mesh(const fs::path&);
extern template LA_TESTING_API std::unique_ptr<QuadMesh3D> load_mesh(const fs::path&);
#endif

template <typename Scalar, typename Index>
SurfaceMesh<Scalar, Index> load_surface_mesh(const fs::path& relative_path)
{
    auto full_path = get_data_path(relative_path);
    REQUIRE(lagrange::fs::exists(full_path));
    io::LoadOptions options;
    options.quiet = true;
    return lagrange::io::load_mesh<SurfaceMesh<Scalar, Index>>(full_path, options);
}

LA_TESTING_API void setup_mkl_reproducibility();

LA_TESTING_API void disable_windows_error_dialogs();
 
} // namespace testing
} // namespace lagrange