This is an automated email from the ASF dual-hosted git repository. isapego pushed a commit to branch ignite-17607 in repository https://gitbox.apache.org/repos/asf/ignite-3.git
commit f36c368210a4a349052454b36dbf066d4d25f037 Author: Igor Sapego <[email protected]> AuthorDate: Wed Mar 15 02:32:50 2023 +0300 IGNITE-17607 Add all arg types test --- .../platforms/cpp/ignite/client/detail/utils.cpp | 88 ++++++++++++++++++---- .../cpp/tests/client-test/compute_test.cpp | 69 +++++++++++++++++ 2 files changed, 141 insertions(+), 16 deletions(-) diff --git a/modules/platforms/cpp/ignite/client/detail/utils.cpp b/modules/platforms/cpp/ignite/client/detail/utils.cpp index 5a21f1c37f..60a5aa9e79 100644 --- a/modules/platforms/cpp/ignite/client/detail/utils.cpp +++ b/modules/platforms/cpp/ignite/client/detail/utils.cpp @@ -106,16 +106,44 @@ void claim_primitive_with_type(binary_tuple_builder &builder, const primitive &v builder.claim(ignite_type::BINARY, data); break; } - - case column_type::DECIMAL: - case column_type::DATE: - case column_type::TIME: - case column_type::DATETIME: - case column_type::TIMESTAMP: - case column_type::BITMASK: + case column_type::DECIMAL: { + const auto& dec_value = value.get<big_decimal>(); + claim_type_and_scale(builder, ignite_type::DECIMAL, dec_value.get_scale()); + builder.claim_number(dec_value); + break; + } + case column_type::NUMBER: { + claim_type_and_scale(builder, ignite_type::NUMBER); + builder.claim_number(value.get<big_integer>()); + break; + } + case column_type::DATE: { + claim_type_and_scale(builder, ignite_type::DATE); + builder.claim_date(value.get<ignite_date>()); + break; + } + case column_type::TIME: { + claim_type_and_scale(builder, ignite_type::TIME); + builder.claim_time(value.get<ignite_time>()); + break; + } + case column_type::DATETIME: { + claim_type_and_scale(builder, ignite_type::DATETIME); + builder.claim_date_time(value.get<ignite_date_time>()); + break; + } + case column_type::TIMESTAMP: { + claim_type_and_scale(builder, ignite_type::TIMESTAMP); + builder.claim_timestamp(value.get<ignite_timestamp>()); + break; + } + case column_type::BITMASK: { + claim_type_and_scale(builder, ignite_type::BITMASK); + builder.claim_bytes(value.get<bit_array>().get_raw()); + break; + } case column_type::PERIOD: case column_type::DURATION: - case column_type::NUMBER: default: throw ignite_error("Unsupported type: " + std::to_string(int(value.get_type()))); } @@ -181,16 +209,44 @@ void append_primitive_with_type(binary_tuple_builder &builder, const primitive & builder.append(ignite_type::BINARY, data); break; } - - case column_type::DECIMAL: - case column_type::DATE: - case column_type::TIME: - case column_type::DATETIME: - case column_type::TIMESTAMP: - case column_type::BITMASK: + case column_type::DECIMAL: { + const auto& dec_value = value.get<big_decimal>(); + append_type_and_scale(builder, ignite_type::DECIMAL, dec_value.get_scale()); + builder.append_number(dec_value); + break; + } + case column_type::NUMBER: { + append_type_and_scale(builder, ignite_type::NUMBER); + builder.append_number(value.get<big_integer>()); + break; + } + case column_type::DATE: { + append_type_and_scale(builder, ignite_type::DATE); + builder.append_date(value.get<ignite_date>()); + break; + } + case column_type::TIME: { + append_type_and_scale(builder, ignite_type::TIME); + builder.append_time(value.get<ignite_time>()); + break; + } + case column_type::DATETIME: { + append_type_and_scale(builder, ignite_type::DATETIME); + builder.append_date_time(value.get<ignite_date_time>()); + break; + } + case column_type::TIMESTAMP: { + append_type_and_scale(builder, ignite_type::TIMESTAMP); + builder.append_timestamp(value.get<ignite_timestamp>()); + break; + } + case column_type::BITMASK: { + append_type_and_scale(builder, ignite_type::BITMASK); + builder.append_bytes(value.get<bit_array>().get_raw()); + break; + } case column_type::PERIOD: case column_type::DURATION: - case column_type::NUMBER: default: throw ignite_error("Unsupported type: " + std::to_string(int(value.get_type()))); } diff --git a/modules/platforms/cpp/tests/client-test/compute_test.cpp b/modules/platforms/cpp/tests/client-test/compute_test.cpp index e6e2324970..4414e7ec3f 100644 --- a/modules/platforms/cpp/tests/client-test/compute_test.cpp +++ b/modules/platforms/cpp/tests/client-test/compute_test.cpp @@ -24,6 +24,8 @@ #include <gtest/gtest.h> #include <chrono> +#include <limits> +#include <sstream> using namespace ignite; @@ -65,6 +67,33 @@ protected: return {nodes.begin(), nodes.end()}; } + /** + * Check that passed argument returned in a specific string form. + * + * @tparam T Type of the argument. + * @param value Argument. + * @param expected_str Expected string form. + */ + template<typename T> + void check_argument(T value, const std::string &expected_str) { + auto cluster_nodes = m_client.get_cluster_nodes(); + auto result = m_client.get_compute().execute(cluster_nodes, ECHO_JOB, {value, expected_str}); + + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result.value().template get<T>(), value); + } + + /** + * Check that passed argument returned in an expected string form. + * + * @tparam T Type of the argument. + * @param value Argument. + */ + template<typename T> + void check_argument(T value) { + check_argument(std::move(value), std::to_string(value)); + } + /** Ignite client. */ ignite_client m_client; }; @@ -172,6 +201,46 @@ TEST_F(compute_test, unknown_node_throws) { ignite_error); } +TEST_F(compute_test, all_arg_types) { + check_argument<std::int8_t>(42); + check_argument<std::int8_t>(std::numeric_limits<std::int8_t>::max()); + check_argument<std::int8_t>(std::numeric_limits<std::int8_t>::min()); + + check_argument<std::int16_t>(4242); + check_argument<std::int16_t>(std::numeric_limits<std::int16_t>::max()); + check_argument<std::int16_t>(std::numeric_limits<std::int16_t>::min()); + + check_argument<std::int32_t>(424242); + check_argument<std::int32_t>(std::numeric_limits<std::int32_t>::max()); + check_argument<std::int32_t>(std::numeric_limits<std::int32_t>::min()); + + check_argument<std::int64_t>(424242424242); + check_argument<std::int64_t>(std::numeric_limits<std::int64_t>::max()); + check_argument<std::int64_t>(std::numeric_limits<std::int64_t>::min()); + + check_argument<float>(0.123456f); + check_argument<float>(std::numeric_limits<float>::max(), "3.4028235E38"); + check_argument<float>(std::numeric_limits<float>::min(), "1.17549435E-38"); + + check_argument<double>(0.987654); + check_argument<double>(std::numeric_limits<double>::max(), "1.7976931348623157E308"); + check_argument<double>(std::numeric_limits<double>::min(), "2.2250738585072014E-308"); + + check_argument<big_decimal>({123456, 3}, "123.456"); + check_argument<big_decimal>({}, "0"); + check_argument<big_decimal>({1, 0}, "1"); + + auto str_dec = "12345678909876543211234567890.987654321"; + check_argument<big_decimal>(big_decimal(str_dec), str_dec); + + check_argument<ignite_date>({2021, 11, 18}, "2021-11-18"); + check_argument<ignite_time>({13, 8, 55, 266574889}, "13:08:55.266574889"); + check_argument<ignite_date_time>({{2021, 11, 18}, {13, 8, 55, 266574889}}, "2021-11-18T13:08:55.266574889"); + + check_argument<uuid>({0, 0}, "00000000-0000-0000-0000-000000000000"); + check_argument<uuid>({0x123e4567e89b12d3, 0x7456426614174000}, "123e4567-e89b-12d3-7456-426614174000"); +} +
