tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix usages of constexpr (#367)

Browse Source 
* Fix usages of constexpr
This commit is contained in:
János Benjamin Antal 2022-03-31 13:52:43 +02:00 committed by GitHub
parent 5822b44b15
commit 537855a0b2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
75 changed files with 372 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/auth/models.cpp
View File

@ -22,7 +22,7 @@
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords."); DEFINE_bool(auth_password_permit_null, true, "Set to false to disable null passwords.");
constexpr std::string_view default_password_regex = ".+"; inline constexpr std::string_view default_password_regex = ".+";
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
DEFINE_string(auth_password_strength_regex, default_password_regex.data(), DEFINE_string(auth_password_strength_regex, default_password_regex.data(),
"The regular expression that should be used to match the entire " "The regular expression that should be used to match the entire "

14
src/communication/bolt/v1/codes.hpp
View File

@ -15,8 +15,8 @@
namespace memgraph::communication::bolt { namespace memgraph::communication::bolt {
static constexpr uint8_t kPreamble[4] = {0x60, 0x60, 0xB0, 0x17}; inline constexpr uint8_t kPreamble[4] = {0x60, 0x60, 0xB0, 0x17};
static constexpr uint8_t kProtocol[4] = {0x00, 0x00, 0x00, 0x01}; inline constexpr uint8_t kProtocol[4] = {0x00, 0x00, 0x00, 0x01};
enum class Signature : uint8_t { enum class Signature : uint8_t {
Noop = 0x00, Noop = 0x00,
@ -95,9 +95,9 @@ enum class Marker : uint8_t {
Struct16 = 0xDD, Struct16 = 0xDD,
}; };
static constexpr uint8_t MarkerString = 0, MarkerList = 1, MarkerMap = 2; inline constexpr uint8_t MarkerString = 0, MarkerList = 1, MarkerMap = 2;
static constexpr Marker MarkerTiny[3] = {Marker::TinyString, Marker::TinyList, Marker::TinyMap}; inline constexpr Marker MarkerTiny[3] = {Marker::TinyString, Marker::TinyList, Marker::TinyMap};
static constexpr Marker Marker8[3] = {Marker::String8, Marker::List8, Marker::Map8}; inline constexpr Marker Marker8[3] = {Marker::String8, Marker::List8, Marker::Map8};
static constexpr Marker Marker16[3] = {Marker::String16, Marker::List16, Marker::Map16}; inline constexpr Marker Marker16[3] = {Marker::String16, Marker::List16, Marker::Map16};
static constexpr Marker Marker32[3] = {Marker::String32, Marker::List32, Marker::Map32}; inline constexpr Marker Marker32[3] = {Marker::String32, Marker::List32, Marker::Map32};
} // namespace memgraph::communication::bolt } // namespace memgraph::communication::bolt

14
src/communication/bolt/v1/constants.hpp
View File

@ -19,17 +19,17 @@ namespace memgraph::communication::bolt {
/** /**
* Sizes related to the chunk defined in Bolt protocol. * Sizes related to the chunk defined in Bolt protocol.
*/ */
static constexpr size_t kChunkHeaderSize = 2; inline constexpr size_t kChunkHeaderSize = 2;
static constexpr size_t kChunkMaxDataSize = 65535; inline constexpr size_t kChunkMaxDataSize = 65535;
static constexpr size_t kChunkWholeSize = kChunkHeaderSize + kChunkMaxDataSize; inline constexpr size_t kChunkWholeSize = kChunkHeaderSize + kChunkMaxDataSize;
/** /**
* Handshake size defined in the Bolt protocol. * Handshake size defined in the Bolt protocol.
*/ */
static constexpr size_t kHandshakeSize = 20; inline constexpr size_t kHandshakeSize = 20;
static constexpr uint16_t kSupportedVersions[] = {0x0100, 0x0400, 0x0401, 0x0403}; inline constexpr uint16_t kSupportedVersions[] = {0x0100, 0x0400, 0x0401, 0x0403};
static constexpr int kPullAll = -1; inline constexpr int kPullAll = -1;
static constexpr int kPullLast = -1; inline constexpr int kPullLast = -1;
} // namespace memgraph::communication::bolt } // namespace memgraph::communication::bolt

4
src/communication/websocket/server.cpp
View File

@ -44,10 +44,10 @@ class QuoteEscapeFormatter : public spdlog::custom_flag_formatter {
void format(const spdlog::details::log_msg &msg, const std::tm & /*time*/, spdlog::memory_buf_t &dest) override { void format(const spdlog::details::log_msg &msg, const std::tm & /*time*/, spdlog::memory_buf_t &dest) override {
for (const auto c : msg.payload) { for (const auto c : msg.payload) {
if (c == '"') { if (c == '"') {
constexpr std::string_view escaped_quote = "\\\""; static constexpr std::string_view escaped_quote = "\\\"";
dest.append(escaped_quote.data(), escaped_quote.data() + escaped_quote.size()); dest.append(escaped_quote.data(), escaped_quote.data() + escaped_quote.size());
} else if (c == '\n') { } else if (c == '\n') {
constexpr std::string_view escaped_newline = "\\n"; static constexpr std::string_view escaped_newline = "\\n";
dest.append(escaped_newline.data(), escaped_newline.data() + escaped_newline.size()); dest.append(escaped_newline.data(), escaped_newline.data() + escaped_newline.size());
} else { } else {
dest.push_back(c); dest.push_back(c);

8
src/integrations/constants.hpp
View File

@ -16,10 +16,10 @@
namespace memgraph::integrations { namespace memgraph::integrations {
constexpr int64_t kDefaultCheckBatchLimit{1}; inline constexpr int64_t kDefaultCheckBatchLimit{1};
constexpr std::chrono::milliseconds kDefaultCheckTimeout{30000}; inline constexpr std::chrono::milliseconds kDefaultCheckTimeout{30000};
constexpr std::chrono::milliseconds kMinimumInterval{1}; inline constexpr std::chrono::milliseconds kMinimumInterval{1};
constexpr int64_t kMinimumSize{1}; inline constexpr int64_t kMinimumSize{1};
const std::string kReducted{"<REDUCTED>"}; const std::string kReducted{"<REDUCTED>"};
} // namespace memgraph::integrations } // namespace memgraph::integrations

8
src/integrations/kafka/consumer.cpp
View File

@ -185,8 +185,10 @@ Consumer::Consumer(ConsumerInfo info, ConsumerFunction consumer_function)
std::inserter(topic_names_from_metadata, topic_names_from_metadata.begin()), std::inserter(topic_names_from_metadata, topic_names_from_metadata.begin()),
[](const auto topic_metadata) { return topic_metadata->topic(); }); [](const auto topic_metadata) { return topic_metadata->topic(); });
constexpr size_t max_topic_name_length = 249; static constexpr size_t max_topic_name_length = 249;
constexpr auto is_valid_topic_name = [](const auto c) { return std::isalnum(c) || c == '.' || c == '_' || c == '-'; }; static constexpr auto is_valid_topic_name = [](const auto c) {
return std::isalnum(c) || c == '.' || c == '_' || c == '-';
};
for (const auto &topic_name : info_.topics) { for (const auto &topic_name : info_.topics) {
if (topic_name.size() > max_topic_name_length || if (topic_name.size() > max_topic_name_length ||
@ -351,7 +353,7 @@ void Consumer::StartConsuming() {
} }
thread_ = std::thread([this] { thread_ = std::thread([this] {
constexpr auto kMaxThreadNameSize = utils::GetMaxThreadNameSize(); static constexpr auto kMaxThreadNameSize = utils::GetMaxThreadNameSize();
const auto full_thread_name = "Cons#" + info_.consumer_name; const auto full_thread_name = "Cons#" + info_.consumer_name;
utils::ThreadSetName(full_thread_name.substr(0, kMaxThreadNameSize)); utils::ThreadSetName(full_thread_name.substr(0, kMaxThreadNameSize));

2
src/integrations/pulsar/consumer.cpp
View File

@ -231,7 +231,7 @@ void Consumer::StartConsuming() {
is_running_.store(true); is_running_.store(true);
thread_ = std::thread([this] { thread_ = std::thread([this] {
constexpr auto kMaxThreadNameSize = utils::GetMaxThreadNameSize(); static constexpr auto kMaxThreadNameSize = utils::GetMaxThreadNameSize();
const auto full_thread_name = "Cons#" + info_.consumer_name; const auto full_thread_name = "Cons#" + info_.consumer_name;
utils::ThreadSetName(full_thread_name.substr(0, kMaxThreadNameSize)); utils::ThreadSetName(full_thread_name.substr(0, kMaxThreadNameSize));

8
src/memgraph.cpp
View File

@ -260,7 +260,7 @@ DEFINE_uint64(
namespace { namespace {
using namespace std::literals; using namespace std::literals;
constexpr std::array isolation_level_mappings{ inline constexpr std::array isolation_level_mappings{
std::pair{"SNAPSHOT_ISOLATION"sv, memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION}, std::pair{"SNAPSHOT_ISOLATION"sv, memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION},
std::pair{"READ_COMMITTED"sv, memgraph::storage::IsolationLevel::READ_COMMITTED}, std::pair{"READ_COMMITTED"sv, memgraph::storage::IsolationLevel::READ_COMMITTED},
std::pair{"READ_UNCOMMITTED"sv, memgraph::storage::IsolationLevel::READ_UNCOMMITTED}}; std::pair{"READ_UNCOMMITTED"sv, memgraph::storage::IsolationLevel::READ_UNCOMMITTED}};
@ -348,7 +348,7 @@ DEFINE_bool(also_log_to_stderr, false, "Log messages go to stderr in addition to
DEFINE_string(log_file, "", "Path to where the log should be stored."); DEFINE_string(log_file, "", "Path to where the log should be stored.");
namespace { namespace {
constexpr std::array log_level_mappings{ inline constexpr std::array log_level_mappings{
std::pair{"TRACE"sv, spdlog::level::trace}, std::pair{"DEBUG"sv, spdlog::level::debug}, std::pair{"TRACE"sv, spdlog::level::trace}, std::pair{"DEBUG"sv, spdlog::level::debug},
std::pair{"INFO"sv, spdlog::level::info}, std::pair{"WARNING"sv, spdlog::level::warn}, std::pair{"INFO"sv, spdlog::level::info}, std::pair{"WARNING"sv, spdlog::level::warn},
std::pair{"ERROR"sv, spdlog::level::err}, std::pair{"CRITICAL"sv, spdlog::level::critical}}; std::pair{"ERROR"sv, spdlog::level::err}, std::pair{"CRITICAL"sv, spdlog::level::critical}};
@ -385,7 +385,7 @@ spdlog::level::level_enum ParseLogLevel() {
} }
// 5 weeks * 7 days // 5 weeks * 7 days
constexpr auto log_retention_count = 35; inline constexpr auto log_retention_count = 35;
void CreateLoggerFromSink(const auto &sinks, const auto log_level) { void CreateLoggerFromSink(const auto &sinks, const auto log_level) {
auto logger = std::make_shared<spdlog::logger>("memgraph_log", sinks.begin(), sinks.end()); auto logger = std::make_shared<spdlog::logger>("memgraph_log", sinks.begin(), sinks.end());
logger->set_level(log_level); logger->set_level(log_level);
@ -456,7 +456,7 @@ struct SessionData {
#endif #endif
}; };
constexpr std::string_view default_user_role_regex = "[a-zA-Z0-9_.+-@]+"; inline constexpr std::string_view default_user_role_regex = "[a-zA-Z0-9_.+-@]+";
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
DEFINE_string(auth_user_or_role_name_regex, default_user_role_regex.data(), DEFINE_string(auth_user_or_role_name_regex, default_user_role_regex.data(),
"Set to the regular expression that each user or role name must fulfill."); "Set to the regular expression that each user or role name must fulfill.");

4
src/query/constants.hpp
View File

@ -14,6 +14,6 @@
#include <string> #include <string>
namespace memgraph::query { namespace memgraph::query {
constexpr uint16_t kDefaultReplicationPort = 10000; inline constexpr uint16_t kDefaultReplicationPort = 10000;
constexpr auto *kDefaultReplicationServerIp = "0.0.0.0"; inline constexpr auto *kDefaultReplicationServerIp = "0.0.0.0";
} // namespace memgraph::query } // namespace memgraph::query

8
src/query/frontend/ast/cypher_main_visitor.cpp
View File

@ -645,28 +645,28 @@ antlrcpp::Any CypherMainVisitor::visitKafkaCreateStreamConfig(MemgraphCypher::Ka
if (ctx->TOPICS()) { if (ctx->TOPICS()) {
ThrowIfExists(memory_, KafkaConfigKey::TOPICS); ThrowIfExists(memory_, KafkaConfigKey::TOPICS);
constexpr auto topics_key = static_cast<uint8_t>(KafkaConfigKey::TOPICS); static constexpr auto topics_key = static_cast<uint8_t>(KafkaConfigKey::TOPICS);
GetTopicNames(memory_[topics_key], ctx->topicNames(), *this); GetTopicNames(memory_[topics_key], ctx->topicNames(), *this);
return {}; return {};
} }
if (ctx->CONSUMER_GROUP()) { if (ctx->CONSUMER_GROUP()) {
ThrowIfExists(memory_, KafkaConfigKey::CONSUMER_GROUP); ThrowIfExists(memory_, KafkaConfigKey::CONSUMER_GROUP);
constexpr auto consumer_group_key = static_cast<uint8_t>(KafkaConfigKey::CONSUMER_GROUP); static constexpr auto consumer_group_key = static_cast<uint8_t>(KafkaConfigKey::CONSUMER_GROUP);
memory_[consumer_group_key] = JoinSymbolicNamesWithDotsAndMinus(*this, *ctx->consumerGroup); memory_[consumer_group_key] = JoinSymbolicNamesWithDotsAndMinus(*this, *ctx->consumerGroup);
return {}; return {};
} }
if (ctx->CONFIGS()) { if (ctx->CONFIGS()) {
ThrowIfExists(memory_, KafkaConfigKey::CONFIGS); ThrowIfExists(memory_, KafkaConfigKey::CONFIGS);
constexpr auto configs_key = static_cast<uint8_t>(KafkaConfigKey::CONFIGS); static constexpr auto configs_key = static_cast<uint8_t>(KafkaConfigKey::CONFIGS);
memory_.emplace(configs_key, ctx->configsMap->accept(this).as<std::unordered_map<Expression *, Expression *>>()); memory_.emplace(configs_key, ctx->configsMap->accept(this).as<std::unordered_map<Expression *, Expression *>>());
return {}; return {};
} }
if (ctx->CREDENTIALS()) { if (ctx->CREDENTIALS()) {
ThrowIfExists(memory_, KafkaConfigKey::CREDENTIALS); ThrowIfExists(memory_, KafkaConfigKey::CREDENTIALS);
constexpr auto credentials_key = static_cast<uint8_t>(KafkaConfigKey::CREDENTIALS); static constexpr auto credentials_key = static_cast<uint8_t>(KafkaConfigKey::CREDENTIALS);
memory_.emplace(credentials_key, memory_.emplace(credentials_key,
ctx->credentialsMap->accept(this).as<std::unordered_map<Expression *, Expression *>>()); ctx->credentialsMap->accept(this).as<std::unordered_map<Expression *, Expression *>>());
return {}; return {};

12
src/query/interpret/awesome_memgraph_functions.cpp
View File

@ -307,9 +307,9 @@ void FType(const char *name, const TypedValue *args, int64_t nargs, int64_t pos
} }
return; return;
} }
constexpr int64_t required_args = FTypeRequiredArgs<ArgType, ArgTypes...>(); static constexpr int64_t required_args = FTypeRequiredArgs<ArgType, ArgTypes...>();
constexpr int64_t optional_args = FTypeOptionalArgs<ArgType, ArgTypes...>(); static constexpr int64_t optional_args = FTypeOptionalArgs<ArgType, ArgTypes...>();
constexpr int64_t total_args = required_args + optional_args; static constexpr int64_t total_args = required_args + optional_args;
if constexpr (optional_args > 0) { if constexpr (optional_args > 0) {
if (nargs < required_args || nargs > total_args) { if (nargs < required_args || nargs > total_args) {
throw QueryRuntimeException("'{}' requires between {} and {} arguments.", name, required_args, total_args); throw QueryRuntimeException("'{}' requires between {} and {} arguments.", name, required_args, total_args);
@ -810,7 +810,7 @@ TypedValue StringMatchOperator(const TypedValue *args, int64_t nargs, const Func
// Check if s1 starts with s2. // Check if s1 starts with s2.
struct StartsWithPredicate { struct StartsWithPredicate {
constexpr static const char *name = "startsWith"; static constexpr const char *name = "startsWith";
bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const { bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const {
if (s1.size() < s2.size()) return false; if (s1.size() < s2.size()) return false;
return std::equal(s2.begin(), s2.end(), s1.begin()); return std::equal(s2.begin(), s2.end(), s1.begin());
@ -820,7 +820,7 @@ auto StartsWith = StringMatchOperator<StartsWithPredicate>;
// Check if s1 ends with s2. // Check if s1 ends with s2.
struct EndsWithPredicate { struct EndsWithPredicate {
constexpr static const char *name = "endsWith"; static constexpr const char *name = "endsWith";
bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const { bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const {
if (s1.size() < s2.size()) return false; if (s1.size() < s2.size()) return false;
return std::equal(s2.rbegin(), s2.rend(), s1.rbegin()); return std::equal(s2.rbegin(), s2.rend(), s1.rbegin());
@ -830,7 +830,7 @@ auto EndsWith = StringMatchOperator<EndsWithPredicate>;
// Check if s1 contains s2. // Check if s1 contains s2.
struct ContainsPredicate { struct ContainsPredicate {
constexpr static const char *name = "contains"; static constexpr const char *name = "contains";
bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const { bool operator()(const TypedValue::TString &s1, const TypedValue::TString &s2) const {
if (s1.size() < s2.size()) return false; if (s1.size() < s2.size()) return false;
return s1.find(s2) != std::string::npos; return s1.find(s2) != std::string::npos;

4
src/query/interpreter.cpp
View File

@ -554,7 +554,7 @@ std::vector<std::string> EvaluateTopicNames(ExpressionEvaluator &evaluator,
Callback::CallbackFunction GetKafkaCreateCallback(StreamQuery *stream_query, ExpressionEvaluator &evaluator, Callback::CallbackFunction GetKafkaCreateCallback(StreamQuery *stream_query, ExpressionEvaluator &evaluator,
InterpreterContext *interpreter_context, InterpreterContext *interpreter_context,
const std::string *username) { const std::string *username) {
constexpr std::string_view kDefaultConsumerGroup = "mg_consumer"; static constexpr std::string_view kDefaultConsumerGroup = "mg_consumer";
std::string consumer_group{stream_query->consumer_group_.empty() ? kDefaultConsumerGroup std::string consumer_group{stream_query->consumer_group_.empty() ? kDefaultConsumerGroup
: stream_query->consumer_group_}; : stream_query->consumer_group_};
@ -899,7 +899,7 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::Pull(AnyStream *strea
// Set up temporary memory for a single Pull. Initial memory comes from the // Set up temporary memory for a single Pull. Initial memory comes from the
// stack. 256 KiB should fit on the stack and should be more than enough for a // stack. 256 KiB should fit on the stack and should be more than enough for a
// single `Pull`. // single `Pull`.
constexpr size_t stack_size = 256 * 1024; static constexpr size_t stack_size = 256UL * 1024UL;
char stack_data[stack_size]; char stack_data[stack_size];
utils::ResourceWithOutOfMemoryException resource_with_exception; utils::ResourceWithOutOfMemoryException resource_with_exception;
utils::MonotonicBufferResource monotonic_memory(&stack_data[0], stack_size, &resource_with_exception); utils::MonotonicBufferResource monotonic_memory(&stack_data[0], stack_size, &resource_with_exception);

2
src/query/interpreter.hpp
View File

@ -47,7 +47,7 @@ extern const Event FailedQuery;
namespace memgraph::query { namespace memgraph::query {
static constexpr size_t kExecutionMemoryBlockSize = 1U * 1024U * 1024U; inline constexpr size_t kExecutionMemoryBlockSize = 1UL * 1024UL * 1024UL;
class AuthQueryHandler { class AuthQueryHandler {
public: public:

4
src/query/procedure/module.cpp
View File

@ -302,7 +302,7 @@ void RegisterMgTransformations(const std::map<std::string, std::unique_ptr<Modul
namespace { namespace {
bool IsAllowedExtension(const auto &extension) { bool IsAllowedExtension(const auto &extension) {
constexpr std::array<std::string_view, 1> allowed_extensions{".py"}; static constexpr std::array<std::string_view, 1> allowed_extensions{".py"};
return std::any_of(allowed_extensions.begin(), allowed_extensions.end(), return std::any_of(allowed_extensions.begin(), allowed_extensions.end(),
[&](const auto allowed_extension) { return allowed_extension == extension; }); [&](const auto allowed_extension) { return allowed_extension == extension; });
} }
@ -653,7 +653,7 @@ void RegisterMgDeleteModuleFile(ModuleRegistry *module_registry, utils::RWLock *
template <class TProcMap, class TTransMap, class TFun> template <class TProcMap, class TTransMap, class TFun>
auto WithModuleRegistration(TProcMap *proc_map, TTransMap *trans_map, const TFun &fun) { auto WithModuleRegistration(TProcMap *proc_map, TTransMap *trans_map, const TFun &fun) {
// We probably don't need more than 256KB for module initialization. // We probably don't need more than 256KB for module initialization.
constexpr size_t stack_bytes = 256 * 1024; static constexpr size_t stack_bytes = 256UL * 1024UL;
unsigned char stack_memory[stack_bytes]; unsigned char stack_memory[stack_bytes];
utils::MonotonicBufferResource monotonic_memory(stack_memory, stack_bytes); utils::MonotonicBufferResource monotonic_memory(stack_memory, stack_bytes);
mgp_memory memory{&monotonic_memory}; mgp_memory memory{&monotonic_memory};

3
src/query/procedure/py_module.cpp
View File

@ -2427,7 +2427,8 @@ mgp_value *PyObjectToMgpValue(PyObject *o, mgp_memory *memory) {
} }
static_cast<void>(local_date_time.release()); static_cast<void>(local_date_time.release());
} else if (PyDelta_CheckExact(o)) { } else if (PyDelta_CheckExact(o)) {
constexpr int64_t microseconds_in_days = static_cast<std::chrono::microseconds>(std::chrono::days{1}).count(); static constexpr int64_t microseconds_in_days =
static_cast<std::chrono::microseconds>(std::chrono::days{1}).count();
const auto days = const auto days =
PyDateTime_DELTA_GET_DAYS(o); // NOLINT(cppcoreguidelines-pro-type-cstyle-cast,hicpp-signed-bitwise) PyDateTime_DELTA_GET_DAYS(o); // NOLINT(cppcoreguidelines-pro-type-cstyle-cast,hicpp-signed-bitwise)
auto microseconds = auto microseconds =

4
src/query/stream/common.hpp
View File

@ -23,8 +23,8 @@
namespace memgraph::query::stream { namespace memgraph::query::stream {
constexpr std::chrono::milliseconds kDefaultBatchInterval{100}; inline constexpr std::chrono::milliseconds kDefaultBatchInterval{100};
constexpr int64_t kDefaultBatchSize{1000}; inline constexpr int64_t kDefaultBatchSize{1000};
template <typename TMessage> template <typename TMessage>
using ConsumerFunction = std::function<void(const std::vector<TMessage> &)>; using ConsumerFunction = std::function<void(const std::vector<TMessage> &)>;

39
src/query/stream/streams.cpp
View File

@ -42,7 +42,7 @@ extern const Event MessagesConsumed;
namespace memgraph::query::stream { namespace memgraph::query::stream {
namespace { namespace {
constexpr auto kExpectedTransformationResultSize = 2; inline constexpr auto kExpectedTransformationResultSize = 2;
const utils::pmr::string query_param_name{"query", utils::NewDeleteResource()}; const utils::pmr::string query_param_name{"query", utils::NewDeleteResource()};
const utils::pmr::string params_param_name{"parameters", utils::NewDeleteResource()}; const utils::pmr::string params_param_name{"parameters", utils::NewDeleteResource()};
@ -172,9 +172,9 @@ void Streams::RegisterProcedures() {
void Streams::RegisterKafkaProcedures() { void Streams::RegisterKafkaProcedures() {
{ {
constexpr std::string_view proc_name = "kafka_set_stream_offset"; static constexpr std::string_view proc_name = "kafka_set_stream_offset";
auto set_stream_offset = [this, proc_name](mgp_list *args, mgp_graph * /*graph*/, mgp_result *result, auto set_stream_offset = [this](mgp_list *args, mgp_graph * /*graph*/, mgp_result *result,
mgp_memory * /*memory*/) { mgp_memory * /*memory*/) {
auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0); auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0);
const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name); const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name);
auto *arg_offset = procedure::Call<mgp_value *>(mgp_list_at, args, 1); auto *arg_offset = procedure::Call<mgp_value *>(mgp_list_at, args, 1);
@ -190,7 +190,7 @@ void Streams::RegisterKafkaProcedures() {
"Unable to set procedure error message of procedure: {}", proc_name); "Unable to set procedure error message of procedure: {}", proc_name);
} }
}, },
[proc_name](auto && /*other*/) { [](auto && /*other*/) {
throw QueryRuntimeException("'{}' can be only used for Kafka stream sources", proc_name); throw QueryRuntimeException("'{}' can be only used for Kafka stream sources", proc_name);
}}, }},
it->second); it->second);
@ -205,17 +205,15 @@ void Streams::RegisterKafkaProcedures() {
} }
{ {
constexpr std::string_view proc_name = "kafka_stream_info"; static constexpr std::string_view proc_name = "kafka_stream_info";
constexpr std::string_view consumer_group_result_name = "consumer_group"; static constexpr std::string_view consumer_group_result_name = "consumer_group";
constexpr std::string_view topics_result_name = "topics"; static constexpr std::string_view topics_result_name = "topics";
constexpr std::string_view bootstrap_servers_result_name = "bootstrap_servers"; static constexpr std::string_view bootstrap_servers_result_name = "bootstrap_servers";
constexpr std::string_view configs_result_name = "configs"; static constexpr std::string_view configs_result_name = "configs";
constexpr std::string_view credentials_result_name = "credentials"; static constexpr std::string_view credentials_result_name = "credentials";
auto get_stream_info = [this, proc_name, consumer_group_result_name, topics_result_name, auto get_stream_info = [this](mgp_list *args, mgp_graph * /*graph*/, mgp_result *result, mgp_memory *memory) {
bootstrap_servers_result_name, configs_result_name, credentials_result_name](
mgp_list *args, mgp_graph * /*graph*/, mgp_result *result, mgp_memory *memory) {
auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0); auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0);
const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name); const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name);
auto lock_ptr = streams_.Lock(); auto lock_ptr = streams_.Lock();
@ -339,7 +337,7 @@ void Streams::RegisterKafkaProcedures() {
return; return;
} }
}, },
[proc_name](auto && /*other*/) { [](auto && /*other*/) {
throw QueryRuntimeException("'{}' can be only used for Kafka stream sources", proc_name); throw QueryRuntimeException("'{}' can be only used for Kafka stream sources", proc_name);
}}, }},
it->second); it->second);
@ -367,11 +365,10 @@ void Streams::RegisterKafkaProcedures() {
void Streams::RegisterPulsarProcedures() { void Streams::RegisterPulsarProcedures() {
{ {
constexpr std::string_view proc_name = "pulsar_stream_info"; static constexpr std::string_view proc_name = "pulsar_stream_info";
constexpr std::string_view service_url_result_name = "service_url"; static constexpr std::string_view service_url_result_name = "service_url";
constexpr std::string_view topics_result_name = "topics"; static constexpr std::string_view topics_result_name = "topics";
auto get_stream_info = [this, proc_name, service_url_result_name, topics_result_name]( auto get_stream_info = [this](mgp_list *args, mgp_graph * /*graph*/, mgp_result *result, mgp_memory *memory) {
mgp_list *args, mgp_graph * /*graph*/, mgp_result *result, mgp_memory *memory) {
auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0); auto *arg_stream_name = procedure::Call<mgp_value *>(mgp_list_at, args, 0);
const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name); const auto *stream_name = procedure::Call<const char *>(mgp_value_get_string, arg_stream_name);
auto lock_ptr = streams_.Lock(); auto lock_ptr = streams_.Lock();
@ -427,7 +424,7 @@ void Streams::RegisterPulsarProcedures() {
return; return;
} }
}, },
[proc_name](auto && /*other*/) { [](auto && /*other*/) {
throw QueryRuntimeException("'{}' can be only used for Pulsar stream sources", proc_name); throw QueryRuntimeException("'{}' can be only used for Pulsar stream sources", proc_name);
}}, }},
it->second); it->second);

4
src/query/trigger.cpp
View File

@ -219,7 +219,7 @@ void Trigger::Execute(DbAccessor *dba, utils::MonotonicBufferResource *execution
// Set up temporary memory for a single Pull. Initial memory comes from the // Set up temporary memory for a single Pull. Initial memory comes from the
// stack. 256 KiB should fit on the stack and should be more than enough for a // stack. 256 KiB should fit on the stack and should be more than enough for a
// single `Pull`. // single `Pull`.
constexpr size_t stack_size = 256 * 1024; static constexpr size_t stack_size = 256UL * 1024UL;
char stack_data[stack_size]; char stack_data[stack_size];
// We can throw on every query because a simple queries for deleting will use only // We can throw on every query because a simple queries for deleting will use only
@ -251,7 +251,7 @@ void Trigger::Execute(DbAccessor *dba, utils::MonotonicBufferResource *execution
namespace { namespace {
// When the format of the persisted trigger is changed, increase this version // When the format of the persisted trigger is changed, increase this version
constexpr uint64_t kVersion{2}; inline constexpr uint64_t kVersion{2};
} // namespace } // namespace
TriggerStore::TriggerStore(std::filesystem::path directory) : storage_{std::move(directory)} {} TriggerStore::TriggerStore(std::filesystem::path directory) : storage_{std::move(directory)} {}

4
src/query/typed_value.cpp
View File

@ -660,8 +660,8 @@ double ToDouble(const TypedValue &value) {
namespace { namespace {
bool IsTemporalType(const TypedValue::Type type) { bool IsTemporalType(const TypedValue::Type type) {
constexpr std::array temporal_types{TypedValue::Type::Date, TypedValue::Type::LocalTime, static constexpr std::array temporal_types{TypedValue::Type::Date, TypedValue::Type::LocalTime,
TypedValue::Type::LocalDateTime, TypedValue::Type::Duration}; TypedValue::Type::LocalDateTime, TypedValue::Type::Duration};
return std::any_of(temporal_types.begin(), temporal_types.end(), return std::any_of(temporal_types.begin(), temporal_types.end(),
[type](const auto temporal_type) { return temporal_type == type; }); [type](const auto temporal_type) { return temporal_type == type; });
}; };

2
src/storage/v2/storage.cpp
View File

@ -49,7 +49,7 @@ namespace memgraph::storage {
using OOMExceptionEnabler = utils::MemoryTracker::OutOfMemoryExceptionEnabler; using OOMExceptionEnabler = utils::MemoryTracker::OutOfMemoryExceptionEnabler;
namespace { namespace {
[[maybe_unused]] constexpr uint16_t kEpochHistoryRetention = 1000; inline constexpr uint16_t kEpochHistoryRetention = 1000;
} // namespace } // namespace
auto AdvanceToVisibleVertex(utils::SkipList<Vertex>::Iterator it, utils::SkipList<Vertex>::Iterator end, auto AdvanceToVisibleVertex(utils::SkipList<Vertex>::Iterator it, utils::SkipList<Vertex>::Iterator end,

4
src/utils/async_timer.cpp
View File

@ -25,7 +25,7 @@
namespace { namespace {
constexpr uint64_t kInvalidFlagId = 0U; inline constexpr uint64_t kInvalidFlagId = 0U;
// std::numeric_limits<time_t>::max() cannot be represented precisely as a double, so the next smallest value is the // std::numeric_limits<time_t>::max() cannot be represented precisely as a double, so the next smallest value is the
// maximum number of seconds the timer can be used with // maximum number of seconds the timer can be used with
const double max_seconds_as_double = std::nexttoward(std::numeric_limits<time_t>::max(), 0.0); const double max_seconds_as_double = std::nexttoward(std::numeric_limits<time_t>::max(), 0.0);
@ -143,7 +143,7 @@ AsyncTimer::AsyncTimer(double seconds)
MG_ASSERT(timer_create(CLOCK_MONOTONIC, &notification_settings, &timer_id_) == 0, "Couldn't create timer: ({}) {}", MG_ASSERT(timer_create(CLOCK_MONOTONIC, &notification_settings, &timer_id_) == 0, "Couldn't create timer: ({}) {}",
errno, strerror(errno)); errno, strerror(errno));
constexpr auto kSecondsToNanos = 1000 * 1000 * 1000; static constexpr auto kSecondsToNanos = 1000 * 1000 * 1000;
// Casting will truncate down, but that's exactly what we want. // Casting will truncate down, but that's exactly what we want.
const auto second_as_time_t = static_cast<time_t>(seconds); const auto second_as_time_t = static_cast<time_t>(seconds);
const auto remaining_nano_seconds = static_cast<time_t>((seconds - second_as_time_t) * kSecondsToNanos); const auto remaining_nano_seconds = static_cast<time_t>((seconds - second_as_time_t) * kSecondsToNanos);

2
src/utils/base64.cpp
View File

@ -45,7 +45,7 @@ namespace {
// two sets of base64 characters needs to be chosen. // two sets of base64 characters needs to be chosen.
// They differ in their last two characters. // They differ in their last two characters.
// //
constexpr std::array base64_chars = { inline constexpr std::array base64_chars = {
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
"0123456789" "0123456789"

4
src/utils/event_counter.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -65,7 +65,7 @@ namespace EventCounter {
APPLY_FOR_EVENTS(M) APPLY_FOR_EVENTS(M)
#undef M #undef M
constexpr Event END = __COUNTER__; inline constexpr Event END = __COUNTER__;
// Initialize array for the global counter with all values set to 0 // Initialize array for the global counter with all values set to 0
Counter global_counters_array[END]{}; Counter global_counters_array[END]{};

2
src/utils/file.hpp
View File

@ -68,7 +68,7 @@ bool RenamePath(const std::filesystem::path &src, const std::filesystem::path &d
/// `write` for each of our (very small) logical reads/writes. Because of that, /// `write` for each of our (very small) logical reads/writes. Because of that,
/// `read` or `write` is only called when the buffer is full and/or needs /// `read` or `write` is only called when the buffer is full and/or needs
/// emptying. /// emptying.
constexpr size_t kFileBufferSize = 262144; inline constexpr size_t kFileBufferSize = 262144;
/// This class implements a file handler that is used to read binary files. It /// This class implements a file handler that is used to read binary files. It
/// was developed because the C++ standard library has an awful API and makes /// was developed because the C++ standard library has an awful API and makes

4
src/utils/fnv.hpp
View File

@ -67,8 +67,8 @@ struct FnvCollection {
template <typename TA, typename TB, typename TAHash = std::hash<TA>, typename TBHash = std::hash<TB>> template <typename TA, typename TB, typename TAHash = std::hash<TA>, typename TBHash = std::hash<TB>>
struct HashCombine { struct HashCombine {
size_t operator()(const TA &a, const TB &b) const { size_t operator()(const TA &a, const TB &b) const {
constexpr size_t fnv_prime = 1099511628211UL; static constexpr size_t fnv_prime = 1099511628211UL;
constexpr size_t fnv_offset = 14695981039346656037UL; static constexpr size_t fnv_offset = 14695981039346656037UL;
size_t ret = fnv_offset; size_t ret = fnv_offset;
ret ^= TAHash()(a); ret ^= TAHash()(a);
ret *= fnv_prime; ret *= fnv_prime;

2
src/utils/license.cpp
View File

@ -30,7 +30,7 @@
namespace memgraph::utils::license { namespace memgraph::utils::license {
namespace { namespace {
constexpr std::string_view license_key_prefix = "mglk-"; inline constexpr std::string_view license_key_prefix = "mglk-";
std::optional<License> GetLicense(const std::string &license_key) { std::optional<License> GetLicense(const std::string &license_key) {
if (license_key.empty()) { if (license_key.empty()) {

4
src/utils/license.hpp
View File

@ -28,8 +28,8 @@ struct License {
bool operator==(const License &) const = default; bool operator==(const License &) const = default;
}; };
constexpr std::string_view kEnterpriseLicenseSettingKey = "enterprise.license"; inline constexpr std::string_view kEnterpriseLicenseSettingKey = "enterprise.license";
constexpr std::string_view kOrganizationNameSettingKey = "organization.name"; inline constexpr std::string_view kOrganizationNameSettingKey = "organization.name";
enum class LicenseCheckError : uint8_t { INVALID_LICENSE_KEY_STRING, INVALID_ORGANIZATION_NAME, EXPIRED_LICENSE }; enum class LicenseCheckError : uint8_t { INVALID_LICENSE_KEY_STRING, INVALID_ORGANIZATION_NAME, EXPIRED_LICENSE };

8
src/utils/math.hpp
View File

@ -24,7 +24,7 @@ static_assert(std::is_same_v<uint64_t, unsigned long>,
/// This function computes the log2 function on integer types. It is faster than /// This function computes the log2 function on integer types. It is faster than
/// the cmath `log2` function because it doesn't use floating point values for /// the cmath `log2` function because it doesn't use floating point values for
/// calculation. /// calculation.
constexpr inline uint64_t Log2(uint64_t val) { constexpr uint64_t Log2(uint64_t val) {
// The `clz` function is undefined when the passed value is 0 and the value of // The `clz` function is undefined when the passed value is 0 and the value of
// `log` is `-inf` so we special case it here. // `log` is `-inf` so we special case it here.
if (val == 0) return 0; if (val == 0) return 0;
@ -35,12 +35,12 @@ constexpr inline uint64_t Log2(uint64_t val) {
} }
/// Return `true` if `val` is a power of 2. /// Return `true` if `val` is a power of 2.
constexpr inline bool IsPow2(uint64_t val) noexcept { return val != 0ULL && (val & (val - 1ULL)) == 0ULL; } constexpr bool IsPow2(uint64_t val) noexcept { return val != 0ULL && (val & (val - 1ULL)) == 0ULL; }
/// Return `val` if it is power of 2, otherwise get the next power of 2 value. /// Return `val` if it is power of 2, otherwise get the next power of 2 value.
/// If `val` is sufficiently large, the next power of 2 value may not fit into /// If `val` is sufficiently large, the next power of 2 value may not fit into
/// the result type and you will get a wrapped value to 1ULL. /// the result type and you will get a wrapped value to 1ULL.
constexpr inline uint64_t Ceil2(uint64_t val) noexcept { constexpr uint64_t Ceil2(uint64_t val) noexcept {
if (val == 0ULL || val == 1ULL) return 1ULL; if (val == 0ULL || val == 1ULL) return 1ULL;
return 1ULL << (Log2(val - 1ULL) + 1ULL); return 1ULL << (Log2(val - 1ULL) + 1ULL);
} }
@ -53,7 +53,7 @@ constexpr inline uint64_t Ceil2(uint64_t val) noexcept {
/// RoundUint64ToMultiple(5, 8) == 8 /// RoundUint64ToMultiple(5, 8) == 8
/// RoundUint64ToMultiple(8, 8) == 8 /// RoundUint64ToMultiple(8, 8) == 8
/// RoundUint64ToMultiple(9, 8) == 16 /// RoundUint64ToMultiple(9, 8) == 16
constexpr inline std::optional<uint64_t> RoundUint64ToMultiple(uint64_t val, uint64_t multiple) noexcept { constexpr std::optional<uint64_t> RoundUint64ToMultiple(uint64_t val, uint64_t multiple) noexcept {
if (multiple == 0) return std::nullopt; if (multiple == 0) return std::nullopt;
uint64_t numerator = val + multiple - 1; uint64_t numerator = val + multiple - 1;
// Check for overflow. // Check for overflow.

4
src/utils/readable_size.cpp
View File

@ -19,8 +19,8 @@ namespace memgraph::utils {
std::string GetReadableSize(double size) { std::string GetReadableSize(double size) {
// TODO (antonio2368): Add support for base 1000 (KB, GB, TB...) // TODO (antonio2368): Add support for base 1000 (KB, GB, TB...)
constexpr std::array units = {"B", "KiB", "MiB", "GiB", "TiB"}; static constexpr std::array units = {"B", "KiB", "MiB", "GiB", "TiB"};
constexpr double delimiter = 1024; static constexpr double delimiter = 1024;
size_t i = 0; size_t i = 0;
for (; i + 1 < units.size() && size >= delimiter; ++i) { for (; i + 1 < units.size() && size >= delimiter; ++i) {

2
src/utils/small_vector.hpp
View File

@ -325,7 +325,7 @@ class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
}; };
template <typename T> template <typename T>
constexpr bool is_pod = std::is_standard_layout_v<T> &&std::is_trivial_v<T>; inline constexpr bool is_pod = std::is_standard_layout_v<T> &&std::is_trivial_v<T>;
/// This class consists of common code factored out of the SmallVector class to /// This class consists of common code factored out of the SmallVector class to
/// reduce code duplication based on the SmallVector 'n' template parameter. /// reduce code duplication based on the SmallVector 'n' template parameter.

10
src/utils/temporal.cpp
View File

@ -90,7 +90,7 @@ LocalDateTime CurrentLocalDateTime() {
} }
namespace { namespace {
constexpr auto *kSupportedDateFormatsHelpMessage = R"help( inline constexpr auto *kSupportedDateFormatsHelpMessage = R"help(
String representing the date should be in one of the following formats: String representing the date should be in one of the following formats:
- YYYY-MM-DD - YYYY-MM-DD
@ -112,7 +112,7 @@ std::pair<DateParameters, bool> ParseDateParameters(std::string_view date_string
// https://en.wikipedia.org/wiki/ISO_8601#Dates // https://en.wikipedia.org/wiki/ISO_8601#Dates
// Date string with the '-' as separator are in the EXTENDED format, // Date string with the '-' as separator are in the EXTENDED format,
// otherwise they are in a BASIC format // otherwise they are in a BASIC format
constexpr std::array valid_sizes{ static constexpr std::array valid_sizes{
10, // YYYY-MM-DD 10, // YYYY-MM-DD
8, // YYYYMMDD 8, // YYYYMMDD
7 // YYYY-MM 7 // YYYY-MM
@ -184,7 +184,7 @@ size_t DateHash::operator()(const Date &date) const {
} }
namespace { namespace {
constexpr auto *kSupportedTimeFormatsHelpMessage = R"help( inline constexpr auto *kSupportedTimeFormatsHelpMessage = R"help(
String representing the time should be in one of the following formats: String representing the time should be in one of the following formats:
- [T]hh:mm:ss - [T]hh:mm:ss
@ -388,7 +388,7 @@ size_t LocalTimeHash::operator()(const LocalTime &local_time) const {
} }
namespace { namespace {
constexpr auto *kSupportedLocalDateTimeFormatsHelpMessage = R"help( inline constexpr auto *kSupportedLocalDateTimeFormatsHelpMessage = R"help(
String representing the LocalDateTime should be in one of the following formats: String representing the LocalDateTime should be in one of the following formats:
- YYYY-MM-DDThh:mm:ss - YYYY-MM-DDThh:mm:ss
@ -458,7 +458,7 @@ std::pair<DateParameters, LocalTimeParameters> ParseLocalDateTimeParameters(std:
LocalDateTime::LocalDateTime(const int64_t microseconds) { LocalDateTime::LocalDateTime(const int64_t microseconds) {
auto chrono_microseconds = std::chrono::microseconds(microseconds); auto chrono_microseconds = std::chrono::microseconds(microseconds);
constexpr int64_t one_day_in_microseconds = std::chrono::microseconds{std::chrono::days{1}}.count(); static constexpr int64_t one_day_in_microseconds = std::chrono::microseconds{std::chrono::days{1}}.count();
if (microseconds < 0 && (microseconds % one_day_in_microseconds != 0)) { if (microseconds < 0 && (microseconds % one_day_in_microseconds != 0)) {
date = Date(microseconds - one_day_in_microseconds); date = Date(microseconds - one_day_in_microseconds);
} else { } else {

3
src/utils/temporal.hpp
View File

@ -235,7 +235,8 @@ struct LocalTime {
auto abs = [](auto value) { return (value >= 0) ? value : -value; }; auto abs = [](auto value) { return (value >= 0) ? value : -value; };
const auto lhs = local_time.MicrosecondsSinceEpoch(); const auto lhs = local_time.MicrosecondsSinceEpoch();
if (rhs < 0 && lhs < abs(rhs)) { if (rhs < 0 && lhs < abs(rhs)) {
constexpr int64_t one_day_in_microseconds = chrono::duration_cast<chrono::microseconds>(chrono::days(1)).count(); static constexpr int64_t one_day_in_microseconds =
chrono::duration_cast<chrono::microseconds>(chrono::days(1)).count();
rhs = one_day_in_microseconds + rhs; rhs = one_day_in_microseconds + rhs;
} }
auto result = chrono::microseconds(lhs + rhs); auto result = chrono::microseconds(lhs + rhs);

2
src/utils/thread.cpp
View File

@ -18,7 +18,7 @@
namespace memgraph::utils { namespace memgraph::utils {
void ThreadSetName(const std::string &name) { void ThreadSetName(const std::string &name) {
constexpr auto max_name_length = GetMaxThreadNameSize(); static constexpr auto max_name_length = GetMaxThreadNameSize();
MG_ASSERT(name.size() <= max_name_length, "Thread name '{}' is too long", max_name_length); MG_ASSERT(name.size() <= max_name_length, "Thread name '{}' is too long", max_name_length);
if (prctl(PR_SET_NAME, name.c_str()) != 0) { if (prctl(PR_SET_NAME, name.c_str()) != 0) {

2
tests/benchmark/query/profile.cpp
View File

@ -409,7 +409,7 @@ namespace tree_storage {
// //
// ProfilingStats // ProfilingStats
constexpr size_t kMaxProfilingStatsChildren = 3; inline constexpr size_t kMaxProfilingStatsChildren = 3;
struct ProfilingStatsStorage; struct ProfilingStatsStorage;
struct ProfilingStats { struct ProfilingStats {

4
tests/concurrent/common.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -24,7 +24,7 @@
// TODO: REFACTOR // TODO: REFACTOR
// Sets max number of threads that will be used in concurrent tests. // Sets max number of threads that will be used in concurrent tests.
constexpr int max_no_threads = 8; inline constexpr int max_no_threads = 8;
using std::cout; using std::cout;
using std::endl; using std::endl;

4
tests/concurrent/network_common.hpp
View File

@ -22,8 +22,8 @@
#include "communication/server.hpp" #include "communication/server.hpp"
static constexpr const int SIZE = 60000; inline constexpr const int SIZE = 60000;
static constexpr const int REPLY = 10; inline constexpr const int REPLY = 10;
using memgraph::io::network::Endpoint; using memgraph::io::network::Endpoint;
using memgraph::io::network::Socket; using memgraph::io::network::Socket;

2
tests/concurrent/network_read_hang.cpp
View File

@ -24,7 +24,7 @@
#include "communication/server.hpp" #include "communication/server.hpp"
static constexpr const char interface[] = "127.0.0.1"; inline constexpr const char interface[] = "127.0.0.1";
using memgraph::io::network::Endpoint; using memgraph::io::network::Endpoint;
using memgraph::io::network::Socket; using memgraph::io::network::Socket;

4
tests/concurrent/network_server.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -17,7 +17,7 @@
#include "network_common.hpp" #include "network_common.hpp"
static constexpr const char interface[] = "127.0.0.1"; inline constexpr const char interface[] = "127.0.0.1";
unsigned char data[SIZE]; unsigned char data[SIZE];

4
tests/concurrent/network_session_leak.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -18,7 +18,7 @@
#include "network_common.hpp" #include "network_common.hpp"
static constexpr const char interface[] = "127.0.0.1"; inline constexpr const char interface[] = "127.0.0.1";
unsigned char data[SIZE]; unsigned char data[SIZE];

2
tests/concurrent/spin_lock.cpp
View File

@ -37,7 +37,7 @@ void test_lock() {
} }
int main() { int main() {
constexpr int N = 16; static constexpr int N = 16;
std::vector<std::thread> threads; std::vector<std::thread> threads;
for (int i = 0; i < N; ++i) threads.push_back(std::thread(test_lock)); for (int i = 0; i < N; ++i) threads.push_back(std::thread(test_lock));

12
tests/e2e/isolation_levels/isolation_levels.cpp
View File

@ -54,7 +54,7 @@ void TestSnapshotIsolation(std::unique_ptr<mg::Client> &client) {
MG_ASSERT(client->BeginTransaction()); MG_ASSERT(client->BeginTransaction());
MG_ASSERT(creator->BeginTransaction()); MG_ASSERT(creator->BeginTransaction());
constexpr auto vertex_count = 10; static constexpr auto vertex_count = 10;
for (size_t i = 0; i < vertex_count; ++i) { for (size_t i = 0; i < vertex_count; ++i) {
MG_ASSERT(creator->Execute("CREATE ()")); MG_ASSERT(creator->Execute("CREATE ()"));
creator->DiscardAll(); creator->DiscardAll();
@ -87,7 +87,7 @@ void TestReadCommitted(std::unique_ptr<mg::Client> &client) {
MG_ASSERT(client->BeginTransaction()); MG_ASSERT(client->BeginTransaction());
MG_ASSERT(creator->BeginTransaction()); MG_ASSERT(creator->BeginTransaction());
constexpr auto vertex_count = 10; static constexpr auto vertex_count = 10;
for (size_t i = 0; i < vertex_count; ++i) { for (size_t i = 0; i < vertex_count; ++i) {
MG_ASSERT(creator->Execute("CREATE ()")); MG_ASSERT(creator->Execute("CREATE ()"));
creator->DiscardAll(); creator->DiscardAll();
@ -119,7 +119,7 @@ void TestReadUncommitted(std::unique_ptr<mg::Client> &client) {
MG_ASSERT(client->BeginTransaction()); MG_ASSERT(client->BeginTransaction());
MG_ASSERT(creator->BeginTransaction()); MG_ASSERT(creator->BeginTransaction());
constexpr auto vertex_count = 10; static constexpr auto vertex_count = 10;
for (size_t i = 1; i <= vertex_count; ++i) { for (size_t i = 1; i <= vertex_count; ++i) {
MG_ASSERT(creator->Execute("CREATE ()")); MG_ASSERT(creator->Execute("CREATE ()"));
creator->DiscardAll(); creator->DiscardAll();
@ -142,9 +142,9 @@ void TestReadUncommitted(std::unique_ptr<mg::Client> &client) {
CleanDatabase(); CleanDatabase();
} }
constexpr std::array isolation_levels{std::pair{"SNAPSHOT ISOLATION", &TestSnapshotIsolation}, inline constexpr std::array isolation_levels{std::pair{"SNAPSHOT ISOLATION", &TestSnapshotIsolation},
std::pair{"READ COMMITTED", &TestReadCommitted}, std::pair{"READ COMMITTED", &TestReadCommitted},
std::pair{"READ UNCOMMITTED", &TestReadUncommitted}}; std::pair{"READ UNCOMMITTED", &TestReadUncommitted}};
void TestGlobalIsolationLevel() { void TestGlobalIsolationLevel() {
spdlog::info("\n\n----Test global isolation levels----\n"); spdlog::info("\n\n----Test global isolation levels----\n");

6
tests/e2e/module_file_manager/module_file_manager.cpp
View File

@ -159,13 +159,13 @@ void DeleteModuleFile(auto &client, const std::filesystem::path &path) {
MG_ASSERT(client->FetchAll().has_value()); MG_ASSERT(client->FetchAll().has_value());
} }
constexpr std::string_view module_content1 = R"(import mgp inline constexpr std::string_view module_content1 = R"(import mgp
@mgp.read_proc @mgp.read_proc
def simple1(ctx: mgp.ProcCtx) -> mgp.Record(result=bool): def simple1(ctx: mgp.ProcCtx) -> mgp.Record(result=bool):
return mgp.Record(mutable=True))"; return mgp.Record(mutable=True))";
constexpr std::string_view module_content2 = R"(import mgp inline constexpr std::string_view module_content2 = R"(import mgp
@mgp.read_proc @mgp.read_proc
def simple2(ctx: mgp.ProcCtx) -> mgp.Record(result=bool): def simple2(ctx: mgp.ProcCtx) -> mgp.Record(result=bool):
@ -247,7 +247,7 @@ int main(int argc, char **argv) {
{ {
std::ofstream non_module_file{non_module_file_path}; std::ofstream non_module_file{non_module_file_path};
MG_ASSERT(non_module_file.is_open(), "Failed to open {} for writing", non_module_file_path); MG_ASSERT(non_module_file.is_open(), "Failed to open {} for writing", non_module_file_path);
constexpr std::string_view content = "import mgp"; static constexpr std::string_view content = "import mgp";
non_module_file.write(content.data(), content.size()); non_module_file.write(content.data(), content.size());
non_module_file.flush(); non_module_file.flush();
} }

6
tests/e2e/triggers/common.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -18,8 +18,8 @@
#include <mgclient.hpp> #include <mgclient.hpp>
constexpr std::string_view kVertexLabel{"VERTEX"}; inline constexpr std::string_view kVertexLabel{"VERTEX"};
constexpr std::string_view kEdgeLabel{"EDGE"}; inline constexpr std::string_view kEdgeLabel{"EDGE"};
std::unique_ptr<mg::Client> Connect(); std::unique_ptr<mg::Client> Connect();
std::unique_ptr<mg::Client> ConnectWithUser(const std::string_view username); std::unique_ptr<mg::Client> ConnectWithUser(const std::string_view username);

16
tests/e2e/triggers/on_create_triggers.cpp
View File

@ -17,9 +17,9 @@
#include "common.hpp" #include "common.hpp"
#include "utils/logging.hpp" #include "utils/logging.hpp"
constexpr std::string_view kTriggerCreatedVertexLabel{"CREATED_VERTEX"}; inline constexpr std::string_view kTriggerCreatedVertexLabel{"CREATED_VERTEX"};
constexpr std::string_view kTriggerCreatedEdgeLabel{"CREATED_EDGE"}; inline constexpr std::string_view kTriggerCreatedEdgeLabel{"CREATED_EDGE"};
constexpr std::string_view kTriggerCreatedObjectLabel{"CREATED_OBJECT"}; inline constexpr std::string_view kTriggerCreatedObjectLabel{"CREATED_OBJECT"};
void CreateOnCreateTriggers(mg::Client &client, bool is_before) { void CreateOnCreateTriggers(mg::Client &client, bool is_before) {
const std::string_view before_or_after = is_before ? "BEFORE" : "AFTER"; const std::string_view before_or_after = is_before ? "BEFORE" : "AFTER";
@ -90,7 +90,7 @@ int main(int argc, char **argv) {
// :CREATED_VERTEX x 2 // :CREATED_VERTEX x 2
// :CREATED_EDGE x 1 // :CREATED_EDGE x 1
// :CREATED_OBJECT x 3 // :CREATED_OBJECT x 3
constexpr auto kNumberOfExpectedVertices = 8; static constexpr auto kNumberOfExpectedVertices = 8;
if (is_before) { if (is_before) {
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
@ -109,15 +109,15 @@ int main(int argc, char **argv) {
client->DiscardAll(); client->DiscardAll();
} }
}; };
constexpr bool kBeforeCommit = true; static constexpr bool kBeforeCommit = true;
constexpr bool kAfterCommit = false; static constexpr bool kAfterCommit = false;
run_create_trigger_tests(kBeforeCommit); run_create_trigger_tests(kBeforeCommit);
run_create_trigger_tests(kAfterCommit); run_create_trigger_tests(kAfterCommit);
const auto run_create_trigger_write_proc_create_vertex_test = [&]() { const auto run_create_trigger_write_proc_create_vertex_test = [&]() {
CreateOnCreateTriggers(*client, true); CreateOnCreateTriggers(*client, true);
ExecuteCreateVertex(*client, 1); ExecuteCreateVertex(*client, 1);
constexpr auto kNumberOfExpectedVertices = 3; static constexpr auto kNumberOfExpectedVertices = 3;
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
CheckVertexExists(*client, kTriggerCreatedVertexLabel, 1); CheckVertexExists(*client, kTriggerCreatedVertexLabel, 1);
CheckVertexExists(*client, kTriggerCreatedObjectLabel, 1); CheckVertexExists(*client, kTriggerCreatedObjectLabel, 1);
@ -133,7 +133,7 @@ int main(int argc, char **argv) {
CreateOnCreateTriggers(*client, true); CreateOnCreateTriggers(*client, true);
client->Execute("MATCH (n {id:1}), (m {id:2}) CALL write.create_edge(n, m, 'edge') YIELD e RETURN e"); client->Execute("MATCH (n {id:1}), (m {id:2}) CALL write.create_edge(n, m, 'edge') YIELD e RETURN e");
client->DiscardAll(); client->DiscardAll();
constexpr auto kNumberOfExpectedVertices = 4; static constexpr auto kNumberOfExpectedVertices = 4;
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
CheckVertexExists(*client, kTriggerCreatedEdgeLabel, 1); CheckVertexExists(*client, kTriggerCreatedEdgeLabel, 1);
CheckVertexExists(*client, kTriggerCreatedObjectLabel, 1); CheckVertexExists(*client, kTriggerCreatedObjectLabel, 1);

15
tests/e2e/triggers/on_delete_triggers.cpp
View File

@ -18,9 +18,9 @@
#include "common.hpp" #include "common.hpp"
#include "utils/logging.hpp" #include "utils/logging.hpp"
constexpr std::string_view kTriggerDeletedVertexLabel{"DELETED_VERTEX"}; inline constexpr std::string_view kTriggerDeletedVertexLabel{"DELETED_VERTEX"};
constexpr std::string_view kTriggerDeletedEdgeLabel{"DELETED_EDGE"}; inline constexpr std::string_view kTriggerDeletedEdgeLabel{"DELETED_EDGE"};
constexpr std::string_view kTriggerDeletedObjectLabel{"DELETED_OBJECT"}; inline constexpr std::string_view kTriggerDeletedObjectLabel{"DELETED_OBJECT"};
enum class AllowedTriggerType : uint8_t { enum class AllowedTriggerType : uint8_t {
VERTEX, VERTEX,
@ -138,8 +138,9 @@ int main(int argc, char **argv) {
const auto run_delete_trigger_tests = [&](const bool is_before, const auto run_delete_trigger_tests = [&](const bool is_before,
const std::unordered_set<AllowedTriggerType> &allowed_trigger_types) { const std::unordered_set<AllowedTriggerType> &allowed_trigger_types) {
constexpr std::array vertex_ids{1, 2, 3, 4}; static constexpr std::array vertex_ids{1, 2, 3, 4};
constexpr std::array edges{EdgeInfo{vertex_ids[0], vertex_ids[1], 5}, EdgeInfo{vertex_ids[2], vertex_ids[3], 6}}; static constexpr std::array edges{EdgeInfo{vertex_ids[0], vertex_ids[1], 5},
EdgeInfo{vertex_ids[2], vertex_ids[3], 6}};
{ {
CreateOnDeleteTriggers(*client, is_before, allowed_trigger_types); CreateOnDeleteTriggers(*client, is_before, allowed_trigger_types);
@ -303,8 +304,8 @@ int main(int argc, char **argv) {
} }
}; };
constexpr bool kBeforeCommit = true; static constexpr bool kBeforeCommit = true;
constexpr bool kAfterCommit = false; static constexpr bool kAfterCommit = false;
run_for_trigger_combinations(kBeforeCommit); run_for_trigger_combinations(kBeforeCommit);
run_for_trigger_combinations(kAfterCommit); run_for_trigger_combinations(kAfterCommit);

38
tests/e2e/triggers/on_update_triggers.cpp
View File

@ -17,15 +17,15 @@
#include "common.hpp" #include "common.hpp"
#include "utils/logging.hpp" #include "utils/logging.hpp"
constexpr std::string_view kTriggerUpdatedVertexLabel{"UPDATED_VERTEX"}; inline constexpr std::string_view kTriggerUpdatedVertexLabel{"UPDATED_VERTEX"};
constexpr std::string_view kTriggerUpdatedEdgeLabel{"UPDATED_EDGE"}; inline constexpr std::string_view kTriggerUpdatedEdgeLabel{"UPDATED_EDGE"};
constexpr std::string_view kTriggerUpdatedObjectLabel{"UPDATED_OBJECT"}; inline constexpr std::string_view kTriggerUpdatedObjectLabel{"UPDATED_OBJECT"};
constexpr std::string_view kTriggerSetVertexPropertyLabel{"SET_VERTEX_PROPERTY"}; inline constexpr std::string_view kTriggerSetVertexPropertyLabel{"SET_VERTEX_PROPERTY"};
constexpr std::string_view kTriggerRemovedVertexPropertyLabel{"REMOVED_VERTEX_PROPERTY"}; inline constexpr std::string_view kTriggerRemovedVertexPropertyLabel{"REMOVED_VERTEX_PROPERTY"};
constexpr std::string_view kTriggerSetVertexLabelLabel{"SET_VERTEX_LABEL"}; inline constexpr std::string_view kTriggerSetVertexLabelLabel{"SET_VERTEX_LABEL"};
constexpr std::string_view kTriggerRemovedVertexLabelLabel{"REMOVED_VERTEX_LABEL"}; inline constexpr std::string_view kTriggerRemovedVertexLabelLabel{"REMOVED_VERTEX_LABEL"};
constexpr std::string_view kTriggerSetEdgePropertyLabel{"SET_EDGE_PROPERTY"}; inline constexpr std::string_view kTriggerSetEdgePropertyLabel{"SET_EDGE_PROPERTY"};
constexpr std::string_view kTriggerRemovedEdgePropertyLabel{"REMOVED_EDGE_PROPERTY"}; inline constexpr std::string_view kTriggerRemovedEdgePropertyLabel{"REMOVED_EDGE_PROPERTY"};
void SetVertexProperty(mg::Client &client, int vertex_id, std::string_view property_name, mg::Value value) { void SetVertexProperty(mg::Client &client, int vertex_id, std::string_view property_name, mg::Value value) {
mg::Map parameters{ mg::Map parameters{
@ -193,8 +193,8 @@ struct EdgeInfo {
}; };
int main(int argc, char **argv) { int main(int argc, char **argv) {
constexpr std::string_view kExtraLabel = "EXTRA_LABEL"; static constexpr std::string_view kExtraLabel = "EXTRA_LABEL";
constexpr std::string_view kUpdatedProperty = "updateProperty"; static constexpr std::string_view kUpdatedProperty = "updateProperty";
gflags::SetUsageMessage("Memgraph E2E ON UPDATE Triggers"); gflags::SetUsageMessage("Memgraph E2E ON UPDATE Triggers");
gflags::ParseCommandLineFlags(&argc, &argv, true); gflags::ParseCommandLineFlags(&argc, &argv, true);
memgraph::logging::RedirectToStderr(); memgraph::logging::RedirectToStderr();
@ -242,7 +242,7 @@ int main(int argc, char **argv) {
// :REMOVED_VERTEX_LABEL x 1 // :REMOVED_VERTEX_LABEL x 1
// :SET_EDGE_PROPERTY x 1 // :SET_EDGE_PROPERTY x 1
// :REMOVED_EDGE_PROPERTY x 1 // :REMOVED_EDGE_PROPERTY x 1
constexpr auto kNumberOfExpectedVertices = 22; static constexpr auto kNumberOfExpectedVertices = 22;
if (is_before) { if (is_before) {
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
@ -288,8 +288,8 @@ int main(int argc, char **argv) {
client->DiscardAll(); client->DiscardAll();
} }
}; };
constexpr bool kBeforeCommit = true; static constexpr bool kBeforeCommit = true;
constexpr bool kAfterCommit = false; static constexpr bool kAfterCommit = false;
run_update_trigger_tests(kBeforeCommit); run_update_trigger_tests(kBeforeCommit);
run_update_trigger_tests(kAfterCommit); run_update_trigger_tests(kAfterCommit);
@ -298,8 +298,8 @@ int main(int argc, char **argv) {
ExecuteCreateVertex(*client, 1); ExecuteCreateVertex(*client, 1);
client->Execute("MATCH (n) CALL write.set_property(n)"); client->Execute("MATCH (n) CALL write.set_property(n)");
client->DiscardAll(); client->DiscardAll();
constexpr auto kNumberOfExpectedVertices = 4; static constexpr auto kNumberOfExpectedVertices = 4;
constexpr int expected_updated_id = 2; static constexpr int expected_updated_id = 2;
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
CheckVertexExists(*client, kTriggerUpdatedVertexLabel, expected_updated_id); CheckVertexExists(*client, kTriggerUpdatedVertexLabel, expected_updated_id);
CheckVertexExists(*client, kTriggerUpdatedObjectLabel, expected_updated_id); CheckVertexExists(*client, kTriggerUpdatedObjectLabel, expected_updated_id);
@ -327,8 +327,8 @@ int main(int argc, char **argv) {
client->DiscardAll(); client->DiscardAll();
client->Execute("MATCH ()-[e]->() CALL write.set_property(e)"); client->Execute("MATCH ()-[e]->() CALL write.set_property(e)");
client->DiscardAll(); client->DiscardAll();
constexpr auto kNumberOfExpectedVertices = 5; static constexpr auto kNumberOfExpectedVertices = 5;
constexpr int expected_updated_id = 2; static constexpr int expected_updated_id = 2;
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
CheckVertexExists(*client, kTriggerSetEdgePropertyLabel, expected_updated_id); CheckVertexExists(*client, kTriggerSetEdgePropertyLabel, expected_updated_id);
CheckVertexExists(*client, kTriggerUpdatedObjectLabel, expected_updated_id); CheckVertexExists(*client, kTriggerUpdatedObjectLabel, expected_updated_id);
@ -355,7 +355,7 @@ int main(int argc, char **argv) {
CreateOnUpdateTriggers(*client, true); CreateOnUpdateTriggers(*client, true);
client->Execute("MATCH (n) CALL write.add_label(n, 'new') YIELD o RETURN o"); client->Execute("MATCH (n) CALL write.add_label(n, 'new') YIELD o RETURN o");
client->DiscardAll(); client->DiscardAll();
constexpr auto kNumberOfExpectedVertices = 4; static constexpr auto kNumberOfExpectedVertices = 4;
CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices); CheckNumberOfAllVertices(*client, kNumberOfExpectedVertices);
CheckVertexExists(*client, kTriggerSetVertexLabelLabel, 1); CheckVertexExists(*client, kTriggerSetVertexLabelLabel, 1);
CheckVertexExists(*client, kTriggerUpdatedVertexLabel, 1); CheckVertexExists(*client, kTriggerUpdatedVertexLabel, 1);

12
tests/e2e/triggers/privilige_check.cpp
View File

@ -18,7 +18,7 @@
#include "common.hpp" #include "common.hpp"
#include "utils/logging.hpp" #include "utils/logging.hpp"
constexpr std::string_view kTriggerPrefix{"CreatedVerticesTrigger"}; inline constexpr std::string_view kTriggerPrefix{"CreatedVerticesTrigger"};
template <typename TException> template <typename TException>
bool FunctionThrows(const auto &function) { bool FunctionThrows(const auto &function) {
@ -35,11 +35,11 @@ int main(int argc, char **argv) {
gflags::ParseCommandLineFlags(&argc, &argv, true); gflags::ParseCommandLineFlags(&argc, &argv, true);
memgraph::logging::RedirectToStderr(); memgraph::logging::RedirectToStderr();
constexpr int kVertexId{42}; static constexpr int kVertexId{42};
constexpr std::string_view kUserlessLabel{"USERLESS"}; static constexpr std::string_view kUserlessLabel{"USERLESS"};
constexpr std::string_view kAdminUser{"ADMIN"}; static constexpr std::string_view kAdminUser{"ADMIN"};
constexpr std::string_view kUserWithCreate{"USER_WITH_CREATE"}; static constexpr std::string_view kUserWithCreate{"USER_WITH_CREATE"};
constexpr std::string_view kUserWithoutCreate{"USER_WITHOUT_CREATE"}; static constexpr std::string_view kUserWithoutCreate{"USER_WITHOUT_CREATE"};
mg::Client::Init(); mg::Client::Init();

2
tests/e2e/websocket/common.hpp
View File

@ -41,7 +41,7 @@ namespace net = boost::asio;
using tcp = boost::asio::ip::tcp; using tcp = boost::asio::ip::tcp;
namespace ssl = boost::asio::ssl; namespace ssl = boost::asio::ssl;
constexpr std::array kSupportedLogLevels{"debug", "trace", "info", "warning", "error", "critical"}; inline constexpr std::array kSupportedLogLevels{"debug", "trace", "info", "warning", "error", "critical"};
struct Credentials { struct Credentials {
std::string_view username; std::string_view username;

2
tests/unit/bolt_chunked_decoder_buffer.cpp
View File

@ -13,7 +13,7 @@
#include "communication/bolt/v1/decoder/chunked_decoder_buffer.hpp" #include "communication/bolt/v1/decoder/chunked_decoder_buffer.hpp"
#include "communication/buffer.hpp" #include "communication/buffer.hpp"
constexpr const int SIZE = 131072; inline constexpr const int SIZE = 131072;
uint8_t data[SIZE]; uint8_t data[SIZE];
using BufferT = memgraph::communication::Buffer; using BufferT = memgraph::communication::Buffer;

2
tests/unit/bolt_chunked_encoder_buffer.cpp
View File

@ -21,7 +21,7 @@ using memgraph::communication::bolt::kChunkMaxDataSize;
using memgraph::communication::bolt::kChunkWholeSize; using memgraph::communication::bolt::kChunkWholeSize;
// test data // test data
constexpr const int kTestDataSize = 100000; inline constexpr const int kTestDataSize = 100000;
uint8_t test_data[kTestDataSize]; uint8_t test_data[kTestDataSize];
struct BoltChunkedEncoderBuffer : ::testing::Test { struct BoltChunkedEncoderBuffer : ::testing::Test {

2
tests/unit/bolt_decoder.cpp
View File

@ -17,7 +17,7 @@
using memgraph::communication::bolt::Value; using memgraph::communication::bolt::Value;
constexpr const int SIZE = 131072; inline constexpr const int SIZE = 131072;
uint8_t data[SIZE]; uint8_t data[SIZE];
/** /**

2
tests/unit/bolt_encoder.cpp
View File

@ -25,7 +25,7 @@ using memgraph::communication::bolt::Value;
* TODO (mferencevic): document * TODO (mferencevic): document
*/ */
constexpr const int SIZE = 131072; inline constexpr const int SIZE = 131072;
uint8_t data[SIZE]; uint8_t data[SIZE];
uint64_t GetBigEndianInt(std::vector<uint8_t> &v, uint8_t len, uint8_t offset = 1) { uint64_t GetBigEndianInt(std::vector<uint8_t> &v, uint8_t len, uint8_t offset = 1) {

70
tests/unit/bolt_session.cpp
View File

@ -100,29 +100,30 @@ class TestSession : public Session<TestInputStream, TestOutputStream> {
std::vector<uint8_t> &output = output_stream.output; std::vector<uint8_t> &output = output_stream.output;
// Sample testdata that has correct inputs and outputs. // Sample testdata that has correct inputs and outputs.
constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, inline constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x00, 0x01}; inline constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x00, 0x01};
constexpr uint8_t init_req[] = {0xb2, 0x01, 0xd0, 0x15, 0x6c, 0x69, 0x62, 0x6e, 0x65, 0x6f, 0x34, 0x6a, 0x2d, inline constexpr uint8_t init_req[] = {0xb2, 0x01, 0xd0, 0x15, 0x6c, 0x69, 0x62, 0x6e, 0x65, 0x6f, 0x34, 0x6a, 0x2d,
0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x31, 0x2e, 0x32, 0x2e, 0x31, 0xa3, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x31, 0x2e, 0x32, 0x2e, 0x31, 0xa3,
0x86, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x85, 0x62, 0x61, 0x73, 0x69, 0x63, 0x86, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x85, 0x62, 0x61, 0x73, 0x69, 0x63,
0x89, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x80, 0x8b, 0x63, 0x89, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x80, 0x8b, 0x63,
0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x80}; 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x80};
constexpr uint8_t init_resp[] = {0x00, 0x18, 0xb1, 0x70, 0xa1, 0x8d, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, inline constexpr uint8_t init_resp[] = {0x00, 0x18, 0xb1, 0x70, 0xa1, 0x8d, 0x63, 0x6f, 0x6e, 0x6e,
0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x86, 0x62, 0x6f, 0x6c, 0x74, 0x2d, 0x31, 0x00, 0x00}; 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x86,
constexpr uint8_t run_req_header[] = {0xb2, 0x10, 0xd1}; 0x62, 0x6f, 0x6c, 0x74, 0x2d, 0x31, 0x00, 0x00};
constexpr uint8_t pullall_req[] = {0xb0, 0x3f}; inline constexpr uint8_t run_req_header[] = {0xb2, 0x10, 0xd1};
constexpr uint8_t discardall_req[] = {0xb0, 0x2f}; inline constexpr uint8_t pullall_req[] = {0xb0, 0x3f};
constexpr uint8_t reset_req[] = {0xb0, 0x0f}; inline constexpr uint8_t discardall_req[] = {0xb0, 0x2f};
constexpr uint8_t ackfailure_req[] = {0xb0, 0x0e}; inline constexpr uint8_t reset_req[] = {0xb0, 0x0f};
constexpr uint8_t success_resp[] = {0x00, 0x03, 0xb1, 0x70, 0xa0, 0x00, 0x00}; inline constexpr uint8_t ackfailure_req[] = {0xb0, 0x0e};
constexpr uint8_t ignored_resp[] = {0x00, 0x02, 0xb0, 0x7e, 0x00, 0x00}; inline constexpr uint8_t success_resp[] = {0x00, 0x03, 0xb1, 0x70, 0xa0, 0x00, 0x00};
inline constexpr uint8_t ignored_resp[] = {0x00, 0x02, 0xb0, 0x7e, 0x00, 0x00};
namespace v4 { namespace v4 {
constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, inline constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x00, 0x04}; inline constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x00, 0x04};
constexpr uint8_t init_req[] = { inline constexpr uint8_t init_req[] = {
0xb1, 0x01, 0xa5, 0x8a, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0xd0, 0x2f, 0x6e, 0x65, 0x6f, 0xb1, 0x01, 0xa5, 0x8a, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x61, 0x67, 0x65, 0x6e, 0x74, 0xd0, 0x2f, 0x6e, 0x65, 0x6f,
0x34, 0x6a, 0x2d, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2f, 0x34, 0x2e, 0x31, 0x2e, 0x31, 0x20, 0x50, 0x79, 0x74, 0x34, 0x6a, 0x2d, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x2f, 0x34, 0x2e, 0x31, 0x2e, 0x31, 0x20, 0x50, 0x79, 0x74,
0x68, 0x6f, 0x6e, 0x2f, 0x33, 0x2e, 0x37, 0x2e, 0x33, 0x2d, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x2d, 0x30, 0x20, 0x28, 0x68, 0x6f, 0x6e, 0x2f, 0x33, 0x2e, 0x37, 0x2e, 0x33, 0x2d, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x2d, 0x30, 0x20, 0x28,
@ -131,25 +132,26 @@ constexpr uint8_t init_req[] = {
0x69, 0x61, 0x6c, 0x73, 0x80, 0x87, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0xa1, 0x87, 0x61, 0x64, 0x64, 0x72, 0x69, 0x61, 0x6c, 0x73, 0x80, 0x87, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0xa1, 0x87, 0x61, 0x64, 0x64, 0x72,
0x65, 0x73, 0x73, 0x8e, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73, 0x74, 0x3a, 0x37, 0x36, 0x38, 0x37}; 0x65, 0x73, 0x73, 0x8e, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73, 0x74, 0x3a, 0x37, 0x36, 0x38, 0x37};
constexpr uint8_t init_resp[] = {0x00, 0x18, 0xb1, 0x70, 0xa1, 0x8d, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, inline constexpr uint8_t init_resp[] = {0x00, 0x18, 0xb1, 0x70, 0xa1, 0x8d, 0x63, 0x6f, 0x6e, 0x6e,
0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x86, 0x62, 0x6f, 0x6c, 0x74, 0x2d, 0x31, 0x00, 0x00}; 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x86,
constexpr uint8_t run_req_header[] = {0xb3, 0x10, 0xd1}; 0x62, 0x6f, 0x6c, 0x74, 0x2d, 0x31, 0x00, 0x00};
constexpr uint8_t pullall_req[] = {0xb1, 0x3f, 0xa0}; inline constexpr uint8_t run_req_header[] = {0xb3, 0x10, 0xd1};
constexpr uint8_t pull_one_req[] = {0xb1, 0x3f, 0xa1, 0x81, 0x6e, 0x01}; inline constexpr uint8_t pullall_req[] = {0xb1, 0x3f, 0xa0};
constexpr uint8_t reset_req[] = {0xb0, 0x0f}; inline constexpr uint8_t pull_one_req[] = {0xb1, 0x3f, 0xa1, 0x81, 0x6e, 0x01};
constexpr uint8_t goodbye[] = {0xb0, 0x02}; inline constexpr uint8_t reset_req[] = {0xb0, 0x0f};
constexpr uint8_t rollback[] = {0xb0, 0x13}; inline constexpr uint8_t goodbye[] = {0xb0, 0x02};
inline constexpr uint8_t rollback[] = {0xb0, 0x13};
} // namespace v4 } // namespace v4
namespace v4_1 { namespace v4_1 {
constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, inline constexpr uint8_t handshake_req[] = {0x60, 0x60, 0xb0, 0x17, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x01, 0x04}; inline constexpr uint8_t handshake_resp[] = {0x00, 0x00, 0x01, 0x04};
constexpr uint8_t noop[] = {0x00, 0x00}; inline constexpr uint8_t noop[] = {0x00, 0x00};
} // namespace v4_1 } // namespace v4_1
namespace v4_3 { namespace v4_3 {
constexpr uint8_t route[]{0xb0, 0x60}; inline constexpr uint8_t route[]{0xb0, 0x60};
} // namespace v4_3 } // namespace v4_3
// Write bolt chunk header (length) // Write bolt chunk header (length)

4
tests/unit/bolt_testdata.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -48,7 +48,7 @@ const uint8_t vertexedge_encoded[] =
const uint64_t sizes[] = {0, 1, 5, 15, 16, 120, 255, 256, 12345, 65535, 65536}; const uint64_t sizes[] = {0, 1, 5, 15, 16, 120, 255, 256, 12345, 65535, 65536};
const uint64_t sizes_num = 11; const uint64_t sizes_num = 11;
constexpr const int STRING = 0, LIST = 1, MAP = 2; inline constexpr const int STRING = 0, LIST = 1, MAP = 2;
const uint8_t type_tiny_magic[] = {0x80, 0x90, 0xA0}; const uint8_t type_tiny_magic[] = {0x80, 0x90, 0xA0};
const uint8_t type_8_magic[] = {0xD0, 0xD4, 0xD8}; const uint8_t type_8_magic[] = {0xD0, 0xD4, 0xD8};
const uint8_t type_16_magic[] = {0xD1, 0xD5, 0xD9}; const uint8_t type_16_magic[] = {0xD1, 0xD5, 0xD9};

2
tests/unit/commit_log_v2.cpp
View File

@ -14,7 +14,7 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace { namespace {
constexpr size_t ids_per_block = 8192 * 64; inline constexpr size_t ids_per_block = 8192 * 64;
} // namespace } // namespace
TEST(CommitLog, Simple) { TEST(CommitLog, Simple) {

2
tests/unit/communication_buffer.cpp
View File

@ -12,7 +12,7 @@
#include "bolt_common.hpp" #include "bolt_common.hpp"
#include "communication/buffer.hpp" #include "communication/buffer.hpp"
constexpr const int SIZE = 4096; inline constexpr const int SIZE = 4096;
uint8_t data[SIZE]; uint8_t data[SIZE];
using memgraph::communication::Buffer; using memgraph::communication::Buffer;

100
tests/unit/cypher_main_visitor.cpp
View File

@ -3019,8 +3019,8 @@ void CheckParsedCallProcedure(const CypherQuery &query, Base &ast_generator,
TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) { TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
auto &ast_generator = *GetParam(); auto &ast_generator = *GetParam();
constexpr std::string_view fst{"fst"}; static constexpr std::string_view fst{"fst"};
constexpr std::string_view snd{"snd"}; static constexpr std::string_view snd{"snd"};
const std::vector args{fst, snd}; const std::vector args{fst, snd};
const auto read_proc = CreateProcByType(ProcedureType::READ, args); const auto read_proc = CreateProcByType(ProcedureType::READ, args);
@ -3035,8 +3035,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
SCOPED_TRACE("Read query part"); SCOPED_TRACE("Read query part");
{ {
SCOPED_TRACE("With WITH"); SCOPED_TRACE("With WITH");
constexpr std::string_view kQueryWithWith{"CALL {}() YIELD {},{} WITH {},{} UNWIND {} as u RETURN u"}; static constexpr std::string_view kQueryWithWith{"CALL {}() YIELD {},{} WITH {},{} UNWIND {} as u RETURN u"};
constexpr size_t kQueryParts{4}; static constexpr size_t kQueryParts{4};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithWith, write_proc, fst, snd, fst, snd, fst); const auto query_str = fmt::format(kQueryWithWith, write_proc, fst, snd, fst, snd, fst);
@ -3054,8 +3054,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
} }
{ {
SCOPED_TRACE("Without WITH"); SCOPED_TRACE("Without WITH");
constexpr std::string_view kQueryWithoutWith{"CALL {}() YIELD {},{} UNWIND {} as u RETURN u"}; static constexpr std::string_view kQueryWithoutWith{"CALL {}() YIELD {},{} UNWIND {} as u RETURN u"};
constexpr size_t kQueryParts{3}; static constexpr size_t kQueryParts{3};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithoutWith, write_proc, fst, snd, fst); const auto query_str = fmt::format(kQueryWithoutWith, write_proc, fst, snd, fst);
@ -3076,8 +3076,9 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
SCOPED_TRACE("Write query part"); SCOPED_TRACE("Write query part");
{ {
SCOPED_TRACE("With WITH"); SCOPED_TRACE("With WITH");
constexpr std::string_view kQueryWithWith{"CALL {}() YIELD {},{} WITH {},{} CREATE(n {{prop : {}}}) RETURN n"}; static constexpr std::string_view kQueryWithWith{
constexpr size_t kQueryParts{4}; "CALL {}() YIELD {},{} WITH {},{} CREATE(n {{prop : {}}}) RETURN n"};
static constexpr size_t kQueryParts{4};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithWith, write_proc, fst, snd, fst, snd, fst); const auto query_str = fmt::format(kQueryWithWith, write_proc, fst, snd, fst, snd, fst);
@ -3095,8 +3096,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
} }
{ {
SCOPED_TRACE("Without WITH"); SCOPED_TRACE("Without WITH");
constexpr std::string_view kQueryWithoutWith{"CALL {}() YIELD {},{} CREATE(n {{prop : {}}}) RETURN n"}; static constexpr std::string_view kQueryWithoutWith{"CALL {}() YIELD {},{} CREATE(n {{prop : {}}}) RETURN n"};
constexpr size_t kQueryParts{3}; static constexpr size_t kQueryParts{3};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithoutWith, write_proc, fst, snd, fst); const auto query_str = fmt::format(kQueryWithoutWith, write_proc, fst, snd, fst);
@ -3117,8 +3118,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsAfter) {
TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsBefore) { TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsBefore) {
auto &ast_generator = *GetParam(); auto &ast_generator = *GetParam();
constexpr std::string_view fst{"fst"}; static constexpr std::string_view fst{"fst"};
constexpr std::string_view snd{"snd"}; static constexpr std::string_view snd{"snd"};
const std::vector args{fst, snd}; const std::vector args{fst, snd};
const auto read_proc = CreateProcByType(ProcedureType::READ, args); const auto read_proc = CreateProcByType(ProcedureType::READ, args);
@ -3131,8 +3132,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsBefore) {
}; };
{ {
SCOPED_TRACE("Read query part"); SCOPED_TRACE("Read query part");
constexpr std::string_view kQueryWithReadQueryPart{"MATCH (n) CALL {}() YIELD * RETURN *"}; static constexpr std::string_view kQueryWithReadQueryPart{"MATCH (n) CALL {}() YIELD * RETURN *"};
constexpr size_t kQueryParts{3}; static constexpr size_t kQueryParts{3};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithReadQueryPart, write_proc); const auto query_str = fmt::format(kQueryWithReadQueryPart, write_proc);
@ -3150,8 +3151,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsBefore) {
} }
{ {
SCOPED_TRACE("Write query part"); SCOPED_TRACE("Write query part");
constexpr std::string_view kQueryWithWriteQueryPart{"CREATE (n) WITH n CALL {}() YIELD * RETURN *"}; static constexpr std::string_view kQueryWithWriteQueryPart{"CREATE (n) WITH n CALL {}() YIELD * RETURN *"};
constexpr size_t kQueryParts{4}; static constexpr size_t kQueryParts{4};
{ {
SCOPED_TRACE("Write proc"); SCOPED_TRACE("Write proc");
const auto query_str = fmt::format(kQueryWithWriteQueryPart, write_proc, fst, snd, fst); const auto query_str = fmt::format(kQueryWithWriteQueryPart, write_proc, fst, snd, fst);
@ -3170,8 +3171,8 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleQueryPartsBefore) {
TEST_P(CypherMainVisitorTest, CallProcedureMultipleProcedures) { TEST_P(CypherMainVisitorTest, CallProcedureMultipleProcedures) {
auto &ast_generator = *GetParam(); auto &ast_generator = *GetParam();
constexpr std::string_view fst{"fst"}; static constexpr std::string_view fst{"fst"};
constexpr std::string_view snd{"snd"}; static constexpr std::string_view snd{"snd"};
const std::vector args{fst, snd}; const std::vector args{fst, snd};
const auto read_proc = CreateProcByType(ProcedureType::READ, args); const auto read_proc = CreateProcByType(ProcedureType::READ, args);
@ -3180,7 +3181,7 @@ TEST_P(CypherMainVisitorTest, CallProcedureMultipleProcedures) {
{ {
SCOPED_TRACE("Read then write"); SCOPED_TRACE("Read then write");
const auto query_str = fmt::format("CALL {}() YIELD * CALL {}() YIELD * RETURN *", read_proc, write_proc); const auto query_str = fmt::format("CALL {}() YIELD * CALL {}() YIELD * RETURN *", read_proc, write_proc);
constexpr size_t kQueryParts{3}; static constexpr size_t kQueryParts{3};
const auto *query = dynamic_cast<CypherQuery *>(ast_generator.ParseQuery(query_str)); const auto *query = dynamic_cast<CypherQuery *>(ast_generator.ParseQuery(query_str));
ASSERT_NE(query, nullptr); ASSERT_NE(query, nullptr);
@ -3501,22 +3502,22 @@ TEST_P(CypherMainVisitorTest, CreateTriggers) {
TestInvalidQuery("CREATE TRIGGER trigger ON UPDTE AFTER COMMIT EXECUTE a", ast_generator); TestInvalidQuery("CREATE TRIGGER trigger ON UPDTE AFTER COMMIT EXECUTE a", ast_generator);
TestInvalidQuery("CREATE TRIGGER trigger ON UPDATE COMMIT EXECUTE a", ast_generator); TestInvalidQuery("CREATE TRIGGER trigger ON UPDATE COMMIT EXECUTE a", ast_generator);
constexpr std::string_view query_template = "CREATE TRIGGER trigger {} {} COMMIT EXECUTE {}"; static constexpr std::string_view query_template = "CREATE TRIGGER trigger {} {} COMMIT EXECUTE {}";
constexpr std::array events{std::pair{"", memgraph::query::TriggerQuery::EventType::ANY}, static constexpr std::array events{std::pair{"", memgraph::query::TriggerQuery::EventType::ANY},
std::pair{"ON CREATE", memgraph::query::TriggerQuery::EventType::CREATE}, std::pair{"ON CREATE", memgraph::query::TriggerQuery::EventType::CREATE},
std::pair{"ON () CREATE", memgraph::query::TriggerQuery::EventType::VERTEX_CREATE}, std::pair{"ON () CREATE", memgraph::query::TriggerQuery::EventType::VERTEX_CREATE},
std::pair{"ON --> CREATE", memgraph::query::TriggerQuery::EventType::EDGE_CREATE}, std::pair{"ON --> CREATE", memgraph::query::TriggerQuery::EventType::EDGE_CREATE},
std::pair{"ON DELETE", memgraph::query::TriggerQuery::EventType::DELETE}, std::pair{"ON DELETE", memgraph::query::TriggerQuery::EventType::DELETE},
std::pair{"ON () DELETE", memgraph::query::TriggerQuery::EventType::VERTEX_DELETE}, std::pair{"ON () DELETE", memgraph::query::TriggerQuery::EventType::VERTEX_DELETE},
std::pair{"ON --> DELETE", memgraph::query::TriggerQuery::EventType::EDGE_DELETE}, std::pair{"ON --> DELETE", memgraph::query::TriggerQuery::EventType::EDGE_DELETE},
std::pair{"ON UPDATE", memgraph::query::TriggerQuery::EventType::UPDATE}, std::pair{"ON UPDATE", memgraph::query::TriggerQuery::EventType::UPDATE},
std::pair{"ON () UPDATE", memgraph::query::TriggerQuery::EventType::VERTEX_UPDATE}, std::pair{"ON () UPDATE", memgraph::query::TriggerQuery::EventType::VERTEX_UPDATE},
std::pair{"ON --> UPDATE", memgraph::query::TriggerQuery::EventType::EDGE_UPDATE}}; std::pair{"ON --> UPDATE", memgraph::query::TriggerQuery::EventType::EDGE_UPDATE}};
constexpr std::array phases{"BEFORE", "AFTER"}; static constexpr std::array phases{"BEFORE", "AFTER"};
constexpr std::array statements{ static constexpr std::array statements{
"", "SOME SUPER\nSTATEMENT", "Statement with 12312321 3 ", " Statement with 12312321 3 " "", "SOME SUPER\nSTATEMENT", "Statement with 12312321 3 ", " Statement with 12312321 3 "
}; };
@ -3553,15 +3554,16 @@ TEST_P(CypherMainVisitorTest, SetIsolationLevelQuery) {
TestInvalidQuery("SET GLOBAL TRANSACTION ISOLATION LEVEL READ_COMITTED", ast_generator); TestInvalidQuery("SET GLOBAL TRANSACTION ISOLATION LEVEL READ_COMITTED", ast_generator);
TestInvalidQuery("SET SESSION TRANSACTION ISOLATION LEVEL READCOMITTED", ast_generator); TestInvalidQuery("SET SESSION TRANSACTION ISOLATION LEVEL READCOMITTED", ast_generator);
constexpr std::array scopes{std::pair{"GLOBAL", memgraph::query::IsolationLevelQuery::IsolationLevelScope::GLOBAL}, static constexpr std::array scopes{
std::pair{"SESSION", memgraph::query::IsolationLevelQuery::IsolationLevelScope::SESSION}, std::pair{"GLOBAL", memgraph::query::IsolationLevelQuery::IsolationLevelScope::GLOBAL},
std::pair{"NEXT", memgraph::query::IsolationLevelQuery::IsolationLevelScope::NEXT}}; std::pair{"SESSION", memgraph::query::IsolationLevelQuery::IsolationLevelScope::SESSION},
constexpr std::array isolation_levels{ std::pair{"NEXT", memgraph::query::IsolationLevelQuery::IsolationLevelScope::NEXT}};
static constexpr std::array isolation_levels{
std::pair{"READ UNCOMMITTED", memgraph::query::IsolationLevelQuery::IsolationLevel::READ_UNCOMMITTED}, std::pair{"READ UNCOMMITTED", memgraph::query::IsolationLevelQuery::IsolationLevel::READ_UNCOMMITTED},
std::pair{"READ COMMITTED", memgraph::query::IsolationLevelQuery::IsolationLevel::READ_COMMITTED}, std::pair{"READ COMMITTED", memgraph::query::IsolationLevelQuery::IsolationLevel::READ_COMMITTED},
std::pair{"SNAPSHOT ISOLATION", memgraph::query::IsolationLevelQuery::IsolationLevel::SNAPSHOT_ISOLATION}}; std::pair{"SNAPSHOT ISOLATION", memgraph::query::IsolationLevelQuery::IsolationLevel::SNAPSHOT_ISOLATION}};
constexpr const auto *query_template = "SET {} TRANSACTION ISOLATION LEVEL {}"; static constexpr const auto *query_template = "SET {} TRANSACTION ISOLATION LEVEL {}";
for (const auto &[scope_string, scope] : scopes) { for (const auto &[scope_string, scope] : scopes) {
for (const auto &[isolation_level_string, isolation_level] : isolation_levels) { for (const auto &[isolation_level_string, isolation_level] : isolation_levels) {
@ -3765,14 +3767,14 @@ TEST_P(CypherMainVisitorTest, CreateKafkaStream) {
const std::vector<std::string> topic_names{"topic1_name.with_dot", "topic1_name.with_multiple.dots", const std::vector<std::string> topic_names{"topic1_name.with_dot", "topic1_name.with_multiple.dots",
"topic-name.with-multiple.dots-and-dashes"}; "topic-name.with-multiple.dots-and-dashes"};
constexpr std::string_view kStreamName{"SomeSuperStream"}; static constexpr std::string_view kStreamName{"SomeSuperStream"};
constexpr std::string_view kTransformName{"moreAwesomeTransform"}; static constexpr std::string_view kTransformName{"moreAwesomeTransform"};
auto check_topic_names = [&](const std::vector<std::string> &topic_names) { auto check_topic_names = [&](const std::vector<std::string> &topic_names) {
constexpr std::string_view kConsumerGroup{"ConsumerGru"}; static constexpr std::string_view kConsumerGroup{"ConsumerGru"};
constexpr int kBatchInterval = 324; static constexpr int kBatchInterval = 324;
const TypedValue batch_interval_value{kBatchInterval}; const TypedValue batch_interval_value{kBatchInterval};
constexpr int kBatchSize = 1; static constexpr int kBatchSize = 1;
const TypedValue batch_size_value{kBatchSize}; const TypedValue batch_size_value{kBatchSize};
const auto topic_names_as_str = memgraph::utils::Join(topic_names, ","); const auto topic_names_as_str = memgraph::utils::Join(topic_names, ",");
@ -3855,8 +3857,8 @@ TEST_P(CypherMainVisitorTest, CreateKafkaStream) {
}; };
using namespace std::literals; using namespace std::literals;
constexpr std::array consumer_groups{"consumergru"sv, "consumer-group-with-dash"sv, "consumer_group.with.dot"sv, static constexpr std::array consumer_groups{"consumergru"sv, "consumer-group-with-dash"sv,
"consumer-group.With-Dot-and.dash"sv}; "consumer_group.with.dot"sv, "consumer-group.With-Dot-and.dash"sv};
for (const auto consumer_group : consumer_groups) { for (const auto consumer_group : consumer_groups) {
EXPECT_NO_FATAL_FAILURE(check_consumer_group(consumer_group)); EXPECT_NO_FATAL_FAILURE(check_consumer_group(consumer_group));
@ -3958,11 +3960,11 @@ TEST_P(CypherMainVisitorTest, CreatePulsarStream) {
const std::vector<std::string> topic_names{"topic1", "topic2"}; const std::vector<std::string> topic_names{"topic1", "topic2"};
const std::string topic_names_str = memgraph::utils::Join(topic_names, ","); const std::string topic_names_str = memgraph::utils::Join(topic_names, ",");
constexpr std::string_view kStreamName{"PulsarStream"}; static constexpr std::string_view kStreamName{"PulsarStream"};
constexpr std::string_view kTransformName{"boringTransformation"}; static constexpr std::string_view kTransformName{"boringTransformation"};
constexpr std::string_view kServiceUrl{"localhost"}; static constexpr std::string_view kServiceUrl{"localhost"};
constexpr int kBatchSize{1000}; static constexpr int kBatchSize{1000};
constexpr int kBatchInterval{231321}; static constexpr int kBatchInterval{231321};
{ {
SCOPED_TRACE("single topic"); SCOPED_TRACE("single topic");

60
tests/unit/integrations_kafka_consumer.cpp
View File

@ -31,7 +31,7 @@ using namespace memgraph::integrations::kafka;
namespace { namespace {
const auto kDummyConsumerFunction = [](const auto & /*messages*/) {}; const auto kDummyConsumerFunction = [](const auto & /*messages*/) {};
constexpr std::optional<std::chrono::milliseconds> kDontCareTimeout = std::nullopt; inline constexpr std::optional<std::chrono::milliseconds> kDontCareTimeout = std::nullopt;
int SpanToInt(std::span<const char> span) { int SpanToInt(std::span<const char> span) {
int result{0}; int result{0};
@ -42,8 +42,8 @@ int SpanToInt(std::span<const char> span) {
return result; return result;
} }
constexpr std::chrono::milliseconds kDefaultBatchInterval{100}; inline constexpr std::chrono::milliseconds kDefaultBatchInterval{100};
constexpr int64_t kDefaultBatchSize{1000}; inline constexpr int64_t kDefaultBatchSize{1000};
} // namespace } // namespace
@ -125,8 +125,8 @@ const std::string ConsumerTest::kTopicName{"FirstTopic"};
TEST_F(ConsumerTest, BatchInterval) { TEST_F(ConsumerTest, BatchInterval) {
// There might be ~300ms delay in message delivery with librdkafka mock, thus the batch interval cannot be too small. // There might be ~300ms delay in message delivery with librdkafka mock, thus the batch interval cannot be too small.
constexpr auto kBatchInterval = std::chrono::milliseconds{500}; static constexpr auto kBatchInterval = std::chrono::milliseconds{500};
constexpr std::string_view kMessage = "BatchIntervalTestMessage"; static constexpr std::string_view kMessage = "BatchIntervalTestMessage";
auto info = CreateDefaultConsumerInfo(); auto info = CreateDefaultConsumerInfo();
std::vector<std::pair<size_t, std::chrono::steady_clock::time_point>> received_timestamps{}; std::vector<std::pair<size_t, std::chrono::steady_clock::time_point>> received_timestamps{};
info.batch_interval = kBatchInterval; info.batch_interval = kBatchInterval;
@ -142,7 +142,7 @@ TEST_F(ConsumerTest, BatchInterval) {
consumer->Start(); consumer->Start();
ASSERT_TRUE(consumer->IsRunning()); ASSERT_TRUE(consumer->IsRunning());
constexpr auto kMessageCount = 7; static constexpr auto kMessageCount = 7;
for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) { for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) {
cluster.SeedTopic(kTopicName, kMessage); cluster.SeedTopic(kTopicName, kMessage);
std::this_thread::sleep_for(kBatchInterval * 0.5); std::this_thread::sleep_for(kBatchInterval * 0.5);
@ -151,7 +151,7 @@ TEST_F(ConsumerTest, BatchInterval) {
consumer->Stop(); consumer->Stop();
EXPECT_TRUE(expected_messages_received) << "Some unexpected message have been received"; EXPECT_TRUE(expected_messages_received) << "Some unexpected message have been received";
auto check_received_timestamp = [&received_timestamps, kBatchInterval](size_t index) { auto check_received_timestamp = [&received_timestamps](size_t index) {
SCOPED_TRACE("Checking index " + std::to_string(index)); SCOPED_TRACE("Checking index " + std::to_string(index));
EXPECT_GE(index, 0) << "Cannot check first timestamp!"; EXPECT_GE(index, 0) << "Cannot check first timestamp!";
const auto message_count = received_timestamps[index].first; const auto message_count = received_timestamps[index].first;
@ -159,8 +159,8 @@ TEST_F(ConsumerTest, BatchInterval) {
auto actual_diff = std::chrono::duration_cast<std::chrono::milliseconds>(received_timestamps[index].second - auto actual_diff = std::chrono::duration_cast<std::chrono::milliseconds>(received_timestamps[index].second -
received_timestamps[index - 1].second); received_timestamps[index - 1].second);
constexpr auto kMinDiff = kBatchInterval * 0.9; static constexpr auto kMinDiff = kBatchInterval * 0.9;
constexpr auto kMaxDiff = kBatchInterval * 1.1; static constexpr auto kMaxDiff = kBatchInterval * 1.1;
EXPECT_LE(kMinDiff.count(), actual_diff.count()); EXPECT_LE(kMinDiff.count(), actual_diff.count());
EXPECT_GE(kMaxDiff.count(), actual_diff.count()); EXPECT_GE(kMaxDiff.count(), actual_diff.count());
}; };
@ -213,10 +213,10 @@ TEST_F(ConsumerTest, StartStop) {
EXPECT_FALSE(consumer.IsRunning()); EXPECT_FALSE(consumer.IsRunning());
}; };
constexpr auto kSimpleStart = false; static constexpr auto kSimpleStart = false;
constexpr auto kSimpleStop = false; static constexpr auto kSimpleStop = false;
constexpr auto kConditionalStart = true; static constexpr auto kConditionalStart = true;
constexpr auto kConditionalStop = true; static constexpr auto kConditionalStop = true;
check_config(kSimpleStart, kSimpleStop); check_config(kSimpleStart, kSimpleStop);
check_config(kSimpleStart, kConditionalStop); check_config(kSimpleStart, kConditionalStop);
@ -226,13 +226,13 @@ TEST_F(ConsumerTest, StartStop) {
TEST_F(ConsumerTest, BatchSize) { TEST_F(ConsumerTest, BatchSize) {
// Increase default batch interval to give more time for messages to receive // Increase default batch interval to give more time for messages to receive
constexpr auto kBatchInterval = std::chrono::milliseconds{1000}; static constexpr auto kBatchInterval = std::chrono::milliseconds{1000};
constexpr auto kBatchSize = 3; static constexpr auto kBatchSize = 3;
auto info = CreateDefaultConsumerInfo(); auto info = CreateDefaultConsumerInfo();
std::vector<std::pair<size_t, std::chrono::steady_clock::time_point>> received_timestamps{}; std::vector<std::pair<size_t, std::chrono::steady_clock::time_point>> received_timestamps{};
info.batch_interval = kBatchInterval; info.batch_interval = kBatchInterval;
info.batch_size = kBatchSize; info.batch_size = kBatchSize;
constexpr std::string_view kMessage = "BatchSizeTestMessage"; static constexpr std::string_view kMessage = "BatchSizeTestMessage";
auto expected_messages_received = true; auto expected_messages_received = true;
auto consumer_function = [&](const std::vector<Message> &messages) mutable { auto consumer_function = [&](const std::vector<Message> &messages) mutable {
received_timestamps.push_back({messages.size(), std::chrono::steady_clock::now()}); received_timestamps.push_back({messages.size(), std::chrono::steady_clock::now()});
@ -245,8 +245,8 @@ TEST_F(ConsumerTest, BatchSize) {
consumer->Start(); consumer->Start();
ASSERT_TRUE(consumer->IsRunning()); ASSERT_TRUE(consumer->IsRunning());
constexpr auto kLastBatchMessageCount = 1; static constexpr auto kLastBatchMessageCount = 1;
constexpr auto kMessageCount = 3 * kBatchSize + kLastBatchMessageCount; static constexpr auto kMessageCount = 3 * kBatchSize + kLastBatchMessageCount;
for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) { for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) {
cluster.SeedTopic(kTopicName, kMessage); cluster.SeedTopic(kTopicName, kMessage);
} }
@ -254,7 +254,7 @@ TEST_F(ConsumerTest, BatchSize) {
consumer->Stop(); consumer->Stop();
EXPECT_TRUE(expected_messages_received) << "Some unexpected message have been received"; EXPECT_TRUE(expected_messages_received) << "Some unexpected message have been received";
auto check_received_timestamp = [&received_timestamps, kBatchInterval](size_t index, size_t expected_message_count) { auto check_received_timestamp = [&received_timestamps](size_t index, size_t expected_message_count) {
SCOPED_TRACE("Checking index " + std::to_string(index)); SCOPED_TRACE("Checking index " + std::to_string(index));
EXPECT_GE(index, 0) << "Cannot check first timestamp!"; EXPECT_GE(index, 0) << "Cannot check first timestamp!";
const auto message_count = received_timestamps[index].first; const auto message_count = received_timestamps[index].first;
@ -265,8 +265,8 @@ TEST_F(ConsumerTest, BatchSize) {
if (expected_message_count == kBatchSize) { if (expected_message_count == kBatchSize) {
EXPECT_LE(actual_diff, kBatchInterval * 0.5); EXPECT_LE(actual_diff, kBatchInterval * 0.5);
} else { } else {
constexpr auto kMinDiff = kBatchInterval * 0.9; static constexpr auto kMinDiff = kBatchInterval * 0.9;
constexpr auto kMaxDiff = kBatchInterval * 1.1; static constexpr auto kMaxDiff = kBatchInterval * 1.1;
EXPECT_LE(kMinDiff.count(), actual_diff.count()); EXPECT_LE(kMinDiff.count(), actual_diff.count());
EXPECT_GE(kMaxDiff.count(), actual_diff.count()); EXPECT_GE(kMaxDiff.count(), actual_diff.count());
} }
@ -276,7 +276,7 @@ TEST_F(ConsumerTest, BatchSize) {
EXPECT_EQ(kBatchSize, received_timestamps[0].first); EXPECT_EQ(kBatchSize, received_timestamps[0].first);
constexpr auto kExpectedBatchCount = kMessageCount / kBatchSize + 1; static constexpr auto kExpectedBatchCount = kMessageCount / kBatchSize + 1;
EXPECT_EQ(kExpectedBatchCount, received_timestamps.size()); EXPECT_EQ(kExpectedBatchCount, received_timestamps.size());
for (auto i = 1; i < received_timestamps.size() - 1; ++i) { for (auto i = 1; i < received_timestamps.size() - 1; ++i) {
check_received_timestamp(i, kBatchSize); check_received_timestamp(i, kBatchSize);
@ -324,7 +324,7 @@ TEST_F(ConsumerTest, InvalidBatchSize) {
} }
TEST_F(ConsumerTest, DISABLED_StartsFromPreviousOffset) { TEST_F(ConsumerTest, DISABLED_StartsFromPreviousOffset) {
constexpr auto kBatchSize = 1; static constexpr auto kBatchSize = 1;
auto info = CreateDefaultConsumerInfo(); auto info = CreateDefaultConsumerInfo();
info.batch_size = kBatchSize; info.batch_size = kBatchSize;
std::atomic<int> received_message_count{0}; std::atomic<int> received_message_count{0};
@ -361,7 +361,7 @@ TEST_F(ConsumerTest, DISABLED_StartsFromPreviousOffset) {
const auto start = std::chrono::steady_clock::now(); const auto start = std::chrono::steady_clock::now();
ASSERT_TRUE(consumer->IsRunning()); ASSERT_TRUE(consumer->IsRunning());
constexpr auto kMaxWaitTime = std::chrono::seconds(5); static constexpr auto kMaxWaitTime = std::chrono::seconds(5);
while (expected_total_messages != received_message_count.load() && while (expected_total_messages != received_message_count.load() &&
(std::chrono::steady_clock::now() - start) < kMaxWaitTime) { (std::chrono::steady_clock::now() - start) < kMaxWaitTime) {
@ -379,7 +379,7 @@ TEST_F(ConsumerTest, DISABLED_StartsFromPreviousOffset) {
} }
TEST_F(ConsumerTest, CheckMethodWorks) { TEST_F(ConsumerTest, CheckMethodWorks) {
constexpr auto kBatchSize = 1; static constexpr auto kBatchSize = 1;
auto info = CreateDefaultConsumerInfo(); auto info = CreateDefaultConsumerInfo();
info.batch_size = kBatchSize; info.batch_size = kBatchSize;
const std::string kMessagePrefix{"Message"}; const std::string kMessagePrefix{"Message"};
@ -388,7 +388,7 @@ TEST_F(ConsumerTest, CheckMethodWorks) {
// This test depends on CreateConsumer starts and stops the consumer, so the offset is stored // This test depends on CreateConsumer starts and stops the consumer, so the offset is stored
auto consumer = CreateConsumer(std::move(info), std::move(consumer_function)); auto consumer = CreateConsumer(std::move(info), std::move(consumer_function));
constexpr auto kMessageCount = 4; static constexpr auto kMessageCount = 4;
for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) { for (auto sent_messages = 0; sent_messages < kMessageCount; ++sent_messages) {
cluster.SeedTopic(kTopicName, std::string_view{kMessagePrefix + std::to_string(sent_messages)}); cluster.SeedTopic(kTopicName, std::string_view{kMessagePrefix + std::to_string(sent_messages)});
} }
@ -449,7 +449,7 @@ TEST_F(ConsumerTest, CheckWithInvalidTimeout) {
ConsumerCheckFailedException); ConsumerCheckFailedException);
const auto end = std::chrono::steady_clock::now(); const auto end = std::chrono::steady_clock::now();
constexpr std::chrono::seconds kMaxExpectedTimeout{2}; static constexpr std::chrono::seconds kMaxExpectedTimeout{2};
EXPECT_LE((end - start), kMaxExpectedTimeout) << "The check most probably failed because of an actual timeout and " EXPECT_LE((end - start), kMaxExpectedTimeout) << "The check most probably failed because of an actual timeout and "
"not because of the invalid value for timeout."; "not because of the invalid value for timeout.";
} }
@ -462,7 +462,7 @@ TEST_F(ConsumerTest, CheckWithInvalidBatchSize) {
EXPECT_THROW(consumer.Check(std::nullopt, -1, kDummyConsumerFunction), ConsumerCheckFailedException); EXPECT_THROW(consumer.Check(std::nullopt, -1, kDummyConsumerFunction), ConsumerCheckFailedException);
const auto end = std::chrono::steady_clock::now(); const auto end = std::chrono::steady_clock::now();
constexpr std::chrono::seconds kMaxExpectedTimeout{2}; static constexpr std::chrono::seconds kMaxExpectedTimeout{2};
EXPECT_LE((end - start), kMaxExpectedTimeout) << "The check most probably failed because of an actual timeout and " EXPECT_LE((end - start), kMaxExpectedTimeout) << "The check most probably failed because of an actual timeout and "
"not because of the invalid value for batch size."; "not because of the invalid value for batch size.";
} }
@ -471,8 +471,8 @@ TEST_F(ConsumerTest, ConsumerStatus) {
const std::string kConsumerName = "ConsumerGroupNameAAAA"; const std::string kConsumerName = "ConsumerGroupNameAAAA";
const std::vector<std::string> topics = {"Topic1QWER", "Topic2XCVBB"}; const std::vector<std::string> topics = {"Topic1QWER", "Topic2XCVBB"};
const std::string kConsumerGroupName = "ConsumerGroupTestAsdf"; const std::string kConsumerGroupName = "ConsumerGroupTestAsdf";
constexpr auto kBatchInterval = std::chrono::milliseconds{111}; static constexpr auto kBatchInterval = std::chrono::milliseconds{111};
constexpr auto kBatchSize = 222; static constexpr auto kBatchSize = 222;
for (const auto &topic : topics) { for (const auto &topic : topics) {
cluster.CreateTopic(topic); cluster.CreateTopic(topic);

4
tests/unit/interpreter.cpp
View File

@ -468,8 +468,8 @@ TEST_F(InterpreterTest, ShortestPath) {
Interpret("MATCH (n) DETACH DELETE n"); Interpret("MATCH (n) DETACH DELETE n");
}; };
constexpr bool kUseNumeric{false}; static constexpr bool kUseNumeric{false};
constexpr bool kUseDuration{true}; static constexpr bool kUseDuration{true};
{ {
SCOPED_TRACE("Test with numeric values"); SCOPED_TRACE("Test with numeric values");
test_shortest_path(kUseNumeric); test_shortest_path(kUseNumeric);

8
tests/unit/kafka_mock.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 Memgraph Ltd. // Copyright 2022 Memgraph Ltd.
// //
// Use of this software is governed by the Business Source License // Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@ -55,7 +55,7 @@ KafkaClusterMock::KafkaClusterMock(const std::vector<std::string> &topics) {
if (rk_ == nullptr) { if (rk_ == nullptr) {
throw std::runtime_error(std::string("Failed to create mock cluster rd_kafka_t: ") + errstr); throw std::runtime_error(std::string("Failed to create mock cluster rd_kafka_t: ") + errstr);
} }
constexpr auto broker_count = 1; static constexpr auto broker_count = 1;
cluster_.reset(rd_kafka_mock_cluster_new(rk_.get(), broker_count)); cluster_.reset(rd_kafka_mock_cluster_new(rk_.get(), broker_count));
if (cluster_ == nullptr) { if (cluster_ == nullptr) {
throw std::runtime_error("Couldn't create cluster for Kafka mock"); throw std::runtime_error("Couldn't create cluster for Kafka mock");
@ -69,8 +69,8 @@ KafkaClusterMock::KafkaClusterMock(const std::vector<std::string> &topics) {
std::string KafkaClusterMock::Bootstraps() const { return rd_kafka_mock_cluster_bootstraps(cluster_.get()); }; std::string KafkaClusterMock::Bootstraps() const { return rd_kafka_mock_cluster_bootstraps(cluster_.get()); };
void KafkaClusterMock::CreateTopic(const std::string &topic_name) { void KafkaClusterMock::CreateTopic(const std::string &topic_name) {
constexpr auto partition_count = 1; static constexpr auto partition_count = 1;
constexpr auto replication_factor = 1; static constexpr auto replication_factor = 1;
rd_kafka_resp_err_t topic_err = rd_kafka_resp_err_t topic_err =
rd_kafka_mock_topic_create(cluster_.get(), topic_name.c_str(), partition_count, replication_factor); rd_kafka_mock_topic_create(cluster_.get(), topic_name.c_str(), partition_count, replication_factor);
if (RD_KAFKA_RESP_ERR_NO_ERROR != topic_err) { if (RD_KAFKA_RESP_ERR_NO_ERROR != topic_err) {

2
tests/unit/mgp_trans_c_api.cpp
View File

@ -16,7 +16,7 @@
#include "test_utils.hpp" #include "test_utils.hpp"
TEST(MgpTransTest, TestMgpTransApi) { TEST(MgpTransTest, TestMgpTransApi) {
constexpr auto no_op_cb = [](mgp_messages *msg, mgp_graph *graph, mgp_result *result, mgp_memory *memory) {}; static constexpr auto no_op_cb = [](mgp_messages *msg, mgp_graph *graph, mgp_result *result, mgp_memory *memory) {};
mgp_module module(memgraph::utils::NewDeleteResource()); mgp_module module(memgraph::utils::NewDeleteResource());
// If this is false, then mgp_module_add_transformation() // If this is false, then mgp_module_add_transformation()
// correctly calls IsValidIdentifier(). We don't need to test // correctly calls IsValidIdentifier(). We don't need to test

4
tests/unit/query_procedure_mgp_type.cpp
View File

@ -334,7 +334,7 @@ TEST(CypherType, EmptyListSatisfiesType) {
TEST(CypherType, ListOfIntSatisfiesType) { TEST(CypherType, ListOfIntSatisfiesType) {
mgp_memory memory{memgraph::utils::NewDeleteResource()}; mgp_memory memory{memgraph::utils::NewDeleteResource()};
constexpr int64_t elem_count = 3; static constexpr int64_t elem_count = 3;
auto *list = EXPECT_MGP_NO_ERROR(mgp_list *, mgp_list_make_empty, elem_count, &memory); auto *list = EXPECT_MGP_NO_ERROR(mgp_list *, mgp_list_make_empty, elem_count, &memory);
auto *mgp_list_v = EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_list, list); auto *mgp_list_v = EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_list, list);
memgraph::query::TypedValue tv_list(std::vector<memgraph::query::TypedValue>{}); memgraph::query::TypedValue tv_list(std::vector<memgraph::query::TypedValue>{});
@ -362,7 +362,7 @@ TEST(CypherType, ListOfIntSatisfiesType) {
TEST(CypherType, ListOfIntAndBoolSatisfiesType) { TEST(CypherType, ListOfIntAndBoolSatisfiesType) {
mgp_memory memory{memgraph::utils::NewDeleteResource()}; mgp_memory memory{memgraph::utils::NewDeleteResource()};
constexpr int64_t elem_count = 2; static constexpr int64_t elem_count = 2;
auto *list = EXPECT_MGP_NO_ERROR(mgp_list *, mgp_list_make_empty, elem_count, &memory); auto *list = EXPECT_MGP_NO_ERROR(mgp_list *, mgp_list_make_empty, elem_count, &memory);
auto *mgp_list_v = EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_list, list); auto *mgp_list_v = EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_list, list);
memgraph::query::TypedValue tv_list(std::vector<memgraph::query::TypedValue>{}); memgraph::query::TypedValue tv_list(std::vector<memgraph::query::TypedValue>{});

22
tests/unit/query_procedures_mgp_graph.cpp
View File

@ -261,8 +261,8 @@ TEST_F(MgpGraphTest, VertexIsMutable) {
} }
TEST_F(MgpGraphTest, VertexSetProperty) { TEST_F(MgpGraphTest, VertexSetProperty) {
constexpr std::string_view property_to_update{"to_update"}; static constexpr std::string_view property_to_update{"to_update"};
constexpr std::string_view property_to_set{"to_set"}; static constexpr std::string_view property_to_set{"to_set"};
memgraph::storage::Gid vertex_id{}; memgraph::storage::Gid vertex_id{};
{ {
auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION);
@ -287,7 +287,7 @@ TEST_F(MgpGraphTest, VertexSetProperty) {
{ {
SCOPED_TRACE("Update the property"); SCOPED_TRACE("Update the property");
constexpr int64_t numerical_value_to_update_to{69}; static constexpr int64_t numerical_value_to_update_to{69};
MgpValuePtr value_to_update_to{ MgpValuePtr value_to_update_to{
EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_int, numerical_value_to_update_to, &memory)}; EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_int, numerical_value_to_update_to, &memory)};
ASSERT_NE(value_to_update_to, nullptr); ASSERT_NE(value_to_update_to, nullptr);
@ -309,7 +309,7 @@ TEST_F(MgpGraphTest, VertexSetProperty) {
} }
{ {
SCOPED_TRACE("Add a property"); SCOPED_TRACE("Add a property");
constexpr double numerical_value_to_set{3.5}; static constexpr double numerical_value_to_set{3.5};
MgpValuePtr value_to_set{EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_double, numerical_value_to_set, &memory)}; MgpValuePtr value_to_set{EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_double, numerical_value_to_set, &memory)};
ASSERT_NE(value_to_set, nullptr); ASSERT_NE(value_to_set, nullptr);
EXPECT_SUCCESS(mgp_vertex_set_property(vertex.get(), property_to_set.data(), value_to_set.get())); EXPECT_SUCCESS(mgp_vertex_set_property(vertex.get(), property_to_set.data(), value_to_set.get()));
@ -321,7 +321,7 @@ TEST_F(MgpGraphTest, VertexSetProperty) {
} }
TEST_F(MgpGraphTest, VertexAddLabel) { TEST_F(MgpGraphTest, VertexAddLabel) {
constexpr std::string_view label = "test_label"; static constexpr std::string_view label = "test_label";
memgraph::storage::Gid vertex_id{}; memgraph::storage::Gid vertex_id{};
{ {
auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION);
@ -351,7 +351,7 @@ TEST_F(MgpGraphTest, VertexAddLabel) {
} }
TEST_F(MgpGraphTest, VertexRemoveLabel) { TEST_F(MgpGraphTest, VertexRemoveLabel) {
constexpr std::string_view label = "test_label"; static constexpr std::string_view label = "test_label";
memgraph::storage::Gid vertex_id{}; memgraph::storage::Gid vertex_id{};
{ {
auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION);
@ -384,7 +384,7 @@ TEST_F(MgpGraphTest, VertexRemoveLabel) {
} }
TEST_F(MgpGraphTest, ModifyImmutableVertex) { TEST_F(MgpGraphTest, ModifyImmutableVertex) {
constexpr std::string_view label_to_remove{"label_to_remove"}; static constexpr std::string_view label_to_remove{"label_to_remove"};
memgraph::storage::Gid vertex_id{}; memgraph::storage::Gid vertex_id{};
{ {
auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); auto accessor = CreateDbAccessor(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION);
@ -543,8 +543,8 @@ TEST_F(MgpGraphTest, EdgesIterator) {
} }
TEST_F(MgpGraphTest, EdgeSetProperty) { TEST_F(MgpGraphTest, EdgeSetProperty) {
constexpr std::string_view property_to_update{"to_update"}; static constexpr std::string_view property_to_update{"to_update"};
constexpr std::string_view property_to_set{"to_set"}; static constexpr std::string_view property_to_set{"to_set"};
memgraph::storage::Gid from_vertex_id{}; memgraph::storage::Gid from_vertex_id{};
auto get_edge = [&from_vertex_id](memgraph::storage::Storage::Accessor &accessor) -> memgraph::storage::EdgeAccessor { auto get_edge = [&from_vertex_id](memgraph::storage::Storage::Accessor &accessor) -> memgraph::storage::EdgeAccessor {
@ -572,7 +572,7 @@ TEST_F(MgpGraphTest, EdgeSetProperty) {
{ {
SCOPED_TRACE("Update the property"); SCOPED_TRACE("Update the property");
constexpr int64_t numerical_value_to_update_to{69}; static constexpr int64_t numerical_value_to_update_to{69};
MgpValuePtr value_to_update_to{ MgpValuePtr value_to_update_to{
EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_int, numerical_value_to_update_to, &memory)}; EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_int, numerical_value_to_update_to, &memory)};
ASSERT_NE(value_to_update_to, nullptr); ASSERT_NE(value_to_update_to, nullptr);
@ -594,7 +594,7 @@ TEST_F(MgpGraphTest, EdgeSetProperty) {
} }
{ {
SCOPED_TRACE("Add a property"); SCOPED_TRACE("Add a property");
constexpr double numerical_value_to_set{3.5}; static constexpr double numerical_value_to_set{3.5};
MgpValuePtr value_to_set{EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_double, numerical_value_to_set, &memory)}; MgpValuePtr value_to_set{EXPECT_MGP_NO_ERROR(mgp_value *, mgp_value_make_double, numerical_value_to_set, &memory)};
ASSERT_NE(value_to_set, nullptr); ASSERT_NE(value_to_set, nullptr);
EXPECT_SUCCESS(mgp_edge_set_property(edge.get(), property_to_set.data(), value_to_set.get())); EXPECT_SUCCESS(mgp_edge_set_property(edge.get(), property_to_set.data(), value_to_set.get()));

8
tests/unit/query_streams.cpp
View File

@ -286,8 +286,8 @@ TEST_F(StreamsTest, CheckWithTimeout) {
TEST_F(StreamsTest, CheckInvalidConfig) { TEST_F(StreamsTest, CheckInvalidConfig) {
auto stream_info = CreateDefaultStreamInfo(); auto stream_info = CreateDefaultStreamInfo();
const auto stream_name = GetDefaultStreamName(); const auto stream_name = GetDefaultStreamName();
constexpr auto kInvalidConfigName = "doesnt.exist"; static constexpr auto kInvalidConfigName = "doesnt.exist";
constexpr auto kConfigValue = "myprecious"; static constexpr auto kConfigValue = "myprecious";
stream_info.configs.emplace(kInvalidConfigName, kConfigValue); stream_info.configs.emplace(kInvalidConfigName, kConfigValue);
const auto checker = [](const std::string_view message) { const auto checker = [](const std::string_view message) {
EXPECT_TRUE(message.find(kInvalidConfigName) != std::string::npos) << message; EXPECT_TRUE(message.find(kInvalidConfigName) != std::string::npos) << message;
@ -300,8 +300,8 @@ TEST_F(StreamsTest, CheckInvalidConfig) {
TEST_F(StreamsTest, CheckInvalidCredentials) { TEST_F(StreamsTest, CheckInvalidCredentials) {
auto stream_info = CreateDefaultStreamInfo(); auto stream_info = CreateDefaultStreamInfo();
const auto stream_name = GetDefaultStreamName(); const auto stream_name = GetDefaultStreamName();
constexpr auto kInvalidCredentialName = "doesnt.exist"; static constexpr auto kInvalidCredentialName = "doesnt.exist";
constexpr auto kCredentialValue = "myprecious"; static constexpr auto kCredentialValue = "myprecious";
stream_info.credentials.emplace(kInvalidCredentialName, kCredentialValue); stream_info.credentials.emplace(kInvalidCredentialName, kCredentialValue);
const auto checker = [](const std::string_view message) { const auto checker = [](const std::string_view message) {
EXPECT_TRUE(message.find(kInvalidCredentialName) != std::string::npos) << message; EXPECT_TRUE(message.find(kInvalidCredentialName) != std::string::npos) << message;

10
tests/unit/storage_v2_isolation_level.cpp
View File

@ -24,9 +24,9 @@ int64_t VerticesCount(memgraph::storage::Storage::Accessor &accessor) {
return count; return count;
} }
constexpr std::array isolation_levels{memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION, inline constexpr std::array isolation_levels{memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION,
memgraph::storage::IsolationLevel::READ_COMMITTED, memgraph::storage::IsolationLevel::READ_COMMITTED,
memgraph::storage::IsolationLevel::READ_UNCOMMITTED}; memgraph::storage::IsolationLevel::READ_UNCOMMITTED};
std::string_view IsolationLevelToString(const memgraph::storage::IsolationLevel isolation_level) { std::string_view IsolationLevelToString(const memgraph::storage::IsolationLevel isolation_level) {
switch (isolation_level) { switch (isolation_level) {
@ -62,7 +62,7 @@ TEST_P(StorageIsolationLevelTest, Visibility) {
ASSERT_EQ(VerticesCount(default_isolation_level_reader), 0); ASSERT_EQ(VerticesCount(default_isolation_level_reader), 0);
ASSERT_EQ(VerticesCount(override_isolation_level_reader), 0); ASSERT_EQ(VerticesCount(override_isolation_level_reader), 0);
constexpr auto iteration_count = 10; static constexpr auto iteration_count = 10;
{ {
SCOPED_TRACE(fmt::format( SCOPED_TRACE(fmt::format(
"Visibility while the creator transaction is active " "Visibility while the creator transaction is active "
@ -86,7 +86,7 @@ TEST_P(StorageIsolationLevelTest, Visibility) {
"Visibility after the creator transaction is committed " "Visibility after the creator transaction is committed "
"(default isolation level = {}, override isolation level = {})", "(default isolation level = {}, override isolation level = {})",
IsolationLevelToString(default_isolation_level), IsolationLevelToString(override_isolation_level))); IsolationLevelToString(default_isolation_level), IsolationLevelToString(override_isolation_level)));
const auto check_vertices_count = [iteration_count](auto &accessor, const auto isolation_level) { const auto check_vertices_count = [](auto &accessor, const auto isolation_level) {
const auto expected_count = const auto expected_count =
isolation_level == memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION ? 0 : iteration_count; isolation_level == memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION ? 0 : iteration_count;
ASSERT_EQ(VerticesCount(accessor), expected_count); ASSERT_EQ(VerticesCount(accessor), expected_count);

8
tests/unit/storage_v2_replication.cpp
View File

@ -391,8 +391,8 @@ TEST_F(ReplicationTest, RecoveryProcess) {
.snapshot_wal_mode = memgraph::storage::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT_WITH_WAL, .snapshot_wal_mode = memgraph::storage::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT_WITH_WAL,
}}); }});
constexpr const auto *property_name = "property_name"; static constexpr const auto *property_name = "property_name";
constexpr const auto property_value = 1; static constexpr const auto property_value = 1;
{ {
// Force the creation of current WAL file // Force the creation of current WAL file
auto acc = main_store.Access(); auto acc = main_store.Access();
@ -411,7 +411,7 @@ TEST_F(ReplicationTest, RecoveryProcess) {
memgraph::utils::OnScopeExit replica_directory_cleaner( memgraph::utils::OnScopeExit replica_directory_cleaner(
[&]() { std::filesystem::remove_all(replica_storage_directory); }); [&]() { std::filesystem::remove_all(replica_storage_directory); });
constexpr const auto *vertex_label = "vertex_label"; static constexpr const auto *vertex_label = "vertex_label";
{ {
memgraph::storage::Storage replica_store( memgraph::storage::Storage replica_store(
{.durability = { {.durability = {
@ -504,7 +504,7 @@ TEST_F(ReplicationTest, BasicAsynchronousReplicationTest) {
memgraph::storage::replication::ReplicationMode::ASYNC) memgraph::storage::replication::ReplicationMode::ASYNC)
.HasError()); .HasError());
constexpr size_t vertices_create_num = 10; static constexpr size_t vertices_create_num = 10;
std::vector<memgraph::storage::Gid> created_vertices; std::vector<memgraph::storage::Gid> created_vertices;
for (size_t i = 0; i < vertices_create_num; ++i) { for (size_t i = 0; i < vertices_create_num; ++i) {
auto acc = main_store.Access(); auto acc = main_store.Access();

2
tests/unit/stripped.cpp
View File

@ -368,7 +368,7 @@ TEST(QueryStripper, QuerySemicolonEndingQuery2) {
} }
TEST(QueryStripper, CreateTriggerQuery) { TEST(QueryStripper, CreateTriggerQuery) {
constexpr std::string_view execute_query{ static constexpr std::string_view execute_query{
" MATCH (execute:Node) RETURN / *test comment */ execute \"test\""}; " MATCH (execute:Node) RETURN / *test comment */ execute \"test\""};
{ {
SCOPED_TRACE("Everything after EXECUTE keyword in CREATE TRIGGER should not be stripped"); SCOPED_TRACE("Everything after EXECUTE keyword in CREATE TRIGGER should not be stripped");

8
tests/unit/utils_async_timer.cpp
View File

@ -19,10 +19,10 @@
using AsyncTimer = memgraph::utils::AsyncTimer; using AsyncTimer = memgraph::utils::AsyncTimer;
constexpr auto kSecondsInMilis = 1000.0; inline constexpr auto kSecondsInMilis = 1000.0;
constexpr auto kIntervalInSeconds = 0.3; inline constexpr auto kIntervalInSeconds = 0.3;
constexpr auto kIntervalInMilis = kIntervalInSeconds * kSecondsInMilis; inline constexpr auto kIntervalInMilis = kIntervalInSeconds * kSecondsInMilis;
constexpr auto kAbsoluteErrorInMilis = 50; inline constexpr auto kAbsoluteErrorInMilis = 50;
std::chrono::steady_clock::time_point Now() { return std::chrono::steady_clock::now(); } std::chrono::steady_clock::time_point Now() { return std::chrono::steady_clock::now(); }

6
tests/unit/utils_file.cpp
View File

@ -288,7 +288,7 @@ TEST_F(UtilsFileTest, ConcurrentReadingAndWritting) {
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
}; };
constexpr size_t number_of_writes = 500; static constexpr size_t number_of_writes = 500;
std::thread writer_thread([&] { std::thread writer_thread([&] {
uint8_t current_number = 0; uint8_t current_number = 0;
for (size_t i = 0; i < number_of_writes; ++i) { for (size_t i = 0; i < number_of_writes; ++i) {
@ -299,11 +299,11 @@ TEST_F(UtilsFileTest, ConcurrentReadingAndWritting) {
} }
}); });
constexpr size_t reader_threads_num = 7; static constexpr size_t reader_threads_num = 7;
// number_of_reads needs to be higher than number_of_writes // number_of_reads needs to be higher than number_of_writes
// so we maximize the chance of having at least one reading // so we maximize the chance of having at least one reading
// thread that will read all of the data. // thread that will read all of the data.
constexpr size_t number_of_reads = 550; static constexpr size_t number_of_reads = 550;
std::vector<std::thread> reader_threads(reader_threads_num); std::vector<std::thread> reader_threads(reader_threads_num);
memgraph::utils::Synchronized<std::vector<size_t>, memgraph::utils::SpinLock> max_read_counts; memgraph::utils::Synchronized<std::vector<size_t>, memgraph::utils::SpinLock> max_read_counts;
for (size_t i = 0; i < reader_threads_num; ++i) { for (size_t i = 0; i < reader_threads_num; ++i) {

8
tests/unit/utils_file_locker.cpp
View File

@ -240,7 +240,7 @@ TEST_F(FileLockerTest, MultipleLockers) {
} }
TEST_F(FileLockerTest, MultipleLockersAndDeleters) { TEST_F(FileLockerTest, MultipleLockersAndDeleters) {
constexpr size_t files_number = 2000; static constexpr size_t files_number = 2000;
CreateFiles(files_number); CreateFiles(files_number);
// setup random number generator // setup random number generator
@ -259,9 +259,9 @@ TEST_F(FileLockerTest, MultipleLockersAndDeleters) {
memgraph::utils::FileRetainer file_retainer; memgraph::utils::FileRetainer file_retainer;
constexpr size_t thread_num = 8; static constexpr size_t thread_num = 8;
constexpr size_t file_access_num = 800; static constexpr size_t file_access_num = 800;
constexpr size_t file_delete_num = 1000; static constexpr size_t file_delete_num = 1000;
std::vector<std::thread> accessor_threads; std::vector<std::thread> accessor_threads;
accessor_threads.reserve(thread_num); accessor_threads.reserve(thread_num);

4
tests/unit/utils_memory.cpp
View File

@ -160,7 +160,7 @@ TEST(MonotonicBufferResource, AllocationWithSizeOverflow) {
// NOLINTNEXTLINE(hicpp-special-member-functions) // NOLINTNEXTLINE(hicpp-special-member-functions)
TEST(MonotonicBufferResource, AllocationWithInitialBufferOnStack) { TEST(MonotonicBufferResource, AllocationWithInitialBufferOnStack) {
TestMemory test_mem; TestMemory test_mem;
constexpr size_t stack_data_size = 1024; static constexpr size_t stack_data_size = 1024;
char stack_data[stack_data_size]; char stack_data[stack_data_size];
memset(stack_data, 0x42, stack_data_size); memset(stack_data, 0x42, stack_data_size);
memgraph::utils::MonotonicBufferResource mem(&stack_data[0], stack_data_size, &test_mem); memgraph::utils::MonotonicBufferResource mem(&stack_data[0], stack_data_size, &test_mem);
@ -342,7 +342,7 @@ class AllocationTrackingMemory final : public memgraph::utils::MemoryResource {
// NOLINTNEXTLINE(hicpp-special-member-functions) // NOLINTNEXTLINE(hicpp-special-member-functions)
TEST(MonotonicBufferResource, ResetGrowthFactor) { TEST(MonotonicBufferResource, ResetGrowthFactor) {
AllocationTrackingMemory test_mem; AllocationTrackingMemory test_mem;
constexpr size_t stack_data_size = 1024; static constexpr size_t stack_data_size = 1024;
char stack_data[stack_data_size]; char stack_data[stack_data_size];
memgraph::utils::MonotonicBufferResource mem(&stack_data[0], stack_data_size, &test_mem); memgraph::utils::MonotonicBufferResource mem(&stack_data[0], stack_data_size, &test_mem);
mem.Allocate(stack_data_size + 1); mem.Allocate(stack_data_size + 1);

4
tests/unit/utils_memory_tracker.cpp
View File

@ -19,7 +19,7 @@
TEST(MemoryTrackerTest, ExceptionEnabler) { TEST(MemoryTrackerTest, ExceptionEnabler) {
memgraph::utils::MemoryTracker memory_tracker; memgraph::utils::MemoryTracker memory_tracker;
constexpr size_t hard_limit = 10; static constexpr size_t hard_limit = 10;
memory_tracker.SetHardLimit(hard_limit); memory_tracker.SetHardLimit(hard_limit);
std::atomic<bool> can_continue{false}; std::atomic<bool> can_continue{false};
@ -56,7 +56,7 @@ TEST(MemoryTrackerTest, ExceptionEnabler) {
TEST(MemoryTrackerTest, ExceptionBlocker) { TEST(MemoryTrackerTest, ExceptionBlocker) {
memgraph::utils::MemoryTracker memory_tracker; memgraph::utils::MemoryTracker memory_tracker;
constexpr size_t hard_limit = 10; static constexpr size_t hard_limit = 10;
memory_tracker.SetHardLimit(hard_limit); memory_tracker.SetHardLimit(hard_limit);
memgraph::utils::MemoryTracker::OutOfMemoryExceptionEnabler exception_enabler; memgraph::utils::MemoryTracker::OutOfMemoryExceptionEnabler exception_enabler;

43
tests/unit/utils_temporal.cpp
View File

@ -37,29 +37,30 @@ struct TestDateParameters {
bool should_throw; bool should_throw;
}; };
constexpr std::array test_dates{TestDateParameters{{-1996, 11, 22}, true}, TestDateParameters{{1996, -11, 22}, true}, inline constexpr std::array test_dates{
TestDateParameters{{1996, 11, -22}, true}, TestDateParameters{{1, 13, 3}, true}, TestDateParameters{{-1996, 11, 22}, true}, TestDateParameters{{1996, -11, 22}, true},
TestDateParameters{{1, 12, 32}, true}, TestDateParameters{{1, 2, 29}, true}, TestDateParameters{{1996, 11, -22}, true}, TestDateParameters{{1, 13, 3}, true},
TestDateParameters{{2020, 2, 29}, false}, TestDateParameters{{1700, 2, 29}, true}, TestDateParameters{{1, 12, 32}, true}, TestDateParameters{{1, 2, 29}, true},
TestDateParameters{{1200, 2, 29}, false}, TestDateParameters{{10000, 12, 3}, true}}; TestDateParameters{{2020, 2, 29}, false}, TestDateParameters{{1700, 2, 29}, true},
TestDateParameters{{1200, 2, 29}, false}, TestDateParameters{{10000, 12, 3}, true}};
struct TestLocalTimeParameters { struct TestLocalTimeParameters {
memgraph::utils::LocalTimeParameters local_time_parameters; memgraph::utils::LocalTimeParameters local_time_parameters;
bool should_throw; bool should_throw;
}; };
constexpr std::array test_local_times{TestLocalTimeParameters{{.hour = 24}, true}, inline constexpr std::array test_local_times{TestLocalTimeParameters{{.hour = 24}, true},
TestLocalTimeParameters{{.hour = -1}, true}, TestLocalTimeParameters{{.hour = -1}, true},
TestLocalTimeParameters{{.minute = -1}, true}, TestLocalTimeParameters{{.minute = -1}, true},
TestLocalTimeParameters{{.minute = 60}, true}, TestLocalTimeParameters{{.minute = 60}, true},
TestLocalTimeParameters{{.second = -1}, true}, TestLocalTimeParameters{{.second = -1}, true},
TestLocalTimeParameters{{.minute = 60}, true}, TestLocalTimeParameters{{.minute = 60}, true},
TestLocalTimeParameters{{.millisecond = -1}, true}, TestLocalTimeParameters{{.millisecond = -1}, true},
TestLocalTimeParameters{{.millisecond = 1000}, true}, TestLocalTimeParameters{{.millisecond = 1000}, true},
TestLocalTimeParameters{{.microsecond = -1}, true}, TestLocalTimeParameters{{.microsecond = -1}, true},
TestLocalTimeParameters{{.microsecond = 1000}, true}, TestLocalTimeParameters{{.microsecond = 1000}, true},
TestLocalTimeParameters{{23, 59, 59, 999, 999}, false}, TestLocalTimeParameters{{23, 59, 59, 999, 999}, false},
TestLocalTimeParameters{{0, 0, 0, 0, 0}, false}}; TestLocalTimeParameters{{0, 0, 0, 0, 0}, false}};
} // namespace } // namespace
TEST(TemporalTest, DateConstruction) { TEST(TemporalTest, DateConstruction) {
@ -195,15 +196,15 @@ TEST(TemporalTest, DurationConversion) {
namespace { namespace {
using namespace std::literals; using namespace std::literals;
constexpr std::array parsing_test_dates_extended{ inline constexpr std::array parsing_test_dates_extended{
std::make_pair("2020-11-22"sv, memgraph::utils::DateParameters{2020, 11, 22}), std::make_pair("2020-11-22"sv, memgraph::utils::DateParameters{2020, 11, 22}),
std::make_pair("2020-11"sv, memgraph::utils::DateParameters{2020, 11}), std::make_pair("2020-11"sv, memgraph::utils::DateParameters{2020, 11}),
}; };
constexpr std::array parsing_test_dates_basic{ inline constexpr std::array parsing_test_dates_basic{
std::make_pair("20201122"sv, memgraph::utils::DateParameters{2020, 11, 22})}; std::make_pair("20201122"sv, memgraph::utils::DateParameters{2020, 11, 22})};
constexpr std::array parsing_test_local_time_extended{ inline constexpr std::array parsing_test_local_time_extended{
std::make_pair("19:23:21.123456"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123, 456}), std::make_pair("19:23:21.123456"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123, 456}),
std::make_pair("19:23:21.123"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123}), std::make_pair("19:23:21.123"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123}),
std::make_pair("19:23:21"sv, memgraph::utils::LocalTimeParameters{19, 23, 21}), std::make_pair("19:23:21"sv, memgraph::utils::LocalTimeParameters{19, 23, 21}),
@ -212,7 +213,7 @@ constexpr std::array parsing_test_local_time_extended{
std::make_pair("01:02:03.004005"sv, memgraph::utils::LocalTimeParameters{1, 2, 3, 4, 5}), std::make_pair("01:02:03.004005"sv, memgraph::utils::LocalTimeParameters{1, 2, 3, 4, 5}),
}; };
constexpr std::array parsing_test_local_time_basic{ inline constexpr std::array parsing_test_local_time_basic{
std::make_pair("192321.123456"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123, 456}), std::make_pair("192321.123456"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123, 456}),
std::make_pair("192321.123"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123}), std::make_pair("192321.123"sv, memgraph::utils::LocalTimeParameters{19, 23, 21, 123}),
std::make_pair("192321"sv, memgraph::utils::LocalTimeParameters{19, 23, 21}), std::make_pair("192321"sv, memgraph::utils::LocalTimeParameters{19, 23, 21}),

4
tests/unit/utils_thread_pool.cpp
View File

@ -20,8 +20,8 @@
using namespace std::chrono_literals; using namespace std::chrono_literals;
TEST(ThreadPool, Basic) { TEST(ThreadPool, Basic) {
constexpr size_t adder_count = 500000; static constexpr size_t adder_count = 500000;
constexpr std::array<size_t, 5> pool_sizes{1, 2, 4, 8, 100}; static constexpr std::array<size_t, 5> pool_sizes{1, 2, 4, 8, 100};
for (const auto pool_size : pool_sizes) { for (const auto pool_size : pool_sizes) {
memgraph::utils::ThreadPool pool{pool_size}; memgraph::utils::ThreadPool pool{pool_size};

16
tests/unit/websocket.cpp
View File

@ -34,8 +34,8 @@ namespace websocket = beast::websocket;
namespace net = boost::asio; namespace net = boost::asio;
using tcp = boost::asio::ip::tcp; using tcp = boost::asio::ip::tcp;
constexpr auto kResponseSuccess{"success"}; inline constexpr auto kResponseSuccess{"success"};
constexpr auto kResponseMessage{"message"}; inline constexpr auto kResponseMessage{"message"};
struct MockAuth : public memgraph::communication::websocket::AuthenticationInterface { struct MockAuth : public memgraph::communication::websocket::AuthenticationInterface {
MockAuth() = default; MockAuth() = default;
@ -180,7 +180,7 @@ TEST_F(WebSocketServerTest, WebsocketLogging) {
} }
TEST_F(WebSocketServerTest, WebsocketAuthenticationParsingError) { TEST_F(WebSocketServerTest, WebsocketAuthenticationParsingError) {
constexpr auto auth_fail = "Cannot parse JSON for WebSocket authentication"; static constexpr auto auth_fail = "Cannot parse JSON for WebSocket authentication";
{ {
SCOPED_TRACE("Checking handling of first request parsing error."); SCOPED_TRACE("Checking handling of first request parsing error.");
@ -210,7 +210,7 @@ TEST_F(WebSocketServerTest, WebsocketAuthenticationParsingError) {
} }
TEST_F(WebSocketServerTest, WebsocketAuthenticationWhenAuthPasses) { TEST_F(WebSocketServerTest, WebsocketAuthenticationWhenAuthPasses) {
constexpr auto auth_success = R"({"message":"User has been successfully authenticated!","success":true})"; static constexpr auto auth_success = R"({"message":"User has been successfully authenticated!","success":true})";
{ {
SCOPED_TRACE("Checking successful authentication response."); SCOPED_TRACE("Checking successful authentication response.");
@ -224,8 +224,8 @@ TEST_F(WebSocketServerTest, WebsocketAuthenticationWhenAuthPasses) {
} }
TEST_F(WebSocketServerTest, WebsocketAuthenticationWithMultipleAttempts) { TEST_F(WebSocketServerTest, WebsocketAuthenticationWithMultipleAttempts) {
constexpr auto auth_success = R"({"message":"User has been successfully authenticated!","success":true})"; static constexpr auto auth_success = R"({"message":"User has been successfully authenticated!","success":true})";
constexpr auto auth_fail = "Cannot parse JSON for WebSocket authentication"; static constexpr auto auth_fail = "Cannot parse JSON for WebSocket authentication";
{ {
SCOPED_TRACE("Checking multiple authentication tries from same client"); SCOPED_TRACE("Checking multiple authentication tries from same client");
@ -277,7 +277,7 @@ TEST_F(WebSocketServerTest, WebsocketAuthenticationWithMultipleAttempts) {
TEST_F(WebSocketServerTest, WebsocketAuthenticationFails) { TEST_F(WebSocketServerTest, WebsocketAuthenticationFails) {
auth.authentication = false; auth.authentication = false;
constexpr auto auth_fail = R"({"message":"Authentication failed!","success":false})"; static constexpr auto auth_fail = R"({"message":"Authentication failed!","success":false})";
{ {
auto client = Client(); auto client = Client();
EXPECT_NO_THROW(client.Connect(ServerAddress(), ServerPort())); EXPECT_NO_THROW(client.Connect(ServerAddress(), ServerPort()));
@ -291,7 +291,7 @@ TEST_F(WebSocketServerTest, WebsocketAuthenticationFails) {
#ifdef MG_ENTERPRISE #ifdef MG_ENTERPRISE
TEST_F(WebSocketServerTest, WebsocketAuthorizationFails) { TEST_F(WebSocketServerTest, WebsocketAuthorizationFails) {
auth.authorization = false; auth.authorization = false;
constexpr auto auth_fail = R"({"message":"Authorization failed!","success":false})"; static constexpr auto auth_fail = R"({"message":"Authorization failed!","success":false})";
{ {
auto client = Client(); auto client = Client();