From dfcf7993da70fa2f9c8eac780f577b53d3acd058 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Thu, 2 May 2024 15:00:54 +0200 Subject: [PATCH] adds segmented array tests --- core/test/base/CMakeLists.txt | 1 + core/test/base/segmented_array.cpp | 184 +++++++++++++++++++++++++++++ 2 files changed, 185 insertions(+) create mode 100644 core/test/base/segmented_array.cpp diff --git a/core/test/base/CMakeLists.txt b/core/test/base/CMakeLists.txt index fb3d1a8e1bb..c608acd9a8a 100644 --- a/core/test/base/CMakeLists.txt +++ b/core/test/base/CMakeLists.txt @@ -26,6 +26,7 @@ ginkgo_create_test(polymorphic_object) ginkgo_create_test(range) ginkgo_create_test(range_accessors) ginkgo_create_test(sanitizers ADDITIONAL_LIBRARIES Threads::Threads) +ginkgo_create_test(segmented_array) ginkgo_create_test(types) ginkgo_create_test(utils) ginkgo_create_test(version EXECUTABLE_NAME version_test) # version collides with C++ stdlib header diff --git a/core/test/base/segmented_array.cpp b/core/test/base/segmented_array.cpp new file mode 100644 index 00000000000..0c004223b12 --- /dev/null +++ b/core/test/base/segmented_array.cpp @@ -0,0 +1,184 @@ +// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors +// +// SPDX-License-Identifier: BSD-3-Clause + +#include + + +#include + + +#include "core/base/segmented_array.hpp" +#include "core/test/utils.hpp" + + +template +gko::array get_flat_array(gko::segmented_array& arr) +{ + return gko::make_array_view(arr.get_executor(), arr.get_size(), + arr.get_flat_data()); +} + + +template +class SegmentedArray : public ::testing::Test { +public: + using value_type = T; + + std::shared_ptr exec = gko::ReferenceExecutor::create(); +}; + +TYPED_TEST_SUITE(SegmentedArray, gko::test::PODTypes, TypenameNameGenerator); + + +TYPED_TEST(SegmentedArray, CanConstructFromExecutor) +{ + using value_type = typename TestFixture::value_type; + + gko::segmented_array arr{this->exec}; + + ASSERT_EQ(arr.get_executor(), this->exec); + ASSERT_EQ(arr.get_segment_count(), 0); + ASSERT_EQ(arr.get_size(), 0); + ASSERT_EQ(arr.get_flat_data(), nullptr); + ASSERT_NE(arr.get_offsets().get_const_data(), nullptr); +} + + +TYPED_TEST(SegmentedArray, CanConstructFromSizes) +{ + using value_type = typename TestFixture::value_type; + + auto arr = gko::segmented_array::create_from_sizes( + {this->exec, {1, 2, 3}}); + + auto expected_offsets = gko::array(this->exec, {0, 1, 3, 6}); + ASSERT_EQ(arr.get_executor(), this->exec); + ASSERT_EQ(arr.get_segment_count(), 3); + ASSERT_EQ(arr.get_size(), 6); + ASSERT_NE(arr.get_flat_data(), nullptr); + GKO_ASSERT_ARRAY_EQ(arr.get_offsets(), expected_offsets); +} + + +TYPED_TEST(SegmentedArray, CanConstructFromBufferAndSizes) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + + auto arr = gko::segmented_array::create_from_sizes( + buffer, {this->exec, {1, 2, 3}}); + + auto expected_offsets = gko::array(this->exec, {0, 1, 3, 6}); + ASSERT_EQ(arr.get_executor(), this->exec); + ASSERT_EQ(arr.get_segment_count(), 3); + ASSERT_EQ(arr.get_size(), 6); + GKO_ASSERT_ARRAY_EQ(arr.get_offsets(), expected_offsets); + GKO_ASSERT_ARRAY_EQ(get_flat_array(arr), buffer); +} + + +TYPED_TEST(SegmentedArray, CanConstructFromOffsets) +{ + using value_type = typename TestFixture::value_type; + auto offsets = gko::array(this->exec, {0, 1, 3, 6}); + + auto arr = gko::segmented_array::create_from_offsets(offsets); + + ASSERT_EQ(arr.get_executor(), this->exec); + ASSERT_EQ(arr.get_segment_count(), 3); + ASSERT_EQ(arr.get_size(), 6); + ASSERT_NE(arr.get_flat_data(), nullptr); + GKO_ASSERT_ARRAY_EQ(arr.get_offsets(), offsets); +} + + +TYPED_TEST(SegmentedArray, CanConstructFromBufferAndOffsets) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + auto offsets = gko::array(this->exec, {0, 1, 3, 6}); + + auto arr = + gko::segmented_array::create_from_offsets(buffer, offsets); + + ASSERT_EQ(arr.get_executor(), this->exec); + ASSERT_EQ(arr.get_segment_count(), 3); + ASSERT_EQ(arr.get_size(), 6); + GKO_ASSERT_ARRAY_EQ(arr.get_offsets(), offsets); + GKO_ASSERT_ARRAY_EQ(get_flat_array(arr), buffer); +} + + +TYPED_TEST(SegmentedArray, CanBeCopied) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + auto offsets = gko::array(this->exec, {0, 1, 3, 6}); + auto arr = + gko::segmented_array::create_from_offsets(buffer, offsets); + + auto copy = arr; + + GKO_ASSERT_ARRAY_EQ(copy.get_offsets(), arr.get_offsets()); + GKO_ASSERT_ARRAY_EQ(get_flat_array(copy), get_flat_array(arr)); +} + + +TYPED_TEST(SegmentedArray, CanBeMoved) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + auto offsets = gko::array(this->exec, {0, 1, 3, 6}); + auto arr = + gko::segmented_array::create_from_offsets(buffer, offsets); + + auto move = std::move(arr); + + GKO_ASSERT_ARRAY_EQ(move.get_offsets(), offsets); + GKO_ASSERT_ARRAY_EQ(get_flat_array(move), buffer); + ASSERT_EQ(arr.get_size(), 0); + ASSERT_EQ(arr.get_segment_count(), 0); + ASSERT_EQ(arr.get_flat_data(), nullptr); + ASSERT_NE(arr.get_offsets().get_const_data(), nullptr); +} + + +TYPED_TEST(SegmentedArray, ThrowsIfBufferSizeDoesntMatchSizes) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + + auto construct_with_size_mismatch = [&] { + auto arr = gko::segmented_array::create_from_offsets( + buffer, {this->exec, {1, 2, 1}}); + }; + ASSERT_THROW(construct_with_size_mismatch(), gko::ValueMismatch); +} + + +TYPED_TEST(SegmentedArray, ThrowsIfBufferSizeDoesntMatchOffsets) +{ + using value_type = typename TestFixture::value_type; + auto buffer = gko::array(this->exec, {1, 2, 2, 3, 3, 3}); + auto offsets = gko::array(this->exec, {0, 1, 3, 4}); + + auto construct_with_size_mismatch = [&] { + auto arr = gko::segmented_array::create_from_offsets( + buffer, offsets); + }; + ASSERT_THROW(construct_with_size_mismatch(), gko::ValueMismatch); +} + + +TYPED_TEST(SegmentedArray, ThrowsOnEmptyOffsets) +{ + using value_type = typename TestFixture::value_type; + auto offsets = gko::array(this->exec); + + auto construct_with_empty_offsets = [&] { + auto arr = + gko::segmented_array::create_from_offsets(offsets); + }; + ASSERT_THROW(construct_with_empty_offsets(), gko::InvalidStateError); +}