diff --git a/be/CMakeLists.txt b/be/CMakeLists.txt index 174df0ec35..1b89319e18 100644 --- a/be/CMakeLists.txt +++ b/be/CMakeLists.txt @@ -534,12 +534,6 @@ set(DORIS_LINK_LIBS Vec ${WL_END_GROUP} ) -if (${MAKE_TEST} STREQUAL "ON") - set(DORIS_LINK_LIBS - ${DORIS_LINK_LIBS} - TestUtil - ) -endif() # COMMON_THIRDPARTY are thirdparty dependencies that can run on all platform @@ -685,10 +679,8 @@ set(DORIS_LINK_LIBS ${DORIS_LINK_LIBS} # Set libraries for test set (TEST_LINK_LIBS ${DORIS_LINK_LIBS} ${WL_START_GROUP} - Test_util gmock gtest - gtest_main ${WL_END_GROUP} ) @@ -699,7 +691,6 @@ if (${MAKE_TEST} STREQUAL "ON") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -DGTEST_USE_OWN_TR1_TUPLE=0") SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage -lgcov") add_definitions(-DBE_TEST) - add_subdirectory(${SRC_DIR}/testutil) endif () add_subdirectory(${SRC_DIR}/agent) @@ -723,46 +714,8 @@ endif() add_subdirectory(${SRC_DIR}/util) add_subdirectory(${SRC_DIR}/vec) -# Utility CMake function to make specifying tests and benchmarks less verbose -FUNCTION(ADD_BE_TEST TEST_NAME) - # use argn to add additional files - set(ADDITIONAL_FILES ${ARGN}) - set(BUILD_OUTPUT_ROOT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/") - # This gets the directory where the test is from (e.g. 'exprs' or 'runtime') - get_filename_component(DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) - get_filename_component(TEST_DIR_NAME ${TEST_NAME} PATH) - get_filename_component(TEST_FILE_NAME ${TEST_NAME} NAME) - - ADD_EXECUTABLE(${TEST_FILE_NAME} ${TEST_NAME}.cpp ${ADDITIONAL_FILES}) - TARGET_LINK_LIBRARIES(${TEST_FILE_NAME} ${TEST_LINK_LIBS}) - SET_TARGET_PROPERTIES(${TEST_FILE_NAME} PROPERTIES COMPILE_FLAGS "-fno-access-control" ENABLE_EXPORTS 1) - if (NOT "${TEST_DIR_NAME}" STREQUAL "") - SET_TARGET_PROPERTIES(${TEST_FILE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${BUILD_OUTPUT_ROOT_DIRECTORY}/${TEST_DIR_NAME}") - endif() - ADD_TEST(${TEST_FILE_NAME} "${BUILD_OUTPUT_ROOT_DIRECTORY}/${TEST_NAME}") -ENDFUNCTION() - if (${MAKE_TEST} STREQUAL "ON") - add_subdirectory(${TEST_DIR}/test_util) - add_subdirectory(${TEST_DIR}/agent) - add_subdirectory(${TEST_DIR}/common) - add_subdirectory(${TEST_DIR}/env) - add_subdirectory(${TEST_DIR}/exec) - add_subdirectory(${TEST_DIR}/exprs) - add_subdirectory(${TEST_DIR}/geo) - add_subdirectory(${TEST_DIR}/gutil) - add_subdirectory(${TEST_DIR}/http) - add_subdirectory(${TEST_DIR}/olap) - add_subdirectory(${TEST_DIR}/runtime) - add_subdirectory(${TEST_DIR}/udf) - add_subdirectory(${TEST_DIR}/util) - add_subdirectory(${TEST_DIR}/vec/core) - add_subdirectory(${TEST_DIR}/vec/exec) - add_subdirectory(${TEST_DIR}/vec/exprs) - add_subdirectory(${TEST_DIR}/vec/function) - add_subdirectory(${TEST_DIR}/vec/runtime) - add_subdirectory(${TEST_DIR}/vec/aggregate_functions) - add_subdirectory(${TEST_DIR}/tools) + add_subdirectory(${TEST_DIR}) endif () # Install be diff --git a/be/src/exprs/cast_functions.cpp b/be/src/exprs/cast_functions.cpp index 8903d5b8ac..d5498cd957 100644 --- a/be/src/exprs/cast_functions.cpp +++ b/be/src/exprs/cast_functions.cpp @@ -26,7 +26,7 @@ #include "runtime/datetime_value.h" #include "runtime/string_value.h" #include "string_functions.h" -#include "util/array_parser.hpp" +#include "util/array_parser.h" #include "util/mysql_global.h" #include "util/string_parser.hpp" diff --git a/be/src/geo/geo_functions.cpp b/be/src/geo/geo_functions.cpp index 33ea5ca0c0..9148b5b347 100644 --- a/be/src/geo/geo_functions.cpp +++ b/be/src/geo/geo_functions.cpp @@ -236,7 +236,8 @@ void GeoFunctions::st_contains_prepare(doris_udf::FunctionContext* ctx, if (str->is_null) { contains_ctx->is_null = true; } else { - contains_ctx->shapes[i] = GeoShape::from_encoded(str->ptr, str->len); + contains_ctx->shapes[i] = + std::shared_ptr(GeoShape::from_encoded(str->ptr, str->len)); if (contains_ctx->shapes[i] == nullptr) { contains_ctx->is_null = true; } @@ -267,22 +268,21 @@ doris_udf::BooleanVal GeoFunctions::st_contains(doris_udf::FunctionContext* ctx, if (state != nullptr && state->is_null) { return BooleanVal::null(); } - GeoShape* shapes[2] = {nullptr, nullptr}; + std::vector> shapes = {nullptr, nullptr}; const StringVal* strs[2] = {&lhs, &rhs}; - // use this to delete new - StContainsState local_state; for (int i = 0; i < 2; ++i) { if (state != nullptr && state->shapes[i] != nullptr) { shapes[i] = state->shapes[i]; } else { - shapes[i] = local_state.shapes[i] = GeoShape::from_encoded(strs[i]->ptr, strs[i]->len); + shapes[i] = + std::shared_ptr(GeoShape::from_encoded(strs[i]->ptr, strs[i]->len)); if (shapes[i] == nullptr) { return BooleanVal::null(); } } } - return shapes[0]->contains(shapes[1]); + return shapes[0]->contains(shapes[1].get()); } } // namespace doris diff --git a/be/src/geo/geo_functions.h b/be/src/geo/geo_functions.h index 90f7d6bccb..c7e069b2a9 100644 --- a/be/src/geo/geo_functions.h +++ b/be/src/geo/geo_functions.h @@ -116,15 +116,11 @@ struct StConstructState { std::string encoded_buf; }; - struct StContainsState { - StContainsState() : is_null(false), shapes{nullptr, nullptr} {} - ~StContainsState() { - delete shapes[0]; - delete shapes[1]; - } + StContainsState() : is_null(false), shapes {nullptr, nullptr} {} + ~StContainsState() {} bool is_null; - GeoShape* shapes[2]; + std::vector> shapes; }; } // namespace doris diff --git a/be/src/olap/page_cache.cpp b/be/src/olap/page_cache.cpp index 7f78176164..6e6d2cfa29 100644 --- a/be/src/olap/page_cache.cpp +++ b/be/src/olap/page_cache.cpp @@ -34,22 +34,21 @@ StoragePageCache::StoragePageCache(size_t capacity, int32_t index_cache_percenta MemTrackerLevel::OVERVIEW)) { SCOPED_SWITCH_THREAD_LOCAL_MEM_TRACKER(_mem_tracker); if (index_cache_percentage == 0) { - _data_page_cache = - std::unique_ptr(new_lru_cache("DataPageCache", capacity)); + _data_page_cache = std::unique_ptr(new_lru_cache("DataPageCache", capacity)); } else if (index_cache_percentage == 100) { - _index_page_cache = - std::unique_ptr(new_lru_cache("IndexPageCache", capacity)); + _index_page_cache = std::unique_ptr(new_lru_cache("IndexPageCache", capacity)); } else if (index_cache_percentage > 0 && index_cache_percentage < 100) { - _data_page_cache = std::unique_ptr(new_lru_cache( - "DataPageCache", capacity * (100 - index_cache_percentage) / 100)); - _index_page_cache = std::unique_ptr(new_lru_cache( - "IndexPageCache", capacity * index_cache_percentage / 100)); + _data_page_cache = std::unique_ptr( + new_lru_cache("DataPageCache", capacity * (100 - index_cache_percentage) / 100)); + _index_page_cache = std::unique_ptr( + new_lru_cache("IndexPageCache", capacity * index_cache_percentage / 100)); } else { CHECK(false) << "invalid index page cache percentage"; } } -bool StoragePageCache::lookup(const CacheKey& key, PageCacheHandle* handle, segment_v2::PageTypePB page_type) { +bool StoragePageCache::lookup(const CacheKey& key, PageCacheHandle* handle, + segment_v2::PageTypePB page_type) { auto cache = _get_page_cache(page_type); auto lru_handle = cache->lookup(key.encode()); if (lru_handle == nullptr) { diff --git a/be/src/olap/page_cache.h b/be/src/olap/page_cache.h index b7ace4dd04..be5a3ffd71 100644 --- a/be/src/olap/page_cache.h +++ b/be/src/olap/page_cache.h @@ -21,12 +21,11 @@ #include #include -#include "gutil/macros.h" // for DISALLOW_COPY_AND_ASSIGN -#include "olap/lru_cache.h" #include "gen_cpp/segment_v2.pb.h" // for cache allocation +#include "gutil/macros.h" // for DISALLOW_COPY_AND_ASSIGN +#include "olap/lru_cache.h" #include "runtime/mem_tracker.h" - namespace doris { class PageCacheHandle; @@ -100,10 +99,10 @@ private: std::shared_ptr _mem_tracker = nullptr; Cache* _get_page_cache(segment_v2::PageTypePB page_type) { - switch (page_type) - { - case segment_v2::DATA_PAGE: + switch (page_type) { + case segment_v2::DATA_PAGE: { return _data_page_cache.get(); + } case segment_v2::INDEX_PAGE: return _index_page_cache.get(); default: diff --git a/be/src/olap/storage_engine.cpp b/be/src/olap/storage_engine.cpp index f56c37c8e1..c999e1dd80 100644 --- a/be/src/olap/storage_engine.cpp +++ b/be/src/olap/storage_engine.cpp @@ -134,9 +134,7 @@ StorageEngine::StorageEngine(const EngineOptions& options) _default_rowset_type(ALPHA_ROWSET), _heartbeat_flags(nullptr), _stream_load_recorder(nullptr) { - if (_s_instance == nullptr) { - _s_instance = this; - } + _s_instance = this; REGISTER_HOOK_METRIC(unused_rowsets_count, [this]() { std::lock_guard lock(_gc_mutex); return _unused_rowsets.size(); @@ -580,11 +578,11 @@ void StorageEngine::stop() { THREAD_JOIN(_tablet_checkpoint_tasks_producer_thread); #undef THREAD_JOIN -#define THREADS_JOIN(threads) \ - for (const auto& thread : threads) {\ - if (thread) { \ - thread->join(); \ - } \ +#define THREADS_JOIN(threads) \ + for (const auto& thread : threads) { \ + if (thread) { \ + thread->join(); \ + } \ } THREADS_JOIN(_path_gc_threads); @@ -745,8 +743,8 @@ void StorageEngine::_clean_unused_rowset_metas() { // tablet may be dropped // TODO(cmy): this is better to be a VLOG, because drop table is a very common case. // leave it as INFO log for observation. Maybe change it in future. - LOG(INFO) << "failed to find tablet " << rowset_meta->tablet_id() << " for rowset: " << rowset_meta->rowset_id() - << ", tablet may be dropped"; + LOG(INFO) << "failed to find tablet " << rowset_meta->tablet_id() + << " for rowset: " << rowset_meta->rowset_id() << ", tablet may be dropped"; invalid_rowset_metas.push_back(rowset_meta); return true; } @@ -759,7 +757,8 @@ void StorageEngine::_clean_unused_rowset_metas() { // which will creates a new tablet with the same id but a different uid. // And in the historical version, when we deleted the replica, we did not delete the corresponding rowset meta, // thus causing the original rowset meta to remain(with same tablet id but different uid). - LOG(WARNING) << "rowset's tablet uid " << rowset_meta->tablet_uid() << " does not equal to tablet uid: " << tablet->tablet_uid(); + LOG(WARNING) << "rowset's tablet uid " << rowset_meta->tablet_uid() + << " does not equal to tablet uid: " << tablet->tablet_uid(); invalid_rowset_metas.push_back(rowset_meta); return true; } @@ -779,9 +778,10 @@ void StorageEngine::_clean_unused_rowset_metas() { RowsetMetaManager::traverse_rowset_metas(data_dir->get_meta(), clean_rowset_func); for (auto& rowset_meta : invalid_rowset_metas) { RowsetMetaManager::remove(data_dir->get_meta(), rowset_meta->tablet_uid(), - rowset_meta->rowset_id()); + rowset_meta->rowset_id()); } - LOG(INFO) << "remove " << invalid_rowset_metas.size() << " invalid rowset meta from dir: " << data_dir->path(); + LOG(INFO) << "remove " << invalid_rowset_metas.size() + << " invalid rowset meta from dir: " << data_dir->path(); invalid_rowset_metas.clear(); } } diff --git a/be/src/runtime/user_function_cache.cpp b/be/src/runtime/user_function_cache.cpp index 49fd4af546..503ba5e67b 100644 --- a/be/src/runtime/user_function_cache.cpp +++ b/be/src/runtime/user_function_cache.cpp @@ -17,9 +17,9 @@ #include "runtime/user_function_cache.h" +#include #include // boost::is_any_of #include // boost::algorithm::ends_with -#include #include #include @@ -56,11 +56,11 @@ struct UserFunctionCacheEntry { std::string lib_file; // make it atomic variable instead of holding a lock - std::atomic is_loaded{false}; + std::atomic is_loaded {false}; // Set to true when this library is not needed. // e.g. deleting some unused library to re - std::atomic should_delete_library{false}; + std::atomic should_delete_library {false}; // lock to make sure only one can load this cache std::mutex load_lock; @@ -80,7 +80,7 @@ struct UserFunctionCacheEntry { LibType type; private: - std::atomic _refs{0}; + std::atomic _refs {0}; }; UserFunctionCacheEntry::~UserFunctionCacheEntry() { @@ -116,7 +116,10 @@ UserFunctionCache* UserFunctionCache::instance() { } Status UserFunctionCache::init(const std::string& lib_dir) { - DCHECK(_lib_dir.empty()); +#ifndef BE_TEST + // _lib_dir may reuesd bettween unit tests + DCHECK(_lib_dir.empty()) << _lib_dir; +#endif _lib_dir = lib_dir; // 1. dynamic open current process RETURN_IF_ERROR(dynamic_open(nullptr, &_current_process_handle)); @@ -241,8 +244,7 @@ Status UserFunctionCache::get_function_ptr(int64_t fid, const std::string& orig_ Status UserFunctionCache::_get_cache_entry(int64_t fid, const std::string& url, const std::string& checksum, - UserFunctionCacheEntry** output_entry, - LibType type) { + UserFunctionCacheEntry** output_entry, LibType type) { UserFunctionCacheEntry* entry = nullptr; { std::lock_guard l(_cache_lock); @@ -250,7 +252,8 @@ Status UserFunctionCache::_get_cache_entry(int64_t fid, const std::string& url, if (it != _entry_map.end()) { entry = it->second; } else { - entry = new UserFunctionCacheEntry(fid, checksum, _make_lib_file(fid, checksum, type), type); + entry = new UserFunctionCacheEntry(fid, checksum, _make_lib_file(fid, checksum, type), + type); entry->ref(); _entry_map.emplace(fid, entry); @@ -375,11 +378,13 @@ Status UserFunctionCache::_add_to_classpath(UserFunctionCacheEntry* entry) { JNIEnv* env; RETURN_IF_ERROR(JniUtil::GetJNIEnv(&env)); jclass class_class_loader = env->FindClass("java/lang/ClassLoader"); - jmethodID method_get_system_class_loader = - env->GetStaticMethodID(class_class_loader, "getSystemClassLoader", "()Ljava/lang/ClassLoader;"); - jobject class_loader = env->CallStaticObjectMethod(class_class_loader, method_get_system_class_loader); + jmethodID method_get_system_class_loader = env->GetStaticMethodID( + class_class_loader, "getSystemClassLoader", "()Ljava/lang/ClassLoader;"); + jobject class_loader = + env->CallStaticObjectMethod(class_class_loader, method_get_system_class_loader); jclass class_url_class_loader = env->FindClass("java/net/URLClassLoader"); - jmethodID method_add_url = env->GetMethodID(class_url_class_loader, "addURL", "(Ljava/net/URL;)V"); + jmethodID method_add_url = + env->GetMethodID(class_url_class_loader, "addURL", "(Ljava/net/URL;)V"); jclass class_url = env->FindClass("java/net/URL"); jmethodID url_ctor = env->GetMethodID(class_url, "", "(Ljava/lang/String;)V"); jobject urlInstance = env->NewObject(class_url, url_ctor, env->NewStringUTF(path.c_str())); @@ -412,8 +417,8 @@ void UserFunctionCache::release_entry(UserFunctionCacheEntry* entry) { } } -Status UserFunctionCache::get_jarpath(int64_t fid, const std::string& url, const std::string& checksum, - std::string* libpath) { +Status UserFunctionCache::get_jarpath(int64_t fid, const std::string& url, + const std::string& checksum, std::string* libpath) { UserFunctionCacheEntry* entry = nullptr; RETURN_IF_ERROR(_get_cache_entry(fid, url, checksum, &entry, LibType::JAR)); *libpath = entry->lib_file; diff --git a/be/src/testutil/CMakeLists.txt b/be/src/testutil/CMakeLists.txt deleted file mode 100644 index 6d7b0aad5b..0000000000 --- a/be/src/testutil/CMakeLists.txt +++ /dev/null @@ -1,28 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/src/testutil") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/src/testutil") - -add_library(TestUtil - desc_tbl_builder.cc - function_utils.cpp -) - diff --git a/be/src/util/CMakeLists.txt b/be/src/util/CMakeLists.txt index 46a6ae7b7d..c4402fbece 100644 --- a/be/src/util/CMakeLists.txt +++ b/be/src/util/CMakeLists.txt @@ -25,6 +25,7 @@ set(UTIL_FILES arrow/row_batch.cpp arrow/row_block.cpp arrow/utils.cpp + array_parser.cpp bfd_parser.cpp bitmap.cpp block_compression.cpp diff --git a/be/src/util/array_parser.cpp b/be/src/util/array_parser.cpp new file mode 100644 index 0000000000..133573af52 --- /dev/null +++ b/be/src/util/array_parser.cpp @@ -0,0 +1,44 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "util/array_parser.h" + +namespace doris { +std::unordered_map ArrayParser::_types_mapping = { + {FunctionContext::INVALID_TYPE, PrimitiveType::INVALID_TYPE}, + {FunctionContext::TYPE_NULL, PrimitiveType::TYPE_NULL}, + {FunctionContext::TYPE_BOOLEAN, PrimitiveType::TYPE_BOOLEAN}, + {FunctionContext::TYPE_TINYINT, PrimitiveType::TYPE_TINYINT}, + {FunctionContext::TYPE_SMALLINT, PrimitiveType::TYPE_SMALLINT}, + {FunctionContext::TYPE_INT, PrimitiveType::TYPE_INT}, + {FunctionContext::TYPE_BIGINT, PrimitiveType::TYPE_BIGINT}, + {FunctionContext::TYPE_LARGEINT, PrimitiveType::TYPE_LARGEINT}, + {FunctionContext::TYPE_FLOAT, PrimitiveType::TYPE_FLOAT}, + {FunctionContext::TYPE_DOUBLE, PrimitiveType::TYPE_DOUBLE}, + {FunctionContext::TYPE_DECIMAL_DEPRACTED, PrimitiveType::TYPE_DECIMAL_DEPRACTED}, + {FunctionContext::TYPE_DATE, PrimitiveType::TYPE_DATE}, + {FunctionContext::TYPE_DATETIME, PrimitiveType::TYPE_DATETIME}, + {FunctionContext::TYPE_CHAR, PrimitiveType::TYPE_CHAR}, + {FunctionContext::TYPE_VARCHAR, PrimitiveType::TYPE_VARCHAR}, + {FunctionContext::TYPE_HLL, PrimitiveType::TYPE_HLL}, + {FunctionContext::TYPE_STRING, PrimitiveType::TYPE_STRING}, + {FunctionContext::TYPE_DECIMALV2, PrimitiveType::TYPE_DECIMALV2}, + {FunctionContext::TYPE_OBJECT, PrimitiveType::TYPE_OBJECT}, + {FunctionContext::TYPE_ARRAY, PrimitiveType::TYPE_ARRAY}, +}; + +} \ No newline at end of file diff --git a/be/src/util/array_parser.hpp b/be/src/util/array_parser.h similarity index 83% rename from be/src/util/array_parser.hpp rename to be/src/util/array_parser.h index 83ef7da9fb..249b190810 100644 --- a/be/src/util/array_parser.hpp +++ b/be/src/util/array_parser.h @@ -185,28 +185,4 @@ private: private: static std::unordered_map _types_mapping; }; - -std::unordered_map ArrayParser::_types_mapping = { - {FunctionContext::INVALID_TYPE, PrimitiveType::INVALID_TYPE}, - {FunctionContext::TYPE_NULL, PrimitiveType::TYPE_NULL}, - {FunctionContext::TYPE_BOOLEAN, PrimitiveType::TYPE_BOOLEAN}, - {FunctionContext::TYPE_TINYINT, PrimitiveType::TYPE_TINYINT}, - {FunctionContext::TYPE_SMALLINT, PrimitiveType::TYPE_SMALLINT}, - {FunctionContext::TYPE_INT, PrimitiveType::TYPE_INT}, - {FunctionContext::TYPE_BIGINT, PrimitiveType::TYPE_BIGINT}, - {FunctionContext::TYPE_LARGEINT, PrimitiveType::TYPE_LARGEINT}, - {FunctionContext::TYPE_FLOAT, PrimitiveType::TYPE_FLOAT}, - {FunctionContext::TYPE_DOUBLE, PrimitiveType::TYPE_DOUBLE}, - {FunctionContext::TYPE_DECIMAL_DEPRACTED, PrimitiveType::TYPE_DECIMAL_DEPRACTED}, - {FunctionContext::TYPE_DATE, PrimitiveType::TYPE_DATE}, - {FunctionContext::TYPE_DATETIME, PrimitiveType::TYPE_DATETIME}, - {FunctionContext::TYPE_CHAR, PrimitiveType::TYPE_CHAR}, - {FunctionContext::TYPE_VARCHAR, PrimitiveType::TYPE_VARCHAR}, - {FunctionContext::TYPE_HLL, PrimitiveType::TYPE_HLL}, - {FunctionContext::TYPE_STRING, PrimitiveType::TYPE_STRING}, - {FunctionContext::TYPE_DECIMALV2, PrimitiveType::TYPE_DECIMALV2}, - {FunctionContext::TYPE_OBJECT, PrimitiveType::TYPE_OBJECT}, - {FunctionContext::TYPE_ARRAY, PrimitiveType::TYPE_ARRAY}, -}; - } // namespace doris diff --git a/be/src/util/core_local.h b/be/src/util/core_local.h index 4a36bd0e6b..f309bbe1ff 100644 --- a/be/src/util/core_local.h +++ b/be/src/util/core_local.h @@ -132,6 +132,19 @@ public: } T* access_at_core(size_t core_idx) const { return _values[core_idx]; } + inline void reset() { + for (int i = 0; i < _size; ++i) { + _values[i]->~T(); + } + _values.clear(); + _values.resize(_size, nullptr); + CoreLocalValueController* controller = CoreLocalValueController::instance(); + for (int i = 0; i < _size; ++i) { + void* ptr = controller->allocator(i)->get_or_create(_id); + _values[i] = new (ptr) T(); + } + } + private: int _id = -1; size_t _size = 0; diff --git a/be/src/util/metrics.cpp b/be/src/util/metrics.cpp index a60384d067..a9cae294d6 100644 --- a/be/src/util/metrics.cpp +++ b/be/src/util/metrics.cpp @@ -19,7 +19,6 @@ #include #include - namespace doris { std::ostream& operator<<(std::ostream& os, MetricType type) { @@ -105,21 +104,17 @@ std::string labels_to_string(std::initializer_list multi_labels) return ss.str(); } -std::string Metric::to_prometheus(const std::string& display_name, - const Labels& entity_labels, +std::string Metric::to_prometheus(const std::string& display_name, const Labels& entity_labels, const Labels& metric_labels) const { std::stringstream ss; - ss << display_name // metric name - << labels_to_string({&entity_labels, &metric_labels}) // metric labels - << " " << to_string() << "\n"; // metric value + ss << display_name // metric name + << labels_to_string({&entity_labels, &metric_labels}) // metric labels + << " " << to_string() << "\n"; // metric value return ss.str(); } -std::map HistogramMetric::_s_output_percentiles = {{"0.50", 50.0}, - {"0.75", 75.0}, - {"0.90", 90.0}, - {"0.95", 95.0}, - {"0.99", 99.0}}; +std::map HistogramMetric::_s_output_percentiles = { + {"0.50", 50.0}, {"0.75", 75.0}, {"0.90", 90.0}, {"0.95", 95.0}, {"0.99", 99.0}}; void HistogramMetric::clear() { std::lock_guard l(_lock); _stats.clear(); @@ -170,31 +165,24 @@ std::string HistogramMetric::to_prometheus(const std::string& display_name, std::stringstream ss; for (const auto& percentile : _s_output_percentiles) { auto quantile_lable = Labels({{"quantile", percentile.first}}); - ss << display_name - << labels_to_string({&entity_labels, &metric_labels, &quantile_lable}) + ss << display_name << labels_to_string({&entity_labels, &metric_labels, &quantile_lable}) << " " << _stats.percentile(percentile.second) << "\n"; } - ss << display_name << "_sum" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.sum() << "\n"; - ss << display_name << "_count" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.num() << "\n"; - ss << display_name << "_max" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.max() << "\n"; - ss << display_name << "_min" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.min() << "\n"; - ss << display_name << "_average" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.average() << "\n"; - ss << display_name << "_median" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.median() << "\n"; + ss << display_name << "_sum" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.sum() << "\n"; + ss << display_name << "_count" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.num() << "\n"; + ss << display_name << "_max" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.max() << "\n"; + ss << display_name << "_min" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.min() << "\n"; + ss << display_name << "_average" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.average() << "\n"; + ss << display_name << "_median" << labels_to_string({&entity_labels, &metric_labels}) << " " + << _stats.median() << "\n"; ss << display_name << "_standard_deviation" - << labels_to_string({&entity_labels, &metric_labels}) - << " " << _stats.standard_deviation() << "\n"; + << labels_to_string({&entity_labels, &metric_labels}) << " " << _stats.standard_deviation() + << "\n"; return ss.str(); } @@ -206,8 +194,10 @@ rj::Value HistogramMetric::to_json_value(rj::Document::AllocatorType& allocator) json_value.AddMember("average", rj::Value(_stats.average()), allocator); json_value.AddMember("median", rj::Value(_stats.median()), allocator); for (const auto& percentile : _s_output_percentiles) { - json_value.AddMember(rj::Value(std::string("percentile_").append(percentile.first.substr(2)).c_str(), allocator), - rj::Value(_stats.percentile(percentile.second)), allocator); + json_value.AddMember( + rj::Value(std::string("percentile_").append(percentile.first.substr(2)).c_str(), + allocator), + rj::Value(_stats.percentile(percentile.second)), allocator); } json_value.AddMember("standard_deviation", rj::Value(_stats.standard_deviation()), allocator); json_value.AddMember("max", rj::Value(_stats.max()), allocator); @@ -251,7 +241,9 @@ Metric* MetricEntity::get_metric(const std::string& name, const std::string& gro void MetricEntity::register_hook(const std::string& name, const std::function& hook) { std::lock_guard l(_lock); +#ifndef BE_TEST DCHECK(_hooks.find(name) == _hooks.end()) << "hook is already exist! " << _name << ":" << name; +#endif _hooks.emplace(name, hook); } @@ -349,12 +341,12 @@ std::string MetricRegistry::to_prometheus(bool with_tablet_metrics) const { for (const auto& entity_metrics_by_type : entity_metrics_by_types) { if (last_group_name.empty() || last_group_name != entity_metrics_by_type.first->group_name) { - ss << entity_metrics_by_type.first->to_prometheus(_name); // metric TYPE line + ss << entity_metrics_by_type.first->to_prometheus(_name); // metric TYPE line } last_group_name = entity_metrics_by_type.first->group_name; std::string display_name = entity_metrics_by_type.first->combine_name(_name); for (const auto& entity_metric : entity_metrics_by_type.second) { - ss << entity_metric.second->to_prometheus(display_name, // metric key-value line + ss << entity_metric.second->to_prometheus(display_name, // metric key-value line entity_metric.first->_labels, entity_metrics_by_type.first->labels); } @@ -364,7 +356,7 @@ std::string MetricRegistry::to_prometheus(bool with_tablet_metrics) const { } std::string MetricRegistry::to_json(bool with_tablet_metrics) const { - rj::Document doc{rj::kArrayType}; + rj::Document doc {rj::kArrayType}; rj::Document::AllocatorType& allocator = doc.GetAllocator(); std::lock_guard l(_lock); for (const auto& entity : _entities) { diff --git a/be/src/util/metrics.h b/be/src/util/metrics.h index c5b005f0e6..24a640b3f0 100644 --- a/be/src/util/metrics.h +++ b/be/src/util/metrics.h @@ -162,6 +162,8 @@ public: void increment(const T& delta) { __sync_fetch_and_add(_value.access(), delta); } + void reset() { _value.reset(); } + rj::Value to_json_value(rj::Document::AllocatorType& allocator) const override { return rj::Value(value()); } diff --git a/be/src/vec/functions/functions_geo.cpp b/be/src/vec/functions/functions_geo.cpp index 51b9cd5311..71018a9b67 100644 --- a/be/src/vec/functions/functions_geo.cpp +++ b/be/src/vec/functions/functions_geo.cpp @@ -17,8 +17,8 @@ #include "vec/functions/functions_geo.h" -#include "geo/geo_types.h" #include "geo/geo_functions.h" +#include "geo/geo_types.h" #include "gutil/strings/substitute.h" #include "vec/columns/column_const.h" #include "vec/functions/simple_function_factory.h" @@ -220,12 +220,11 @@ struct StCircle { size_t result) { DCHECK_EQ(arguments.size(), 3); auto return_type = remove_nullable(block.get_data_type(result)); - auto center_lng = block.get_by_position(arguments[0]) - .column->convert_to_full_column_if_const(); - auto center_lat = block.get_by_position(arguments[1]) - .column->convert_to_full_column_if_const(); - auto radius = block.get_by_position(arguments[2]) - .column->convert_to_full_column_if_const(); + auto center_lng = + block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); + auto center_lat = + block.get_by_position(arguments[1]).column->convert_to_full_column_if_const(); + auto radius = block.get_by_position(arguments[2]).column->convert_to_full_column_if_const(); const auto size = center_lng->size(); @@ -234,7 +233,7 @@ struct StCircle { res = ColumnNullable::create(return_type->create_column(), ColumnUInt8::create()); StConstructState* state = - (StConstructState*) context->get_function_state(FunctionContext::FRAGMENT_LOCAL); + (StConstructState*)context->get_function_state(FunctionContext::FRAGMENT_LOCAL); if (state == nullptr) { GeoCircle circle; std::string buf; @@ -270,8 +269,8 @@ struct StCircle { return Status::OK(); } - if (!context->is_arg_constant(0) || !context->is_arg_constant(1) - || !context->is_arg_constant(2)) { + if (!context->is_arg_constant(0) || !context->is_arg_constant(1) || + !context->is_arg_constant(2)) { return Status::OK(); } @@ -300,8 +299,8 @@ struct StCircle { if (scope != FunctionContext::FRAGMENT_LOCAL) { return Status::OK(); } - StConstructState* state = reinterpret_cast( - context->get_function_state(scope)); + StConstructState* state = + reinterpret_cast(context->get_function_state(scope)); delete state; return Status::OK(); } @@ -322,16 +321,16 @@ struct StContains { auto null_type = std::reinterpret_pointer_cast(return_type); auto res = ColumnNullable::create(return_type->create_column(), ColumnUInt8::create()); - StContainsState* state = (StContainsState*) context->get_function_state(FunctionContext::FRAGMENT_LOCAL); + StContainsState* state = + (StContainsState*)context->get_function_state(FunctionContext::FRAGMENT_LOCAL); if (state != nullptr && state->is_null) { res->insert_data(nullptr, 0); block.replace_by_position(result, ColumnConst::create(std::move(res), size)); return Status::OK(); } - StContainsState local_state; int i; - GeoShape* shapes[2] = {nullptr, nullptr}; + std::vector> shapes = {nullptr, nullptr}; for (int row = 0; row < size; ++row) { auto lhs_value = shape1->get_data_at(row); auto rhs_value = shape2->get_data_at(row); @@ -340,7 +339,8 @@ struct StContains { if (state != nullptr && state->shapes[i] != nullptr) { shapes[i] = state->shapes[i]; } else { - shapes[i] = local_state.shapes[i] = GeoShape::from_encoded(strs[i]->data, strs[i]->size); + shapes[i] = std::shared_ptr( + GeoShape::from_encoded(strs[i]->data, strs[i]->size)); if (shapes[i] == nullptr) { res->insert_data(nullptr, 0); break; @@ -349,7 +349,7 @@ struct StContains { } if (i == 2) { - auto contains_value = shapes[0]->contains(shapes[1]); + auto contains_value = shapes[0]->contains(shapes[1].get()); res->insert_data(const_cast((char*)&contains_value), 0); } } @@ -373,7 +373,8 @@ struct StContains { if (str->is_null) { contains_ctx->is_null = true; } else { - contains_ctx->shapes[i] = GeoShape::from_encoded(str->ptr, str->len); + contains_ctx->shapes[i] = + std::shared_ptr(GeoShape::from_encoded(str->ptr, str->len)); if (contains_ctx->shapes[i] == nullptr) { contains_ctx->is_null = true; } @@ -389,49 +390,49 @@ struct StContains { if (scope != FunctionContext::FRAGMENT_LOCAL) { return Status::OK(); } - StContainsState* state = reinterpret_cast( - context->get_function_state(scope)); + StContainsState* state = + reinterpret_cast(context->get_function_state(scope)); delete state; return Status::OK(); } }; -struct StGeometryFromText{ +struct StGeometryFromText { static constexpr auto NAME = "st_geometryfromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_ANY; }; -struct StGeomFromText{ +struct StGeomFromText { static constexpr auto NAME = "st_geomfromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_ANY; }; -struct StLineFromText{ +struct StLineFromText { static constexpr auto NAME = "st_linefromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_LINE_STRING; }; -struct StLineStringFromText{ +struct StLineStringFromText { static constexpr auto NAME = "st_linestringfromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_LINE_STRING; }; -struct StPolygon{ +struct StPolygon { static constexpr auto NAME = "st_polygon"; static constexpr GeoShapeType shape_type = GEO_SHAPE_POLYGON; }; -struct StPolyFromText{ +struct StPolyFromText { static constexpr auto NAME = "st_polyfromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_POLYGON; }; -struct StPolygonFromText{ +struct StPolygonFromText { static constexpr auto NAME = "st_polygonfromtext"; static constexpr GeoShapeType shape_type = GEO_SHAPE_POLYGON; }; -template +template struct StGeoFromText { static constexpr auto NEED_CONTEXT = true; static constexpr auto NAME = Impl::NAME; @@ -446,13 +447,15 @@ struct StGeoFromText { auto null_type = std::reinterpret_pointer_cast(return_type); auto res = ColumnNullable::create(return_type->create_column(), ColumnUInt8::create()); - StConstructState* state = (StConstructState*) context->get_function_state(FunctionContext::FRAGMENT_LOCAL); + StConstructState* state = + (StConstructState*)context->get_function_state(FunctionContext::FRAGMENT_LOCAL); if (state == nullptr) { GeoParseStatus status; std::string buf; for (int row = 0; row < size; ++row) { auto value = geo->get_data_at(row); - std::unique_ptr shape(GeoShape::from_wkt(value.data, value.size, &status)); + std::unique_ptr shape( + GeoShape::from_wkt(value.data, value.size, &status)); if (shape == nullptr || status != GEO_PARSE_OK || (Impl::shape_type != GEO_SHAPE_ANY && shape->type() != Impl::shape_type)) { res->insert_data(nullptr, 0); @@ -490,8 +493,8 @@ struct StGeoFromText { state->is_null = true; } else { GeoParseStatus status; - std::unique_ptr shape(GeoShape::from_wkt(const_cast( - (char*)str_value->ptr), str_value->len, &status)); + std::unique_ptr shape(GeoShape::from_wkt( + const_cast((char*)str_value->ptr), str_value->len, &status)); if (shape == nullptr || (Impl::shape_type != GEO_SHAPE_ANY && shape->type() != Impl::shape_type)) { state->is_null = true; @@ -506,8 +509,8 @@ struct StGeoFromText { static Status close(FunctionContext* context, FunctionContext::FunctionStateScope scope) { if (scope == FunctionContext::FRAGMENT_LOCAL) { - StConstructState* state = reinterpret_cast( - context->get_function_state(scope)); + StConstructState* state = + reinterpret_cast(context->get_function_state(scope)); delete state; } return Status::OK(); diff --git a/be/test/CMakeLists.txt b/be/test/CMakeLists.txt new file mode 100644 index 0000000000..a97a0b0407 --- /dev/null +++ b/be/test/CMakeLists.txt @@ -0,0 +1,389 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# where to put generated libraries +set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test") + +# where to put generated libraries +set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test") + +set(AGENT_TEST_FILES + agent/utils_test.cpp + # agent/agent_server_test.cpp + # agent/cgroups_mgr_test.cpp + # agent/heartbeat_server_test.cpp +) +set(COMMON_TEST_FILES + common/resource_tls_test.cpp + common/status_test.cpp + common/config_test.cpp +) +set(ENV_TEST_FILES + env/env_posix_test.cpp +) + +set(EXEC_TEST_FILES + exec/hash_table_test.cpp + exec/olap_common_test.cpp + exec/json_scanner_test.cpp + exec/json_scanner_with_jsonpath_test.cpp + exec/parquet_scanner_test.cpp + exec/orc_scanner_test.cpp + exec/plain_text_line_reader_uncompressed_test.cpp + exec/plain_text_line_reader_gzip_test.cpp + exec/plain_text_line_reader_bzip_test.cpp + exec/plain_text_line_reader_lz4frame_test.cpp + exec/broker_scanner_test.cpp + exec/broker_scan_node_test.cpp + exec/tablet_info_test.cpp + exec/tablet_sink_test.cpp + exec/buffered_reader_test.cpp + exec/es_http_scan_node_test.cpp + exec/es_predicate_test.cpp + exec/es_query_builder_test.cpp + exec/es_scan_reader_test.cpp + exec/s3_reader_test.cpp + exec/multi_bytes_separator_test.cpp + # exec/hdfs_file_reader_test.cpp + # exec/new_olap_scan_node_test.cpp + # exec/pre_aggregation_node_test.cpp + # exec/partitioned_hash_table_test.cpp + # exec/olap_scanner_test.cpp + # exec/olap_meta_reader_test.cpp + # exec/olap_scan_node_test.cpp + # exec/mysql_scan_node_test.cpp + # exec/mysql_scanner_test.cpp + # exec/csv_scanner_test.cpp + # exec/csv_scan_node_test.cpp + # exec/csv_scan_bench_test.cpp + # exec/schema_scan_node_test.cpp + # exec/unix_odbc_test.cpp + # exec/schema_scanner_test.cpp + # exec/set_executor_test.cpp + # exec/schema_scanner/schema_authors_scanner_test.cpp + # exec/schema_scanner/schema_columns_scanner_test.cpp + # exec/schema_scanner/schema_create_table_scanner_test.cpp + # exec/schema_scanner/schema_open_tables_scanner_test.cpp + # exec/schema_scanner/schema_schemata_scanner_test.cpp + # exec/schema_scanner/schema_table_names_scanner_test.cpp + # exec/schema_scanner/schema_tables_scanner_test.cpp + # exec/schema_scanner/schema_variables_scanner_test.cpp + # exec/schema_scanner/schema_engines_scanner_test.cpp + # exec/schema_scanner/schema_collations_scanner_test.cpp + # exec/schema_scanner/schema_charsets_scanner_test.cpp + # exec/broker_reader_test.cpp + # exec/es_scan_node_test.cpp +) + +if(DEFINED DORIS_WITH_LZO) + set(EXEC_TEST_FILES ${EXEC_FILES} exec/plain_text_line_reader_lzop_test.cpp) +endif() + +set(EXPRS_TEST_FILES + # exprs/binary_predicate_test.cpp + # exprs/in_predicate_test.cpp + # exprs/expr-test.cpp + # exprs/hybrid_set_test.cpp + # exprs/in-predicate-test.cpp + exprs/json_function_test.cpp + exprs/string_functions_test.cpp + exprs/timestamp_functions_test.cpp + exprs/percentile_approx_test.cpp + exprs/percentile_test.cpp + exprs/bitmap_function_test.cpp + exprs/hll_function_test.cpp + exprs/encryption_functions_test.cpp + exprs/math_functions_test.cpp + exprs/topn_function_test.cpp + exprs/runtime_filter_test.cpp + exprs/bloom_filter_predicate_test.cpp + exprs/array_functions_test.cpp + exprs/quantile_function_test.cpp + exprs/window_funnel_test.cpp +) +set(GEO_TEST_FILES + geo/wkt_parse_test.cpp + geo/geo_functions_test.cpp + geo/geo_types_test.cpp +) +set(GUTIL_TEST_FILES + gutil/strings/numbers_test.cpp +) +set(HTTP_TEST_FILES + http/message_body_sink_test.cpp + http/http_utils_test.cpp + http/http_client_test.cpp + # TODO this will overide HttpChannel and make other test failed + # http/stream_load_test.cpp + # http/metrics_action_test.cpp +) +set(OLAP_TEST_FILES + olap/engine_storage_migration_task_test.cpp + olap/schema_change_test.cpp + olap/timestamped_version_tracker_test.cpp + olap/tablet_schema_helper.cpp + olap/delta_writer_test.cpp + olap/delete_handler_test.cpp + olap/row_block_test.cpp + olap/row_block_v2_test.cpp + olap/bit_field_test.cpp + olap/byte_buffer_test.cpp + olap/run_length_byte_test.cpp + olap/run_length_integer_test.cpp + olap/stream_index_test.cpp + olap/lru_cache_test.cpp + olap/bloom_filter_test.cpp + olap/bloom_filter_column_predicate_test.cpp + olap/bloom_filter_index_test.cpp + olap/comparison_predicate_test.cpp + olap/in_list_predicate_test.cpp + olap/null_predicate_test.cpp + olap/file_helper_test.cpp + olap/file_utils_test.cpp + olap/column_reader_test.cpp + olap/cumulative_compaction_policy_test.cpp + olap/row_cursor_test.cpp + olap/skiplist_test.cpp + olap/serialize_test.cpp + olap/olap_meta_test.cpp + olap/decimal12_test.cpp + olap/column_vector_test.cpp + olap/storage_types_test.cpp + olap/aggregate_func_test.cpp + olap/rowset/segment_v2/bitshuffle_page_test.cpp + olap/rowset/segment_v2/plain_page_test.cpp + olap/rowset/segment_v2/bitmap_index_test.cpp + olap/rowset/segment_v2/binary_plain_page_test.cpp + olap/rowset/segment_v2/binary_prefix_page_test.cpp + olap/rowset/segment_v2/column_reader_writer_test.cpp + olap/rowset/segment_v2/encoding_info_test.cpp + olap/rowset/segment_v2/ordinal_page_index_test.cpp + olap/rowset/segment_v2/rle_page_test.cpp + olap/rowset/segment_v2/binary_dict_page_test.cpp + olap/rowset/segment_v2/segment_test.cpp + olap/rowset/segment_v2/row_ranges_test.cpp + olap/rowset/segment_v2/frame_of_reference_page_test.cpp + olap/rowset/segment_v2/block_bloom_filter_test.cpp + olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp + olap/rowset/segment_v2/zone_map_index_test.cpp + olap/tablet_meta_test.cpp + olap/tablet_meta_manager_test.cpp + olap/tablet_mgr_test.cpp + olap/tablet_test.cpp + olap/rowset/rowset_meta_manager_test.cpp + olap/rowset/rowset_meta_test.cpp + olap/rowset/alpha_rowset_test.cpp + olap/rowset/beta_rowset_test.cpp + olap/rowset/unique_rowset_id_generator_test.cpp + olap/txn_manager_test.cpp + olap/generic_iterators_test.cpp + olap/key_coder_test.cpp + olap/short_key_index_test.cpp + olap/page_cache_test.cpp + olap/hll_test.cpp + olap/selection_vector_test.cpp + olap/block_column_predicate_test.cpp + olap/options_test.cpp + olap/fs/file_block_manager_test.cpp + olap/common_test.cpp + # olap/rowset/rowset_converter_test.cpp + # olap/memtable_flush_executor_test.cpp + # olap/push_handler_test.cpp +) +set(PLUGIN_TEST_FILES + # plugin/plugin_zip_test.cpp + # plugin/plugin_loader_test.cpp + # plugin/plugin_mgr_test.cpp +) +set(RUNTIME_TEST_FILES + # runtime/buffered_tuple_stream_test.cpp + # runtime/sorter_test.cpp + # runtime/buffer_control_block_test.cpp + # runtime/result_buffer_mgr_test.cpp + # runtime/result_sink_test.cpp + # runtime/data_stream_test.cpp + # runtime/parallel_executor_test.cpp + # runtime/datetime_value_test.cpp + # runtime/dpp_sink_internal_test.cpp + # runtime/dpp_sink_test.cpp + # runtime/data_spliter_test.cpp + # runtime/etl_job_mgr_test.cpp + # runtime/tmp_file_mgr_test.cpp + # runtime/disk_io_mgr_test.cpp + # runtime/thread_resource_mgr_test.cpp + # runtime/qsorter_test.cpp + # runtime/buffered_block_mgr2_test.cpp + # runtime/buffered_tuple_stream2_test.cpp + # runtime/export_task_mgr_test.cpp + # runtime/minidump_test.cpp + runtime/mem_pool_test.cpp + runtime/free_list_test.cpp + runtime/string_buffer_test.cpp + runtime/decimalv2_value_test.cpp + runtime/large_int_value_test.cpp + runtime/string_value_test.cpp + runtime/fragment_mgr_test.cpp + runtime/mem_limit_test.cpp + runtime/stream_load_pipe_test.cpp + # TODO this test will override DeltaWriter, will make other test failed + # runtime/load_channel_mgr_test.cpp + runtime/snapshot_loader_test.cpp + runtime/user_function_cache_test.cpp + runtime/kafka_consumer_pipe_test.cpp + runtime/routine_load_task_executor_test.cpp + runtime/small_file_mgr_test.cpp + runtime/heartbeat_flags_test.cpp + runtime/result_queue_mgr_test.cpp + runtime/memory_scratch_sink_test.cpp + runtime/test_env.cc + runtime/external_scan_context_mgr_test.cpp + runtime/memory/chunk_allocator_test.cpp + runtime/memory/system_allocator_test.cpp + runtime/cache/partition_cache_test.cpp + runtime/collection_value_test.cpp + runtime/array_test.cpp +) +set(TESTUTIL_TEST_FILES + testutil/test_util.cpp + testutil/array_utils.cpp + testutil/desc_tbl_builder.cc + testutil/function_utils.cpp + testutil/run_all_tests.cpp +) +set(UDF_TEST_FILES + # udf/udf_test.cpp + # udf/uda_test.cpp +) +set(UTIL_TEST_FILES + util/bit_util_test.cpp + util/brpc_client_cache_test.cpp + util/path_trie_test.cpp + util/coding_test.cpp + util/crc32c_test.cpp + util/lru_cache_util_test.cpp + util/filesystem_util_test.cpp + util/internal_queue_test.cpp + util/cidr_test.cpp + util/metrics_test.cpp + util/doris_metrics_test.cpp + util/system_metrics_test.cpp + util/string_util_test.cpp + util/string_parser_test.cpp + util/core_local_test.cpp + util/json_util_test.cpp + util/byte_buffer2_test.cpp + util/uid_util_test.cpp + util/encryption_util_test.cpp + util/md5_test.cpp + util/sm3_test.cpp + util/bitmap_test.cpp + util/bitmap_value_test.cpp + util/faststring_test.cpp + util/rle_encoding_test.cpp + util/tdigest_test.cpp + util/block_compression_test.cpp + util/arrow/arrow_row_block_test.cpp + util/arrow/arrow_row_batch_test.cpp + util/arrow/arrow_work_flow_test.cpp + util/counter_cond_variable_test.cpp + util/frame_of_reference_coding_test.cpp + util/bit_stream_utils_test.cpp + util/radix_sort_test.cpp + util/zip_util_test.cpp + util/utf8_check_test.cpp + util/cgroup_util_test.cpp + util/path_util_test.cpp + util/file_cache_test.cpp + util/parse_util_test.cpp + util/countdown_latch_test.cpp + util/monotime_test.cpp + util/scoped_cleanup_test.cpp + util/thread_test.cpp + util/threadpool_test.cpp + util/mysql_row_buffer_test.cpp + util/trace_test.cpp + util/easy_json-test.cpp + util/http_channel_test.cpp + util/histogram_test.cpp + util/s3_uri_test.cpp + util/s3_storage_backend_test.cpp + util/broker_storage_backend_test.cpp + util/sort_heap_test.cpp + util/counts_test.cpp + util/date_func_test.cpp + util/tuple_row_zorder_compare_test.cpp + util/array_parser_test.cpp + util/quantile_state_test.cpp +) +set(VEC_TEST_FILES + vec/aggregate_functions/agg_test.cpp + vec/aggregate_functions/agg_min_max_test.cpp + vec/aggregate_functions/vec_window_funnel_test.cpp + vec/core/block_test.cpp + vec/core/column_array_test.cpp + vec/core/column_complex_test.cpp + vec/core/column_nullable_test.cpp + vec/exec/vgeneric_iterators_test.cpp + vec/exprs/vexpr_test.cpp + vec/function/function_array_element_test.cpp + vec/function/function_array_index_test.cpp + vec/function/function_bitmap_test.cpp + vec/function/function_comparison_test.cpp + vec/function/function_hash_test.cpp + vec/function/function_math_test.cpp + vec/function/function_string_test.cpp + vec/function/function_time_test.cpp + vec/function/function_ifnull_test.cpp + vec/function/function_nullif_test.cpp + vec/function/function_like_test.cpp + vec/function/function_arithmetic_test.cpp + vec/function/function_json_test.cpp + vec/function/function_geo_test.cpp + vec/function/function_test_util.cpp + vec/function/table_function_test.cpp + vec/runtime/vdata_stream_test.cpp +) + +add_executable(doris_be_test + ${AGENT_TEST_FILES} + ${COMMON_TEST_FILES} + ${ENV_TEST_FILES} + ${EXEC_TEST_FILES} + ${EXPRS_TEST_FILES} + ${GEO_TEST_FILES} + ${GUTIL_TEST_FILES} + ${HTTP_TEST_FILES} + ${OLAP_TEST_FILES} + ${PLUGIN_TEST_FILES} + ${RUNTIME_TEST_FILES} + ${TESTUTIL_TEST_FILES} + ${UDF_TEST_FILES} + ${UTIL_TEST_FILES} + ${VEC_TEST_FILES} +) + +target_link_libraries(doris_be_test ${TEST_LINK_LIBS}) +set_target_properties(doris_be_test PROPERTIES COMPILE_FLAGS "-fno-access-control" ENABLE_EXPORTS 1) + +add_executable(benchmark_tool + tools/benchmark_tool.cpp + testutil/test_util.cpp + olap/tablet_schema_helper.cpp +) + +target_link_libraries(benchmark_tool ${TEST_LINK_LIBS}) +set_target_properties(benchmark_tool PROPERTIES COMPILE_FLAGS "-fno-access-control") diff --git a/be/test/agent/CMakeLists.txt b/be/test/agent/CMakeLists.txt deleted file mode 100644 index 5f88055a9f..0000000000 --- a/be/test/agent/CMakeLists.txt +++ /dev/null @@ -1,27 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/agent") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/agent") - -#ADD_BE_TEST(agent_server_test) -#ADD_BE_TEST(cgroups_mgr_test) -#ADD_BE_TEST(heartbeat_server_test) -ADD_BE_TEST(utils_test) diff --git a/be/test/agent/agent_server_test.cpp b/be/test/agent/agent_server_test.cpp index dc5d282c94..0f2d4d240a 100644 --- a/be/test/agent/agent_server_test.cpp +++ b/be/test/agent/agent_server_test.cpp @@ -177,14 +177,3 @@ TEST(ReleaseSnapshotTest, TestReleaseSnapshot) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/agent/cgroups_mgr_test.cpp b/be/test/agent/cgroups_mgr_test.cpp index bf27a5120d..9e5e002d29 100644 --- a/be/test/agent/cgroups_mgr_test.cpp +++ b/be/test/agent/cgroups_mgr_test.cpp @@ -42,9 +42,9 @@ class CgroupsMgrTest : public testing::Test { public: // create a mock cgroup folder static void SetUpTestCase() { - ASSERT_TRUE(std::filesystem::remove_all(_s_cgroup_path)); + EXPECT_TRUE(std::filesystem::remove_all(_s_cgroup_path)); // create a mock cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_cgroup_path)); + EXPECT_TRUE(std::filesystem::create_directory(_s_cgroup_path)); std::vector paths; paths.emplace_back(config::storage_root_path, -1); @@ -52,11 +52,11 @@ public: doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); } // delete the mock cgroup folder - static void TearDownTestCase() { ASSERT_TRUE(std::filesystem::remove_all(_s_cgroup_path)); } + static void TearDownTestCase() { EXPECT_TRUE(std::filesystem::remove_all(_s_cgroup_path)); } // test if a file contains specific number static bool does_contain_number(const std::string& file_path, int32_t number) { @@ -80,28 +80,28 @@ CgroupsMgr CgroupsMgrTest::_s_cgroups_mgr(nullptr, CgroupsMgrTest::_s_cgroup_pat TEST_F(CgroupsMgrTest, TestIsDirectory) { // test folder exist bool exist = _s_cgroups_mgr.is_directory(CgroupsMgrTest::_s_cgroup_path.c_str()); - ASSERT_TRUE(exist); + EXPECT_TRUE(exist); // test folder not exist bool not_exist = _s_cgroups_mgr.is_directory("./abc"); - ASSERT_FALSE(not_exist); + EXPECT_FALSE(not_exist); // test file exist, but not folder bool not_folder = _s_cgroups_mgr.is_directory("/etc/profile"); - ASSERT_FALSE(not_folder); + EXPECT_FALSE(not_folder); } TEST_F(CgroupsMgrTest, TestIsFileExist) { // test file exist bool exist = _s_cgroups_mgr.is_file_exist(CgroupsMgrTest::_s_cgroup_path.c_str()); - ASSERT_TRUE(exist); + EXPECT_TRUE(exist); // test file not exist bool not_exist = _s_cgroups_mgr.is_file_exist("./abc"); - ASSERT_FALSE(not_exist); + EXPECT_FALSE(not_exist); } TEST_F(CgroupsMgrTest, TestInitCgroups) { // test for task file not exist Status op_status = _s_cgroups_mgr.init_cgroups(); - ASSERT_EQ(Status::DORIS_ERROR, op_status); + EXPECT_EQ(Status::DORIS_ERROR, op_status); // create task file, then init should success std::string task_file_path = _s_cgroup_path + "/tasks"; @@ -110,51 +110,51 @@ TEST_F(CgroupsMgrTest, TestInitCgroups) { outfile.close(); // create a mock user under cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei")); + EXPECT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei")); std::ofstream user_out_file(_s_cgroup_path + "/yiguolei/tasks"); user_out_file << 123 << std::endl; user_out_file.close(); // create a mock user group under cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei/low")); + EXPECT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei/low")); std::ofstream group_out_file(CgroupsMgrTest::_s_cgroup_path + "/yiguolei/low/tasks"); group_out_file << 456 << std::endl; group_out_file.close(); op_status = _s_cgroups_mgr.init_cgroups(); // init should be successful - ASSERT_EQ(Status::OK(), op_status); + EXPECT_EQ(Status::OK(), op_status); // all tasks should be migrated to root cgroup path - ASSERT_TRUE(does_contain_number(task_file_path, 1111111)); - ASSERT_TRUE(does_contain_number(task_file_path, 123)); - ASSERT_TRUE(does_contain_number(task_file_path, 456)); + EXPECT_TRUE(does_contain_number(task_file_path, 1111111)); + EXPECT_TRUE(does_contain_number(task_file_path, 123)); + EXPECT_TRUE(does_contain_number(task_file_path, 456)); } TEST_F(CgroupsMgrTest, TestAssignThreadToCgroups) { // default cgroup not exist, so that assign to an unknown user will fail Status op_status = _s_cgroups_mgr.assign_thread_to_cgroups(111, "abc", "low"); - ASSERT_EQ(Status::DORIS_ERROR, op_status); + EXPECT_EQ(Status::DORIS_ERROR, op_status); // user cgroup exist // create a mock user under cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei2")); + EXPECT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei2")); std::ofstream user_out_file(_s_cgroup_path + "/yiguolei2/tasks"); user_out_file << 123 << std::endl; user_out_file.close(); op_status = _s_cgroups_mgr.assign_thread_to_cgroups(111, "yiguolei2", "aaaa"); - ASSERT_EQ(Status::OK(), op_status); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei2/tasks", 111)); + EXPECT_EQ(Status::OK(), op_status); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei2/tasks", 111)); // user,level cgroup exist // create a mock user group under cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei2/low")); + EXPECT_TRUE(std::filesystem::create_directory(_s_cgroup_path + "/yiguolei2/low")); std::ofstream group_out_file(_s_cgroup_path + "/yiguolei2/low/tasks"); group_out_file << 456 << std::endl; group_out_file.close(); op_status = _s_cgroups_mgr.assign_thread_to_cgroups(111, "yiguolei2", "low"); - ASSERT_EQ(Status::OK(), op_status); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei2/low/tasks", 111)); + EXPECT_EQ(Status::OK(), op_status); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei2/low/tasks", 111)); } TEST_F(CgroupsMgrTest, TestModifyUserCgroups) { @@ -165,10 +165,10 @@ TEST_F(CgroupsMgrTest, TestModifyUserCgroups) { std::string user_name = "user_modify"; Status op_status = _s_cgroups_mgr.modify_user_cgroups(user_name, user_share, level_share); - ASSERT_EQ(Status::OK(), op_status); + EXPECT_EQ(Status::OK(), op_status); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/user_modify/cpu.shares", 100)); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/user_modify/low/cpu.shares", 100)); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/user_modify/cpu.shares", 100)); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/user_modify/low/cpu.shares", 100)); } TEST_F(CgroupsMgrTest, TestUpdateLocalCgroups) { @@ -186,23 +186,17 @@ TEST_F(CgroupsMgrTest, TestUpdateLocalCgroups) { user_resource_result.resourceByUser["yiguolei3"] = user_resource; Status op_status = _s_cgroups_mgr.update_local_cgroups(user_resource_result); - ASSERT_EQ(Status::OK(), op_status); - ASSERT_EQ(2, _s_cgroups_mgr._cur_version); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/cpu.shares", 100)); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/low/cpu.shares", 123)); - ASSERT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/normal/cpu.shares", 234)); + EXPECT_EQ(Status::OK(), op_status); + EXPECT_EQ(2, _s_cgroups_mgr._cur_version); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/cpu.shares", 100)); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/low/cpu.shares", 123)); + EXPECT_TRUE(does_contain_number(_s_cgroup_path + "/yiguolei3/normal/cpu.shares", 234)); } TEST_F(CgroupsMgrTest, TestRelocateTasks) { // create a source cgroup, add some taskid into it Status op_status = _s_cgroups_mgr.relocate_tasks("/a/b/c/d", _s_cgroup_path); - ASSERT_EQ(Status::DORIS_ERROR, op_status); + EXPECT_EQ(Status::DORIS_ERROR, op_status); } } // namespace doris - -int main(int argc, char** argv) { - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/agent/heartbeat_server_test.cpp b/be/test/agent/heartbeat_server_test.cpp index b27fb6c64d..4adeddf6f2 100644 --- a/be/test/agent/heartbeat_server_test.cpp +++ b/be/test/agent/heartbeat_server_test.cpp @@ -79,14 +79,3 @@ TEST(HeartbeatTest, TestHeartbeat) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/agent/utils_test.cpp b/be/test/agent/utils_test.cpp index ddb3dc0420..700b0fd5cf 100644 --- a/be/test/agent/utils_test.cpp +++ b/be/test/agent/utils_test.cpp @@ -34,13 +34,7 @@ namespace doris { TEST(AgentUtilsTest, Test) { std::string host_name = BackendOptions::get_localhost(); int cnt = std::count(host_name.begin(), host_name.end(), '.'); - ASSERT_EQ(3, cnt); + EXPECT_EQ(3, cnt); } } // namespace doris - -int main(int argc, char** argv) { - doris::BackendOptions::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/common/CMakeLists.txt b/be/test/common/CMakeLists.txt deleted file mode 100644 index 1b2dda8908..0000000000 --- a/be/test/common/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/common") - -ADD_BE_TEST(resource_tls_test) -ADD_BE_TEST(status_test) -ADD_BE_TEST(config_test) -ADD_BE_TEST(config_validator_test) diff --git a/be/test/common/config_test.cpp b/be/test/common/config_test.cpp index 7d6eb42b14..e835d8313b 100644 --- a/be/test/common/config_test.cpp +++ b/be/test/common/config_test.cpp @@ -45,12 +45,12 @@ TEST_F(ConfigTest, DumpAllConfigs) { CONF_Int64s(cfg_std_vector_int64_t, "4294967296123,4294967296234,4294967296345"); CONF_Strings(cfg_std_vector_std_string, "doris,config,test,string"); - ASSERT_TRUE(config::init(nullptr, true)); + EXPECT_TRUE(config::init(nullptr, true)); std::stringstream ss; for (const auto& it : *(config::full_conf_map)) { ss << it.first << "=" << it.second << std::endl; } - ASSERT_EQ( + EXPECT_EQ( "cfg_bool_false=0\ncfg_bool_true=1\ncfg_double=123.456\ncfg_int16_t=2561\ncfg_int32_t=" "65536123\ncfg_int64_t=4294967296123\ncfg_std_string=doris_config_test_string\ncfg_std_" "vector_bool=1, 0, 1\ncfg_std_vector_double=123.456, 123.457, " @@ -69,72 +69,67 @@ TEST_F(ConfigTest, UpdateConfigs) { CONF_mInt64(cfg_int64_t, "4294967296123"); CONF_String(cfg_std_string, "doris_config_test_string"); - ASSERT_TRUE(config::init(nullptr, true)); + EXPECT_TRUE(config::init(nullptr, true)); // bool - ASSERT_FALSE(cfg_bool); - ASSERT_TRUE(config::set_config("cfg_bool", "true").ok()); - ASSERT_TRUE(cfg_bool); + EXPECT_FALSE(cfg_bool); + EXPECT_TRUE(config::set_config("cfg_bool", "true").ok()); + EXPECT_TRUE(cfg_bool); // double - ASSERT_EQ(cfg_double, 123.456); - ASSERT_TRUE(config::set_config("cfg_double", "654.321").ok()); - ASSERT_EQ(cfg_double, 654.321); + EXPECT_EQ(cfg_double, 123.456); + EXPECT_TRUE(config::set_config("cfg_double", "654.321").ok()); + EXPECT_EQ(cfg_double, 654.321); // int16 - ASSERT_EQ(cfg_int16_t, 2561); - ASSERT_TRUE(config::set_config("cfg_int16_t", "2562").ok()); - ASSERT_EQ(cfg_int16_t, 2562); + EXPECT_EQ(cfg_int16_t, 2561); + EXPECT_TRUE(config::set_config("cfg_int16_t", "2562").ok()); + EXPECT_EQ(cfg_int16_t, 2562); // int32 - ASSERT_EQ(cfg_int32_t, 65536123); - ASSERT_TRUE(config::set_config("cfg_int32_t", "65536124").ok()); - ASSERT_EQ(cfg_int32_t, 65536124); + EXPECT_EQ(cfg_int32_t, 65536123); + EXPECT_TRUE(config::set_config("cfg_int32_t", "65536124").ok()); + EXPECT_EQ(cfg_int32_t, 65536124); // int64 - ASSERT_EQ(cfg_int64_t, 4294967296123); - ASSERT_TRUE(config::set_config("cfg_int64_t", "4294967296124").ok()); - ASSERT_EQ(cfg_int64_t, 4294967296124); + EXPECT_EQ(cfg_int64_t, 4294967296123); + EXPECT_TRUE(config::set_config("cfg_int64_t", "4294967296124").ok()); + EXPECT_EQ(cfg_int64_t, 4294967296124); // not exist Status s = config::set_config("cfg_not_exist", "123"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Not found: 'cfg_not_exist' is not found"); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Not found: 'cfg_not_exist' is not found"); // immutable - ASSERT_TRUE(cfg_bool_immutable); + EXPECT_TRUE(cfg_bool_immutable); s = config::set_config("cfg_bool_immutable", "false"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Not supported: 'cfg_bool_immutable' is not support to modify"); - ASSERT_TRUE(cfg_bool_immutable); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Not supported: 'cfg_bool_immutable' is not support to modify"); + EXPECT_TRUE(cfg_bool_immutable); // convert error s = config::set_config("cfg_bool", "falseeee"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Invalid argument: convert 'falseeee' as bool failed"); - ASSERT_TRUE(cfg_bool); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Invalid argument: convert 'falseeee' as bool failed"); + EXPECT_TRUE(cfg_bool); s = config::set_config("cfg_double", ""); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Invalid argument: convert '' as double failed"); - ASSERT_EQ(cfg_double, 654.321); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Invalid argument: convert '' as double failed"); + EXPECT_EQ(cfg_double, 654.321); // convert error s = config::set_config("cfg_int32_t", "4294967296124"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Invalid argument: convert '4294967296124' as int32_t failed"); - ASSERT_EQ(cfg_int32_t, 65536124); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Invalid argument: convert '4294967296124' as int32_t failed"); + EXPECT_EQ(cfg_int32_t, 65536124); // not support s = config::set_config("cfg_std_string", "test"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Not supported: 'cfg_std_string' is not support to modify"); - ASSERT_EQ(cfg_std_string, "doris_config_test_string"); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Not supported: 'cfg_std_string' is not support to modify"); + EXPECT_EQ(cfg_std_string, "doris_config_test_string"); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/common/config_validator_test.cpp b/be/test/common/config_validator_test.cpp index 605f7cbb5a..ec8fa0fab5 100644 --- a/be/test/common/config_validator_test.cpp +++ b/be/test/common/config_validator_test.cpp @@ -27,33 +27,24 @@ namespace doris { using namespace config; CONF_mInt16(cfg_validator_1, "15"); -CONF_Validator(cfg_validator_1, [](int16_t config) -> bool { - return 0 <= config && config <= 10; -}); +CONF_Validator(cfg_validator_1, [](int16_t config) -> bool { return 0 <= config && config <= 10; }); CONF_mInt16(cfg_validator_2, "5"); -CONF_Validator(cfg_validator_2, [](int16_t config) -> bool { - return 0 <= config && config <= 10; -}); +CONF_Validator(cfg_validator_2, [](int16_t config) -> bool { return 0 <= config && config <= 10; }); TEST(ConfigValidatorTest, Validator) { - ASSERT_FALSE(config::init(nullptr, true)); + EXPECT_FALSE(config::init(nullptr, true)); config::Register::_s_field_map->erase("cfg_validator_1"); - ASSERT_TRUE(config::init(nullptr, true)); + EXPECT_TRUE(config::init(nullptr, true)); Status s = config::set_config("cfg_validator_2", "15"); - ASSERT_FALSE(s.ok()); - ASSERT_EQ(s.to_string(), "Invalid argument: validate cfg_validator_2=15 failed"); - ASSERT_EQ(cfg_validator_2, 5); + EXPECT_FALSE(s.ok()); + EXPECT_EQ(s.to_string(), "Invalid argument: validate cfg_validator_2=15 failed"); + EXPECT_EQ(cfg_validator_2, 5); s = config::set_config("cfg_validator_2", "8"); - ASSERT_TRUE(s.ok()); - ASSERT_EQ(cfg_validator_2, 8); + EXPECT_TRUE(s.ok()); + EXPECT_EQ(cfg_validator_2, 8); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/common/resource_tls_test.cpp b/be/test/common/resource_tls_test.cpp index a1fbc3cca8..8e9eeeeae7 100644 --- a/be/test/common/resource_tls_test.cpp +++ b/be/test/common/resource_tls_test.cpp @@ -28,31 +28,20 @@ namespace doris { class ResourceTlsTest : public testing::Test {}; TEST_F(ResourceTlsTest, EmptyTest) { - ASSERT_TRUE(ResourceTls::get_resource_tls() == nullptr); - ASSERT_TRUE(ResourceTls::set_resource_tls((TResourceInfo*)1) != 0); + EXPECT_TRUE(ResourceTls::get_resource_tls() == nullptr); + EXPECT_TRUE(ResourceTls::set_resource_tls((TResourceInfo*)1) != 0); } TEST_F(ResourceTlsTest, NormalTest) { ResourceTls::init(); - ASSERT_TRUE(ResourceTls::get_resource_tls() == nullptr); + EXPECT_TRUE(ResourceTls::get_resource_tls() == nullptr); TResourceInfo* info = new TResourceInfo(); info->user = "testUser"; info->group = "testGroup"; - ASSERT_TRUE(ResourceTls::set_resource_tls(info) == 0); + EXPECT_TRUE(ResourceTls::set_resource_tls(info) == 0); TResourceInfo* getInfo = ResourceTls::get_resource_tls(); - ASSERT_STREQ("testUser", getInfo->user.c_str()); - ASSERT_STREQ("testGroup", getInfo->group.c_str()); + EXPECT_STREQ("testUser", getInfo->user.c_str()); + EXPECT_STREQ("testGroup", getInfo->group.c_str()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/common/status_test.cpp b/be/test/common/status_test.cpp index df6afca325..f8d67666a6 100644 --- a/be/test/common/status_test.cpp +++ b/be/test/common/status_test.cpp @@ -29,52 +29,47 @@ class StatusTest : public testing::Test {}; TEST_F(StatusTest, OK) { // default Status st; - ASSERT_TRUE(st.ok()); - ASSERT_EQ("", st.get_error_msg()); - ASSERT_EQ("OK", st.to_string()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ("", st.get_error_msg()); + EXPECT_EQ("OK", st.to_string()); // copy { Status other = st; - ASSERT_TRUE(other.ok()); + EXPECT_TRUE(other.ok()); } // move assign st = Status(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // move construct { Status other = std::move(st); - ASSERT_TRUE(other.ok()); + EXPECT_TRUE(other.ok()); } } TEST_F(StatusTest, Error) { // default Status st = Status::InternalError("123"); - ASSERT_FALSE(st.ok()); - ASSERT_EQ("123", st.get_error_msg()); - ASSERT_EQ("Internal error: 123", st.to_string()); + EXPECT_FALSE(st.ok()); + EXPECT_EQ("123", st.get_error_msg()); + EXPECT_EQ("Internal error: 123", st.to_string()); // copy { Status other = st; - ASSERT_FALSE(other.ok()); - ASSERT_EQ("123", st.get_error_msg()); + EXPECT_FALSE(other.ok()); + EXPECT_EQ("123", st.get_error_msg()); } // move assign st = Status::InternalError("456"); - ASSERT_FALSE(st.ok()); - ASSERT_EQ("456", st.get_error_msg()); + EXPECT_FALSE(st.ok()); + EXPECT_EQ("456", st.get_error_msg()); // move construct { Status other = std::move(st); - ASSERT_FALSE(other.ok()); - ASSERT_EQ("456", other.get_error_msg()); - ASSERT_EQ("Internal error: 456", other.to_string()); + EXPECT_FALSE(other.ok()); + EXPECT_EQ("456", other.get_error_msg()); + EXPECT_EQ("Internal error: 456", other.to_string()); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/env/CMakeLists.txt b/be/test/env/CMakeLists.txt deleted file mode 100644 index 04d8893543..0000000000 --- a/be/test/env/CMakeLists.txt +++ /dev/null @@ -1,21 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/env") - -ADD_BE_TEST(env_posix_test) diff --git a/be/test/env/env_posix_test.cpp b/be/test/env/env_posix_test.cpp index 3570dc027c..f4343b7ba8 100644 --- a/be/test/env/env_posix_test.cpp +++ b/be/test/env/env_posix_test.cpp @@ -31,7 +31,7 @@ public: virtual ~EnvPosixTest() {} void SetUp() override { auto st = FileUtils::create_dir("./ut_dir/env_posix"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } void TearDown() override {} }; @@ -44,8 +44,8 @@ TEST_F(EnvPosixTest, file_path_desc) { path_desc_stream << path_desc << "/test" << "/" << 1; FilePathDesc dest_path_desc = path_desc_stream.path_desc(); - ASSERT_EQ("/local/test/1", dest_path_desc.filepath); - ASSERT_EQ("/remote/test/1", dest_path_desc.remote_path); + EXPECT_EQ("/local/test/1", dest_path_desc.filepath); + EXPECT_EQ("/remote/test/1", dest_path_desc.remote_path); } TEST_F(EnvPosixTest, random_access) { @@ -53,42 +53,42 @@ TEST_F(EnvPosixTest, random_access) { std::unique_ptr wfile; auto env = Env::Default(); auto st = env->new_writable_file(fname, &wfile); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->pre_allocate(1024); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // write data Slice field1("123456789"); st = wfile->append(field1); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::string buf; for (int i = 0; i < 100; ++i) { buf.push_back((char)i); } st = wfile->append(buf); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Slice abc("abc"); Slice bcd("bcd"); Slice slices[2] {abc, bcd}; st = wfile->appendv(slices, 2); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->flush(WritableFile::FLUSH_ASYNC); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->sync(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->close(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_EQ(115, wfile->size()); + EXPECT_EQ(115, wfile->size()); uint64_t size; st = env->get_file_size(fname, &size); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(115, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(115, size); { char mem[1024]; std::unique_ptr rfile; st = env->new_random_access_file(fname, &rfile); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Slice slice1(mem, 9); Slice slice2(mem + 9, 100); @@ -96,18 +96,18 @@ TEST_F(EnvPosixTest, random_access) { Slice read_slices[3] {slice1, slice2, slice3}; st = rfile->readv_at(0, read_slices, 3); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("123456789", std::string(slice1.data, slice1.size).c_str()); - ASSERT_STREQ("abc", std::string(slice3.data, slice3.size).c_str()); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("123456789", std::string(slice1.data, slice1.size).c_str()); + EXPECT_STREQ("abc", std::string(slice3.data, slice3.size).c_str()); Slice slice4(mem, 3); st = rfile->read_at(112, &slice4); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bcd", std::string(slice4.data, slice4.size).c_str()); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bcd", std::string(slice4.data, slice4.size).c_str()); // end of file st = rfile->read_at(114, &slice4); - ASSERT_EQ(TStatusCode::END_OF_FILE, st.code()); + EXPECT_EQ(TStatusCode::END_OF_FILE, st.code()); LOG(INFO) << "st=" << st.to_string(); } } @@ -117,45 +117,45 @@ TEST_F(EnvPosixTest, random_rw) { std::unique_ptr wfile; auto env = Env::Default(); auto st = env->new_random_rw_file(fname, &wfile); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // write data Slice field1("123456789"); st = wfile->write_at(0, field1); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::string buf; for (int i = 0; i < 100; ++i) { buf.push_back((char)i); } st = wfile->write_at(9, buf); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Slice abc("abc"); Slice bcd("bcd"); Slice slices[2] {abc, bcd}; st = wfile->writev_at(0, slices, 2); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint64_t size; st = wfile->size(&size); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(109, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(109, size); st = wfile->flush(RandomRWFile::FLUSH_ASYNC, 0, 0); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->sync(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = wfile->close(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = env->get_file_size(fname, &size); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(109, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(109, size); { char mem[1024]; std::unique_ptr rfile; RandomRWFileOptions opts; opts.mode = Env::MUST_EXIST; st = env->new_random_rw_file(opts, fname, &rfile); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Slice slice1(mem, 3); Slice slice2(mem + 3, 3); @@ -164,18 +164,18 @@ TEST_F(EnvPosixTest, random_rw) { Slice read_slices[3] {slice1, slice2, slice3}; st = rfile->readv_at(0, read_slices, 3); LOG(INFO) << st.to_string(); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("abc", std::string(slice1.data, slice1.size).c_str()); - ASSERT_STREQ("bcd", std::string(slice2.data, slice2.size).c_str()); - ASSERT_STREQ("789", std::string(slice3.data, slice3.size).c_str()); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("abc", std::string(slice1.data, slice1.size).c_str()); + EXPECT_STREQ("bcd", std::string(slice2.data, slice2.size).c_str()); + EXPECT_STREQ("789", std::string(slice3.data, slice3.size).c_str()); Slice slice4(mem, 100); st = rfile->read_at(9, slice4); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // end of file st = rfile->read_at(102, slice4); - ASSERT_EQ(TStatusCode::END_OF_FILE, st.code()); + EXPECT_EQ(TStatusCode::END_OF_FILE, st.code()); LOG(INFO) << "st=" << st.to_string(); } } @@ -184,41 +184,36 @@ TEST_F(EnvPosixTest, iterate_dir) { std::string dir_path = "./ut_dir/env_posix/iterate_dir"; FileUtils::remove_all(dir_path); auto st = Env::Default()->create_dir_if_missing(dir_path); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = Env::Default()->create_dir_if_missing(dir_path + "/abc"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = Env::Default()->create_dir_if_missing(dir_path + "/123"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); { std::vector children; st = Env::Default()->get_children(dir_path, &children); - ASSERT_EQ(4, children.size()); + EXPECT_EQ(4, children.size()); std::sort(children.begin(), children.end()); - ASSERT_STREQ(".", children[0].c_str()); - ASSERT_STREQ("..", children[1].c_str()); - ASSERT_STREQ("123", children[2].c_str()); - ASSERT_STREQ("abc", children[3].c_str()); + EXPECT_STREQ(".", children[0].c_str()); + EXPECT_STREQ("..", children[1].c_str()); + EXPECT_STREQ("123", children[2].c_str()); + EXPECT_STREQ("abc", children[3].c_str()); } { std::vector children; st = FileUtils::list_files(Env::Default(), dir_path, &children); - ASSERT_EQ(2, children.size()); + EXPECT_EQ(2, children.size()); std::sort(children.begin(), children.end()); - ASSERT_STREQ("123", children[0].c_str()); - ASSERT_STREQ("abc", children[1].c_str()); + EXPECT_STREQ("123", children[0].c_str()); + EXPECT_STREQ("abc", children[1].c_str()); } FileUtils::remove_all(dir_path); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/CMakeLists.txt b/be/test/exec/CMakeLists.txt deleted file mode 100644 index a22e5c24e1..0000000000 --- a/be/test/exec/CMakeLists.txt +++ /dev/null @@ -1,77 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/exec") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/exec") - -# TODO: why is this test disabled? -#ADD_BE_TEST(new_olap_scan_node_test) -#ADD_BE_TEST(pre_aggregation_node_test) -ADD_BE_TEST(hash_table_test) -# ADD_BE_TEST(partitioned_hash_table_test) -#ADD_BE_TEST(olap_scanner_test) -#ADD_BE_TEST(olap_meta_reader_test) -ADD_BE_TEST(olap_common_test) -#ADD_BE_TEST(olap_scan_node_test) -#ADD_BE_TEST(mysql_scan_node_test) -#ADD_BE_TEST(mysql_scanner_test) -#ADD_BE_TEST(csv_scanner_test) -#ADD_BE_TEST(csv_scan_node_test) -# ADD_BE_TEST(csv_scan_bench_test) -ADD_BE_TEST(json_scanner_test) -ADD_BE_TEST(json_scanner_with_jsonpath_test) -ADD_BE_TEST(parquet_scanner_test) -ADD_BE_TEST(orc_scanner_test) -ADD_BE_TEST(plain_text_line_reader_uncompressed_test) -ADD_BE_TEST(plain_text_line_reader_gzip_test) -ADD_BE_TEST(plain_text_line_reader_bzip_test) -ADD_BE_TEST(plain_text_line_reader_lz4frame_test) -if(DEFINED DORIS_WITH_LZO) -ADD_BE_TEST(plain_text_line_reader_lzop_test) -endif() -# ADD_BE_TEST(broker_reader_test) -ADD_BE_TEST(broker_scanner_test) -ADD_BE_TEST(broker_scan_node_test) -ADD_BE_TEST(tablet_info_test) -ADD_BE_TEST(tablet_sink_test) -ADD_BE_TEST(buffered_reader_test) -# ADD_BE_TEST(es_scan_node_test) -ADD_BE_TEST(es_http_scan_node_test) -ADD_BE_TEST(es_predicate_test) -ADD_BE_TEST(es_query_builder_test) -ADD_BE_TEST(es_scan_reader_test) -#ADD_BE_TEST(schema_scan_node_test) -#ADD_BE_TEST(unix_odbc_test) -#ADD_BE_TEST(schema_scanner_test) -##ADD_BE_TEST(set_executor_test) -#ADD_BE_TEST(schema_scanner/schema_authors_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_columns_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_create_table_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_open_tables_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_schemata_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_table_names_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_tables_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_variables_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_engines_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_collations_scanner_test) -#ADD_BE_TEST(schema_scanner/schema_charsets_scanner_test) -ADD_BE_TEST(s3_reader_test) -ADD_BE_TEST(multi_bytes_separator_test) -ADD_BE_TEST(hdfs_file_reader_test) diff --git a/be/test/exec/broker_reader_test.cpp b/be/test/exec/broker_reader_test.cpp index 017073a69f..c9f19279e4 100644 --- a/be/test/exec/broker_reader_test.cpp +++ b/be/test/exec/broker_reader_test.cpp @@ -61,7 +61,7 @@ TEST_F(BrokerReaderTest, normal) { std::string path = "hdfs://host:port/dir"; BrokerReader reader(_env, _addresses, _properties, path, 0); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint8_t buf[128 * 1024]; MonotonicStopWatch watch; watch.start(); @@ -70,22 +70,10 @@ TEST_F(BrokerReaderTest, normal) { while (!eof) { size_t buf_len = 128 * 1024; st = reader.read(buf, &buf_len, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); total_size += buf_len; } LOG(INFO) << "get from broker " << total_size << " bytes using " << watch.elapsed_time(); } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/broker_scan_node_test.cpp b/be/test/exec/broker_scan_node_test.cpp index 4c4c9f1a90..18128200ea 100644 --- a/be/test/exec/broker_scan_node_test.cpp +++ b/be/test/exec/broker_scan_node_test.cpp @@ -403,7 +403,7 @@ TEST_F(BrokerScanNodeTest, normal) { BrokerScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); auto status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // set scan range std::vector scan_ranges; @@ -421,7 +421,7 @@ TEST_F(BrokerScanNodeTest, normal) { range.file_type = TFileType::FILE_LOCAL; range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; range.splittable = true; - std::vector columns_from_path{"1"}; + std::vector columns_from_path {"1"}; range.__set_columns_from_path(columns_from_path); range.__set_num_of_columns_from_file(3); broker_scan_range.ranges.push_back(range); @@ -443,7 +443,7 @@ TEST_F(BrokerScanNodeTest, normal) { range.file_type = TFileType::FILE_LOCAL; range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; range.splittable = true; - std::vector columns_from_path{"2"}; + std::vector columns_from_path {"2"}; range.__set_columns_from_path(columns_from_path); range.__set_num_of_columns_from_file(3); broker_scan_range.ranges.push_back(range); @@ -456,25 +456,25 @@ TEST_F(BrokerScanNodeTest, normal) { scan_node.set_scan_ranges(scan_ranges); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Get batch RowBatch batch(scan_node.row_desc(), _runtime_state.batch_size()); bool eos = false; status = scan_node.get_next(&_runtime_state, &batch, &eos); - ASSERT_EQ(3, batch.num_rows()); - ASSERT_FALSE(eos); + EXPECT_EQ(3, batch.num_rows()); + EXPECT_FALSE(eos); batch.reset(); status = scan_node.get_next(&_runtime_state, &batch, &eos); - ASSERT_EQ(1, batch.num_rows()); - ASSERT_FALSE(eos); + EXPECT_EQ(1, batch.num_rows()); + EXPECT_FALSE(eos); batch.reset(); status = scan_node.get_next(&_runtime_state, &batch, &eos); - ASSERT_EQ(0, batch.num_rows()); - ASSERT_TRUE(eos); + EXPECT_EQ(0, batch.num_rows()); + EXPECT_TRUE(eos); scan_node.close(&_runtime_state); { @@ -485,14 +485,3 @@ TEST_F(BrokerScanNodeTest, normal) { } } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/broker_scanner_test.cpp b/be/test/exec/broker_scanner_test.cpp index 6bbb42740e..689e876754 100644 --- a/be/test/exec/broker_scanner_test.cpp +++ b/be/test/exec/broker_scanner_test.cpp @@ -68,7 +68,7 @@ private: DescriptorTbl* _desc_tbl; std::vector _addresses; ScannerCounter _counter; - std::vector _pre_filter; + std::vector _pre_filter; }; void BrokerScannerTest::init_desc_table() { @@ -358,9 +358,10 @@ TEST_F(BrokerScannerTest, normal) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -368,37 +369,37 @@ TEST_F(BrokerScannerTest, normal) { bool eof = false; // 1,2,3 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(1, *(int*)tuple->get_slot(0)); - ASSERT_EQ(2, *(int*)tuple->get_slot(4)); - ASSERT_EQ(3, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(1, *(int*)tuple->get_slot(0)); + EXPECT_EQ(2, *(int*)tuple->get_slot(4)); + EXPECT_EQ(3, *(int*)tuple->get_slot(8)); // 4,5,6 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(4, *(int*)tuple->get_slot(0)); - ASSERT_EQ(5, *(int*)tuple->get_slot(4)); - ASSERT_EQ(6, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(4, *(int*)tuple->get_slot(0)); + EXPECT_EQ(5, *(int*)tuple->get_slot(4)); + EXPECT_EQ(6, *(int*)tuple->get_slot(8)); // 7, 8, unqualitifed st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_FALSE(fill_tuple); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_FALSE(fill_tuple); // 8,9,10 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(8, *(int*)tuple->get_slot(0)); - ASSERT_EQ(9, *(int*)tuple->get_slot(4)); - ASSERT_EQ(10, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(8, *(int*)tuple->get_slot(0)); + EXPECT_EQ(9, *(int*)tuple->get_slot(4)); + EXPECT_EQ(10, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal2) { @@ -418,9 +419,10 @@ TEST_F(BrokerScannerTest, normal2) { range.size = 4; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -428,31 +430,31 @@ TEST_F(BrokerScannerTest, normal2) { bool eof = false; // 1,2,3 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(1, *(int*)tuple->get_slot(0)); - ASSERT_EQ(2, *(int*)tuple->get_slot(4)); - ASSERT_EQ(3, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(1, *(int*)tuple->get_slot(0)); + EXPECT_EQ(2, *(int*)tuple->get_slot(4)); + EXPECT_EQ(3, *(int*)tuple->get_slot(8)); // 3,4,5 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_TRUE(fill_tuple); - ASSERT_EQ(3, *(int*)tuple->get_slot(0)); - ASSERT_EQ(4, *(int*)tuple->get_slot(4)); - ASSERT_EQ(5, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_TRUE(fill_tuple); + EXPECT_EQ(3, *(int*)tuple->get_slot(0)); + EXPECT_EQ(4, *(int*)tuple->get_slot(4)); + EXPECT_EQ(5, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(fill_tuple); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(fill_tuple); + EXPECT_FALSE(eof); st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(fill_tuple); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(fill_tuple); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal3) { @@ -472,9 +474,10 @@ TEST_F(BrokerScannerTest, normal3) { range.size = 5; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -482,39 +485,39 @@ TEST_F(BrokerScannerTest, normal3) { bool eof = false; // 1,2,3 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(1, *(int*)tuple->get_slot(0)); - ASSERT_EQ(2, *(int*)tuple->get_slot(4)); - ASSERT_EQ(3, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(1, *(int*)tuple->get_slot(0)); + EXPECT_EQ(2, *(int*)tuple->get_slot(4)); + EXPECT_EQ(3, *(int*)tuple->get_slot(8)); // 3,4,5 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_TRUE(fill_tuple); - ASSERT_EQ(3, *(int*)tuple->get_slot(0)); - ASSERT_EQ(4, *(int*)tuple->get_slot(4)); - ASSERT_EQ(5, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_TRUE(fill_tuple); + EXPECT_EQ(3, *(int*)tuple->get_slot(0)); + EXPECT_EQ(4, *(int*)tuple->get_slot(4)); + EXPECT_EQ(5, *(int*)tuple->get_slot(8)); // first line of normal2_2.csv is 2,3, which is unqualified st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_FALSE(fill_tuple); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_FALSE(fill_tuple); // 4,5,6 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(4, *(int*)tuple->get_slot(0)); - ASSERT_EQ(5, *(int*)tuple->get_slot(4)); - ASSERT_EQ(6, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(4, *(int*)tuple->get_slot(0)); + EXPECT_EQ(5, *(int*)tuple->get_slot(4)); + EXPECT_EQ(6, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal4) { @@ -528,9 +531,10 @@ TEST_F(BrokerScannerTest, normal4) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -538,15 +542,15 @@ TEST_F(BrokerScannerTest, normal4) { bool eof = false; // 1,2,3 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(1, *(int*)tuple->get_slot(0)); - ASSERT_EQ(2, *(int*)tuple->get_slot(4)); - ASSERT_EQ(3, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(1, *(int*)tuple->get_slot(0)); + EXPECT_EQ(2, *(int*)tuple->get_slot(4)); + EXPECT_EQ(3, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal5) { @@ -560,9 +564,10 @@ TEST_F(BrokerScannerTest, normal5) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -570,8 +575,8 @@ TEST_F(BrokerScannerTest, normal5) { bool eof = false; // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal6) { @@ -585,9 +590,10 @@ TEST_F(BrokerScannerTest, normal6) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -595,15 +601,15 @@ TEST_F(BrokerScannerTest, normal6) { bool eof = false; // 4,5,6 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(4, *(int*)tuple->get_slot(0)); - ASSERT_EQ(5, *(int*)tuple->get_slot(4)); - ASSERT_EQ(6, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(4, *(int*)tuple->get_slot(0)); + EXPECT_EQ(5, *(int*)tuple->get_slot(4)); + EXPECT_EQ(6, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal7) { @@ -617,9 +623,10 @@ TEST_F(BrokerScannerTest, normal7) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -627,8 +634,8 @@ TEST_F(BrokerScannerTest, normal7) { bool eof = false; // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal8) { @@ -642,9 +649,10 @@ TEST_F(BrokerScannerTest, normal8) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -652,15 +660,15 @@ TEST_F(BrokerScannerTest, normal8) { bool eof = false; // 4,5,6 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(4, *(int*)tuple->get_slot(0)); - ASSERT_EQ(5, *(int*)tuple->get_slot(4)); - ASSERT_EQ(6, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(4, *(int*)tuple->get_slot(0)); + EXPECT_EQ(5, *(int*)tuple->get_slot(4)); + EXPECT_EQ(6, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, normal9) { @@ -674,9 +682,10 @@ TEST_F(BrokerScannerTest, normal9) { range.format_type = TFileFormatType::FORMAT_CSV_PLAIN; ranges.push_back(range); - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -684,8 +693,8 @@ TEST_F(BrokerScannerTest, normal9) { bool eof = false; // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BrokerScannerTest, multi_bytes_1) { @@ -703,9 +712,10 @@ TEST_F(BrokerScannerTest, multi_bytes_1) { _params.line_delimiter_str = "BB"; _params.column_separator_length = 4; _params.line_delimiter_length = 2; - BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, &_counter); + BrokerScanner scanner(&_runtime_state, _profile, _params, ranges, _addresses, _pre_filter, + &_counter); auto st = scanner.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); MemPool tuple_pool(_tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(20); @@ -713,33 +723,22 @@ TEST_F(BrokerScannerTest, multi_bytes_1) { bool eof = false; // 4,5,6 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(4, *(int*)tuple->get_slot(0)); - ASSERT_EQ(5, *(int*)tuple->get_slot(4)); - ASSERT_EQ(6, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(4, *(int*)tuple->get_slot(0)); + EXPECT_EQ(5, *(int*)tuple->get_slot(4)); + EXPECT_EQ(6, *(int*)tuple->get_slot(8)); // 1,2,3 st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(1, *(int*)tuple->get_slot(0)); - ASSERT_EQ(2, *(int*)tuple->get_slot(4)); - ASSERT_EQ(3, *(int*)tuple->get_slot(8)); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(1, *(int*)tuple->get_slot(0)); + EXPECT_EQ(2, *(int*)tuple->get_slot(4)); + EXPECT_EQ(3, *(int*)tuple->get_slot(8)); // end of file st = scanner.get_next(tuple, &tuple_pool, &eof, &fill_tuple); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/buffered_reader_test.cpp b/be/test/exec/buffered_reader_test.cpp index b984d9c5d5..7fe6c47fee 100644 --- a/be/test/exec/buffered_reader_test.cpp +++ b/be/test/exec/buffered_reader_test.cpp @@ -39,14 +39,14 @@ TEST_F(BufferedReaderTest, normal_use) { "./be/test/exec/test_data/buffered_reader/buffered_reader_test_file", 0); BufferedReader reader(&profile, file_reader, 1024); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint8_t buf[1024]; MonotonicStopWatch watch; watch.start(); int64_t read_length = 0; st = reader.readat(0, 1024, &read_length, buf); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(950, read_length); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(950, read_length); LOG(INFO) << "read bytes " << read_length << " using time " << watch.elapsed_time(); } @@ -57,40 +57,40 @@ TEST_F(BufferedReaderTest, test_validity) { "./be/test/exec/test_data/buffered_reader/buffered_reader_test_file.txt", 0); BufferedReader reader(&profile, file_reader, 64); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint8_t buf[10]; bool eof = false; int64_t buf_len = 10; int64_t read_length = 0; st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("vxzAbCdEfG", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("vxzAbCdEfG", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("hIj\n\nMnOpQ", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("hIj\n\nMnOpQ", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("rStUvWxYz\n", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("rStUvWxYz\n", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("IjKl", std::string((char*)buf, 4).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("IjKl", std::string((char*)buf, 4).c_str()); + EXPECT_FALSE(eof); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BufferedReaderTest, test_seek) { @@ -100,7 +100,7 @@ TEST_F(BufferedReaderTest, test_seek) { "./be/test/exec/test_data/buffered_reader/buffered_reader_test_file.txt", 0); BufferedReader reader(&profile, file_reader, 64); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint8_t buf[10]; bool eof = false; size_t buf_len = 10; @@ -108,41 +108,41 @@ TEST_F(BufferedReaderTest, test_seek) { // Seek to the end of the file st = reader.seek(45); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); // Seek to the beginning of the file st = reader.seek(0); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); // Seek to a wrong position st = reader.seek(-1); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); // Seek to a wrong position st = reader.seek(-1000); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhjlnprt", std::string((char*)buf, read_length).c_str()); + EXPECT_FALSE(eof); // Seek to a wrong position st = reader.seek(1000); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = reader.read(buf, buf_len, &read_length, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(BufferedReaderTest, test_miss) { @@ -152,36 +152,31 @@ TEST_F(BufferedReaderTest, test_miss) { "./be/test/exec/test_data/buffered_reader/buffered_reader_test_file.txt", 0); BufferedReader reader(&profile, file_reader, 64); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint8_t buf[128]; int64_t bytes_read; st = reader.readat(20, 10, &bytes_read, buf); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("hIj\n\nMnOpQ", std::string((char*)buf, (size_t)bytes_read).c_str()); - ASSERT_EQ(10, bytes_read); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("hIj\n\nMnOpQ", std::string((char*)buf, (size_t)bytes_read).c_str()); + EXPECT_EQ(10, bytes_read); st = reader.readat(0, 5, &bytes_read, buf); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhj", std::string((char*)buf, (size_t)bytes_read).c_str()); - ASSERT_EQ(5, bytes_read); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhj", std::string((char*)buf, (size_t)bytes_read).c_str()); + EXPECT_EQ(5, bytes_read); st = reader.readat(5, 10, &bytes_read, buf); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("lnprtvxzAb", std::string((char*)buf, (size_t)bytes_read).c_str()); - ASSERT_EQ(10, bytes_read); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("lnprtvxzAb", std::string((char*)buf, (size_t)bytes_read).c_str()); + EXPECT_EQ(10, bytes_read); // if requested length is larger than the capacity of buffer, do not // need to copy the character into local buffer. st = reader.readat(0, 128, &bytes_read, buf); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("bdfhjlnprt", std::string((char*)buf, 10).c_str()); - ASSERT_EQ(45, bytes_read); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("bdfhjlnprt", std::string((char*)buf, 10).c_str()); + EXPECT_EQ(45, bytes_read); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/csv_scan_bench_test.cpp b/be/test/exec/csv_scan_bench_test.cpp index 2756ab36d9..d7c6e2200d 100644 --- a/be/test/exec/csv_scan_bench_test.cpp +++ b/be/test/exec/csv_scan_bench_test.cpp @@ -297,10 +297,10 @@ void CsvScanNodeBenchTest::init_desc_tbl() { TEST_F(CsvScanNodeBenchTest, NormalUse) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; @@ -308,37 +308,19 @@ TEST_F(CsvScanNodeBenchTest, NormalUse) { // RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); RowBatch row_batch(scan_node._row_descriptor, 1024); status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - // ASSERT_TRUE(num > 0); - // std::cout << "num: " << num << std::endl; + // EXPECT_TRUE(num > 0); } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); { std::stringstream ss; scan_node.runtime_profile()->pretty_print(&ss); LOG(WARNING) << ss.str(); - std::cout << ss.str() << std::endl; } } } // end namespace doris - -int main(int argc, char** argv) { - ProfilerStart("profile_scan_bench"); - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - RUN_ALL_TESTS(); - - ProfilerStop(); - return 0; -} diff --git a/be/test/exec/csv_scan_node_test.cpp b/be/test/exec/csv_scan_node_test.cpp index f60d3172a3..929b5f355f 100644 --- a/be/test/exec/csv_scan_node_test.cpp +++ b/be/test/exec/csv_scan_node_test.cpp @@ -244,35 +244,31 @@ TEST_F(CsvScanNodeTest, NormalUse) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - std::cout << "num: " << num << std::endl; - ASSERT_EQ(num, 6); + EXPECT_EQ(num, 6); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); - // LOG(WARNING) << "input row[" << i << "]: " << print_row(row, scan_node._row_descriptor); - std::cout << "input row: " << print_row(row, scan_node._row_descriptor) << std::endl; - if (i == 0) { - ASSERT_EQ(std::string("[(1 -12345.67891 2015-04-20 abc\0\0)]", 35), + EXPECT_EQ(std::string("[(1 -12345.67891 2015-04-20 abc\0\0)]", 35), print_row(row, scan_node._row_descriptor)); } } } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); } TEST_F(CsvScanNodeTest, continuousDelim) { @@ -282,35 +278,31 @@ TEST_F(CsvScanNodeTest, continuousDelim) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - std::cout << "num: " << num << std::endl; - ASSERT_EQ(num, 1); + EXPECT_EQ(num, 1); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); - // LOG(WARNING) << "input row[" << i << "]: " << print_row(row, scan_node._row_descriptor); - std::cout << "input row: " << print_row(row, scan_node._row_descriptor) << std::endl; - if (i == 0) { - ASSERT_EQ(std::string("[(1 -12345.67891 2015-04-20 \0\0\0\0\0)]", 35), + EXPECT_EQ(std::string("[(1 -12345.67891 2015-04-20 \0\0\0\0\0)]", 35), print_row(row, scan_node._row_descriptor)); } } } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); } TEST_F(CsvScanNodeTest, wrong_decimal_format_test) { @@ -320,25 +312,24 @@ TEST_F(CsvScanNodeTest, wrong_decimal_format_test) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - std::cout << "num: " << num << std::endl; - ASSERT_EQ(0, num); + EXPECT_EQ(0, num); } // Failed because reach max_filter_ratio - ASSERT_TRUE(!scan_node.close(_state).ok()); + EXPECT_TRUE(!scan_node.close(_state).ok()); } TEST_F(CsvScanNodeTest, fill_fix_len_stringi_test) { @@ -348,41 +339,38 @@ TEST_F(CsvScanNodeTest, fill_fix_len_stringi_test) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - std::cout << "num: " << num << std::endl; - ASSERT_TRUE(num > 0); + EXPECT_TRUE(num > 0); // 1,2015-04-20,12345.67891,abcdefg for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); LOG(WARNING) << "input row[" << i << "]: " << print_row(row, scan_node._row_descriptor); - std::cout << "input row: " << print_row(row, scan_node._row_descriptor) << std::endl; if (i == 0) { - ASSERT_EQ(std::string("[(1 12345.67891 2015-04-20 ab\0\0\0)]", 34), + EXPECT_EQ(std::string("[(1 12345.67891 2015-04-20 ab\0\0\0)]", 34), print_row(row, scan_node._row_descriptor)); Tuple* tuple = row->get_tuple(0); StringValue* str_slot = tuple->get_string_slot(_t_desc_table.slotDescriptors[3].byteOffset); - std::cout << "str_slot len: " << str_slot->len << std::endl; - ASSERT_EQ(5, str_slot->len); + EXPECT_EQ(5, str_slot->len); } } } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); } TEST_F(CsvScanNodeTest, wrong_fix_len_string_format_test) { @@ -392,25 +380,24 @@ TEST_F(CsvScanNodeTest, wrong_fix_len_string_format_test) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - std::cout << "num: " << num << std::endl; - ASSERT_EQ(0, num); + EXPECT_EQ(0, num); } // Failed because reach max_filter_ratio - ASSERT_TRUE(!scan_node.close(_state).ok()); + EXPECT_TRUE(!scan_node.close(_state).ok()); } // To be added test case @@ -420,21 +407,3 @@ TEST_F(CsvScanNodeTest, wrong_fix_len_string_format_test) { // 4. max_filter_ratio } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::config::read_size = 8388608; - doris::config::min_buffer_size = 1024; - - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::CpuInfo::init(); - doris::DiskInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/csv_scanner_test.cpp b/be/test/exec/csv_scanner_test.cpp index fa20d538b1..846618518a 100644 --- a/be/test/exec/csv_scanner_test.cpp +++ b/be/test/exec/csv_scanner_test.cpp @@ -51,12 +51,12 @@ void CsvScannerTest::init() { TEST_F(CsvScannerTest, normal_use) { CsvScanner scanner(_file_paths); Status status = scanner.open(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string line_str; bool eos = false; status = scanner.get_next_row(&line_str, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); while (!eos) { status = scanner.get_next_row(&line_str, &eos); @@ -64,7 +64,7 @@ TEST_F(CsvScannerTest, normal_use) { if (eos) { break; } - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); LOG(WARNING) << line_str; } @@ -78,23 +78,12 @@ TEST_F(CsvScannerTest, no_exist_files) { CsvScanner scanner(no_exist_files); Status status = scanner.open(); // check until 'get_next_row()' - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string line_str; bool eos = false; status = scanner.get_next_row(&line_str, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/es_http_scan_node_test.cpp b/be/test/exec/es_http_scan_node_test.cpp index 17b2d4c983..fdcbb89426 100644 --- a/be/test/exec/es_http_scan_node_test.cpp +++ b/be/test/exec/es_http_scan_node_test.cpp @@ -107,10 +107,10 @@ protected: TEST_F(EsHttpScanNodeTest, normal_use) { EsHttpScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.init(_tnode, &_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // scan range TEsScanRange es_scan_range; @@ -131,18 +131,13 @@ TEST_F(EsHttpScanNodeTest, normal_use) { scan_ranges.push_back(scan_range_params); status = scan_node.set_scan_ranges(scan_ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.close(&_runtime_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/es_predicate_test.cpp b/be/test/exec/es_predicate_test.cpp index 28ce54877d..966b0c0eff 100644 --- a/be/test/exec/es_predicate_test.cpp +++ b/be/test/exec/es_predicate_test.cpp @@ -142,7 +142,7 @@ Status EsPredicateTest::build_expr_context_list(std::vector& conju TEST_F(EsPredicateTest, normal) { std::vector conjunct_ctxs; Status status = build_expr_context_list(conjunct_ctxs); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); TupleDescriptor* tuple_desc = _desc_tbl->get_tuple_descriptor(0); std::vector predicates; for (int i = 0; i < conjunct_ctxs.size(); ++i) { @@ -164,15 +164,10 @@ TEST_F(EsPredicateTest, normal) { "{\"bool\":{\"filter\":[{\"bool\":{\"should\":[{\"range\":{\"id\":{\"gt\":\"10\"}}}]}}]" "}}"; LOG(INFO) << "compound bool query" << actual_bool_json; - ASSERT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); + EXPECT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); for (auto predicate : predicates) { delete predicate; } } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/es_query_builder_test.cpp b/be/test/exec/es_query_builder_test.cpp index a9b04b72a7..6b8a172dcb 100644 --- a/be/test/exec/es_query_builder_test.cpp +++ b/be/test/exec/es_query_builder_test.cpp @@ -58,7 +58,7 @@ TEST_F(BooleanQueryBuilderTest, term_query) { term_value.Accept(writer); std::string actual_json = buffer.GetString(); //LOG(INFO) << "term query" << actual_json; - ASSERT_STREQ("{\"term\":{\"content\":\"wyf\"}}", actual_json.c_str()); + EXPECT_STREQ("{\"term\":{\"content\":\"wyf\"}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, range_query) { @@ -80,7 +80,7 @@ TEST_F(BooleanQueryBuilderTest, range_query) { range_value.Accept(writer); std::string actual_json = buffer.GetString(); //LOG(INFO) << "range query" << actual_json; - ASSERT_STREQ("{\"range\":{\"k\":{\"gte\":\"a\"}}}", actual_json.c_str()); + EXPECT_STREQ("{\"range\":{\"k\":{\"gte\":\"a\"}}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, es_query) { @@ -106,7 +106,7 @@ TEST_F(BooleanQueryBuilderTest, es_query) { es_query_value.Accept(writer); std::string actual_json = buffer.GetString(); //LOG(INFO) << "es query" << actual_json; - ASSERT_STREQ("{\"bool\":{\"must_not\":{\"exists\":{\"field\":\"f1\"}}}}", actual_json.c_str()); + EXPECT_STREQ("{\"bool\":{\"must_not\":{\"exists\":{\"field\":\"f1\"}}}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, like_query) { @@ -129,7 +129,7 @@ TEST_F(BooleanQueryBuilderTest, like_query) { like_query_value.Accept(writer); std::string actual_json = buffer.GetString(); // LOG(INFO) << "wildcard query" << actual_json; - ASSERT_STREQ("{\"wildcard\":{\"content\":\"a*e*g?\"}}", actual_json.c_str()); + EXPECT_STREQ("{\"wildcard\":{\"content\":\"a*e*g?\"}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, terms_in_query) { @@ -167,7 +167,7 @@ TEST_F(BooleanQueryBuilderTest, terms_in_query) { in_query_value.Accept(writer); std::string actual_json = buffer.GetString(); //LOG(INFO) << "terms in sets query" << actual_json; - ASSERT_STREQ("{\"terms\":{\"dv\":[\"2.0\",\"4.0\",\"8.0\"]}}", actual_json.c_str()); + EXPECT_STREQ("{\"terms\":{\"dv\":[\"2.0\",\"4.0\",\"8.0\"]}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, match_all_query) { @@ -182,7 +182,7 @@ TEST_F(BooleanQueryBuilderTest, match_all_query) { match_all_query_value.Accept(writer); std::string actual_json = buffer.GetString(); //LOG(INFO) << "match all query" << actual_json; - ASSERT_STREQ("{\"match_all\":{}}", actual_json.c_str()); + EXPECT_STREQ("{\"match_all\":{}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, exists_query) { @@ -202,7 +202,7 @@ TEST_F(BooleanQueryBuilderTest, exists_query) { rapidjson::Writer writer(buffer); exists_query_value.Accept(writer); std::string actual_json = buffer.GetString(); - ASSERT_STREQ("{\"exists\":{\"field\":\"k1\"}}", actual_json.c_str()); + EXPECT_STREQ("{\"exists\":{\"field\":\"k1\"}}", actual_json.c_str()); } TEST_F(BooleanQueryBuilderTest, bool_query) { @@ -267,7 +267,7 @@ TEST_F(BooleanQueryBuilderTest, bool_query) { "not\":{\"exists\":{\"field\":\"f1\"}}}},{\"range\":{\"k\":{\"gte\":\"a\"}}},{\"term\":" "{\"content\":\"wyf\"}}]}}"; //LOG(INFO) << "bool query" << actual_json; - ASSERT_STREQ(expected_json.c_str(), actual_json.c_str()); + EXPECT_STREQ(expected_json.c_str(), actual_json.c_str()); delete like_predicate; delete function_predicate; @@ -371,7 +371,7 @@ TEST_F(BooleanQueryBuilderTest, compound_bool_query) { "{\"term\":{\"content\":\"wyf\"}}]}}]}},{\"bool\":{\"should\":[{\"bool\":{\"must_not\":" "[{\"terms\":{\"fv\":[\"8.0\",\"16.0\"]}}]}}]}}]}}"; //LOG(INFO) << "compound bool query" << actual_bool_json; - ASSERT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); + EXPECT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); delete bool_predicate_1; delete bool_predicate_2; delete bool_predicate_3; @@ -393,7 +393,7 @@ TEST_F(BooleanQueryBuilderTest, validate_esquery) { ExtFunction legal_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, es_query_values); auto st = BooleanQueryBuilder::check_es_query(legal_es_query); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); char empty_query[] = "{}"; int empty_query_length = (int)strlen(empty_query); StringValue empty_query_value(empty_query, empty_query_length); @@ -402,7 +402,7 @@ TEST_F(BooleanQueryBuilderTest, validate_esquery) { ExtFunction empty_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, empty_query_values); st = BooleanQueryBuilder::check_es_query(empty_es_query); - ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); + EXPECT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); //LOG(INFO) <<"error msg:" << st1.get_error_msg(); char malformed_query[] = "{\"bool\": {\"must_not\": {\"exists\": {"; int malformed_query_length = (int)strlen(malformed_query); @@ -412,7 +412,7 @@ TEST_F(BooleanQueryBuilderTest, validate_esquery) { ExtFunction malformed_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, malformed_query_values); st = BooleanQueryBuilder::check_es_query(malformed_es_query); - ASSERT_STREQ(st.get_error_msg().c_str(), "malformed esquery json"); + EXPECT_STREQ(st.get_error_msg().c_str(), "malformed esquery json"); char illegal_query[] = "{\"term\": {\"k1\" : \"2\"},\"match\": {\"k1\": \"3\"}}"; int illegal_query_length = (int)strlen(illegal_query); StringValue illegal_query_value(illegal_query, illegal_query_length); @@ -421,7 +421,7 @@ TEST_F(BooleanQueryBuilderTest, validate_esquery) { ExtFunction illegal_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, illegal_query_values); st = BooleanQueryBuilder::check_es_query(illegal_es_query); - ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); + EXPECT_STREQ(st.get_error_msg().c_str(), "esquery must only one root"); char illegal_key_query[] = "[\"22\"]"; int illegal_key_query_length = (int)strlen(illegal_key_query); StringValue illegal_key_query_value(illegal_key_query, illegal_key_query_length); @@ -430,7 +430,7 @@ TEST_F(BooleanQueryBuilderTest, validate_esquery) { ExtFunction illegal_key_es_query(TExprNodeType::FUNCTION_CALL, function_name, es_query_cols, illegal_key_query_values); st = BooleanQueryBuilder::check_es_query(illegal_key_es_query); - ASSERT_STREQ(st.get_error_msg().c_str(), "esquery must be a object"); + EXPECT_STREQ(st.get_error_msg().c_str(), "esquery must be a object"); } TEST_F(BooleanQueryBuilderTest, validate_partial) { @@ -513,7 +513,7 @@ TEST_F(BooleanQueryBuilderTest, validate_partial) { std::vector result; BooleanQueryBuilder::validate(and_bool_predicates, &result); std::vector expected = {true, true, true}; - ASSERT_EQ(result, expected); + EXPECT_EQ(result, expected); char illegal_query[] = "{\"term\": {\"k1\" : \"2\"},\"match\": {\"k1\": \"3\"}}"; int illegal_query_length = (int)strlen(illegal_query); StringValue illegal_query_value(illegal_query, illegal_query_length); @@ -529,7 +529,7 @@ TEST_F(BooleanQueryBuilderTest, validate_partial) { std::vector result1; BooleanQueryBuilder::validate(and_bool_predicates_1, &result1); std::vector expected1 = {true, true, false}; - ASSERT_EQ(result1, expected1); + EXPECT_EQ(result1, expected1); } // ( k >= "a" and (fv not in [8.0, 16.0]) or (content != "wyf") ) or content like "a%e%g_" @@ -604,7 +604,7 @@ TEST_F(BooleanQueryBuilderTest, validate_compound_and) { std::vector result1; BooleanQueryBuilder::validate(or_predicates, &result1); std::vector expected1 = {true}; - ASSERT_TRUE(result1 == expected1); + EXPECT_TRUE(result1 == expected1); rapidjson::Document document; rapidjson::Value compound_and_value(rapidjson::kObjectType); @@ -619,11 +619,6 @@ TEST_F(BooleanQueryBuilderTest, validate_compound_and) { "\"should\":[{\"range\":{\"k\":{\"gte\":\"a\"}}}]}},{\"bool\":{\"should\":[{\"bool\":{" "\"must_not\":[{\"term\":{\"content\":\"wyf\"}}]}},{\"bool\":{\"must_not\":[{\"terms\":" "{\"fv\":[\"8.0\",\"16.0\"]}}]}}]}}]}},{\"wildcard\":{\"content\":\"a*e*g?\"}}]}}]}}"; - ASSERT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); + EXPECT_STREQ(expected_json.c_str(), actual_bool_json.c_str()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/es_scan_node_test.cpp b/be/test/exec/es_scan_node_test.cpp index 2a68abebcf..c647170f53 100644 --- a/be/test/exec/es_scan_node_test.cpp +++ b/be/test/exec/es_scan_node_test.cpp @@ -107,7 +107,7 @@ protected: TEST_F(EsScanNodeTest, normal_use) { EsScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); TEsScanRange es_scan_range; es_scan_range.__set_index("index1"); es_scan_range.__set_type("docs"); @@ -126,27 +126,22 @@ TEST_F(EsScanNodeTest, normal_use) { scan_ranges.push_back(scan_range_params); status = scan_node.set_scan_ranges(scan_ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::stringstream out; scan_node.debug_string(1, &out); LOG(WARNING) << out.str(); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_state.batch_size()); bool eos = false; status = scan_node.get_next(&_runtime_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(2, row_batch.num_rows()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(2, row_batch.num_rows()); + EXPECT_TRUE(eos); status = scan_node.close(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/es_scan_reader_test.cpp b/be/test/exec/es_scan_reader_test.cpp index 8649ebec1a..9c4185086f 100644 --- a/be/test/exec/es_scan_reader_test.cpp +++ b/be/test/exec/es_scan_reader_test.cpp @@ -208,7 +208,7 @@ public: mock_es_server->register_handler(DELETE, "/_search/scroll", &rest_clear_scroll_action); mock_es_server->start(); real_port = mock_es_server->get_real_port(); - ASSERT_NE(0, real_port); + EXPECT_NE(0, real_port); } static void TearDownTestCase() { delete mock_es_server; } @@ -231,22 +231,17 @@ TEST_F(MockESServerTest, workflow) { docvalue_context, &doc_value_mode); ESScanReader reader(target, props, doc_value_mode); auto st = reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); bool eos = false; std::unique_ptr parser = nullptr; while (!eos) { st = reader.get_next(&eos, parser); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); if (eos) { break; } } auto cst = reader.close(); - ASSERT_TRUE(cst.ok()); + EXPECT_TRUE(cst.ok()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/hash_table_test.cpp b/be/test/exec/hash_table_test.cpp index 6746fed3e1..abd40ff638 100644 --- a/be/test/exec/hash_table_test.cpp +++ b/be/test/exec/hash_table_test.cpp @@ -37,7 +37,7 @@ #include "runtime/runtime_state.h" #include "runtime/string_value.h" #include "runtime/test_env.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/cpu_info.h" #include "util/runtime_profile.h" #include "util/time.h" @@ -225,7 +225,7 @@ TEST_F(HashTableTest, BasicTest) { hash_table.insert(build_rows[i]); } - EXPECT_EQ(hash_table.size(), 5); + EXPECT_EQ(5, hash_table.size()); // Do a full table scan and validate returned pointers full_scan(&hash_table, 0, 5, true, scan_rows, build_rows); @@ -384,21 +384,9 @@ TEST_F(HashTableTest, GrowTableTest2) { size_t counter = 0; auto func = [&](TupleRow* row) { counter++; }; hash_table.for_each_row(func); - ASSERT_EQ(counter, hash_table.size()); + EXPECT_EQ(counter, hash_table.size()); hash_table.close(); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::CpuInfo::init(); - doris::MemInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/hdfs_file_reader_test.cpp b/be/test/exec/hdfs_file_reader_test.cpp index f67e08a30c..6807272bac 100644 --- a/be/test/exec/hdfs_file_reader_test.cpp +++ b/be/test/exec/hdfs_file_reader_test.cpp @@ -16,10 +16,11 @@ // under the License. #include "exec/hdfs_file_reader.h" -#include "exec/hdfs_reader_writer.h" #include +#include "exec/hdfs_reader_writer.h" + namespace doris { class HdfsFileReaderTest : public testing::Test {}; @@ -31,12 +32,8 @@ TEST_F(HdfsFileReaderTest, test_connect_fail) { Status status = hdfs_file_reader.open(); hdfs_file_reader.close(); std::string msg = status.get_error_msg(); - ASSERT_TRUE(msg.find("Connection refused") >= 0); + EXPECT_TRUE(msg.find("Connection refused") >= 0); + hdfs_file_reader.close(); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/json_scanner_test.cpp b/be/test/exec/json_scanner_test.cpp index c10f59327e..582e26b7c5 100644 --- a/be/test/exec/json_scanner_test.cpp +++ b/be/test/exec/json_scanner_test.cpp @@ -26,9 +26,9 @@ #include "exec/broker_scan_node.h" #include "exec/local_file_reader.h" #include "exprs/cast_functions.h" +#include "exprs/decimalv2_operators.h" #include "gen_cpp/Descriptors_types.h" #include "gen_cpp/PlanNodes_types.h" -#include "exprs/decimalv2_operators.h" #include "runtime/descriptors.h" #include "runtime/exec_env.h" #include "runtime/row_batch.h" @@ -76,7 +76,7 @@ private: #define DST_TUPLE_SLOT_ID_START 1 #define SRC_TUPLE_SLOT_ID_START 7 int JsonScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int next_slot_id) { - const char *columnNames[] = {"category","author","title","price", "largeint", "decimal"}; + const char* columnNames[] = {"category", "author", "title", "price", "largeint", "decimal"}; for (int i = 0; i < COLUMN_NUMBERS; i++) { TSlotDescriptor slot_desc; @@ -225,7 +225,7 @@ int JsonScannerTest::create_dst_tuple(TDescriptorTable& t_desc_table, int next_s t_desc_table.slotDescriptors.push_back(slot_desc); } byteOffset += 8; - {// lagreint + { // lagreint TSlotDescriptor slot_desc; slot_desc.id = next_slot_id++; @@ -251,7 +251,7 @@ int JsonScannerTest::create_dst_tuple(TDescriptorTable& t_desc_table, int next_s t_desc_table.slotDescriptors.push_back(slot_desc); } byteOffset += 16; - {// decimal + { // decimal TSlotDescriptor slot_desc; slot_desc.id = next_slot_id++; @@ -533,7 +533,7 @@ TEST_F(JsonScannerTest, normal_simple_arrayjson) { BrokerScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); auto status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // set scan range std::vector scan_ranges; @@ -558,31 +558,32 @@ TEST_F(JsonScannerTest, normal_simple_arrayjson) { scan_node.set_scan_ranges(scan_ranges); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Get batch RowBatch batch(scan_node.row_desc(), _runtime_state.batch_size()); bool eof = false; status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(2, batch.num_rows()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(2, batch.num_rows()); // Do not use num_as_string, so largeint is too big is null and decimal value loss precision - auto tuple_str = batch.get_row(1)->get_tuple(0)->to_string(*scan_node.row_desc().tuple_descriptors()[0]); - ASSERT_TRUE(tuple_str.find("1180591620717411303424") == tuple_str.npos); - ASSERT_TRUE(tuple_str.find("9999999999999.999999") == tuple_str.npos); - ASSERT_FALSE(eof); + auto tuple_str = + batch.get_row(1)->get_tuple(0)->to_string(*scan_node.row_desc().tuple_descriptors()[0]); + EXPECT_TRUE(tuple_str.find("1180591620717411303424") == tuple_str.npos); + EXPECT_TRUE(tuple_str.find("9999999999999.999999") == tuple_str.npos); + EXPECT_FALSE(eof); batch.reset(); status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, batch.num_rows()); - ASSERT_TRUE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, batch.num_rows()); + EXPECT_TRUE(eof); // Use num_as_string load data again BrokerScanNode scan_node2(&_obj_pool, _tnode, *_desc_tbl); scan_node2.init(_tnode); status = scan_node2.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); scan_ranges.clear(); { TScanRangeParams scan_range_params; @@ -606,15 +607,16 @@ TEST_F(JsonScannerTest, normal_simple_arrayjson) { } scan_node2.set_scan_ranges(scan_ranges); status = scan_node2.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node2.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(2, batch.num_rows()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(2, batch.num_rows()); // Use num as string, load largeint, decimal successfully - tuple_str = batch.get_row(1)->get_tuple(0)->to_string(*scan_node2.row_desc().tuple_descriptors()[0]); - ASSERT_FALSE(tuple_str.find("1180591620717411303424") == tuple_str.npos); - ASSERT_FALSE(tuple_str.find("9999999999999.999999") == tuple_str.npos); + tuple_str = batch.get_row(1)->get_tuple(0)->to_string( + *scan_node2.row_desc().tuple_descriptors()[0]); + EXPECT_FALSE(tuple_str.find("1180591620717411303424") == tuple_str.npos); + EXPECT_FALSE(tuple_str.find("9999999999999.999999") == tuple_str.npos); scan_node.close(&_runtime_state); scan_node2.close(&_runtime_state); @@ -626,9 +628,3 @@ TEST_F(JsonScannerTest, normal_simple_arrayjson) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/json_scanner_with_jsonpath_test.cpp b/be/test/exec/json_scanner_with_jsonpath_test.cpp index 907afb25df..9db0bd37b4 100644 --- a/be/test/exec/json_scanner_with_jsonpath_test.cpp +++ b/be/test/exec/json_scanner_with_jsonpath_test.cpp @@ -37,9 +37,9 @@ namespace doris { -class JsonScannerTest : public testing::Test { +class JsonScannerWithJsonPathTest : public testing::Test { public: - JsonScannerTest() : _runtime_state(TQueryGlobals()) { + JsonScannerWithJsonPathTest() : _runtime_state(TQueryGlobals()) { init(); _runtime_state._instance_mem_tracker.reset(new MemTracker()); _runtime_state._exec_env = ExecEnv::GetInstance(); @@ -73,7 +73,8 @@ private: #define COLUMN_NUMBERS 4 #define DST_TUPLE_SLOT_ID_START 1 #define SRC_TUPLE_SLOT_ID_START 5 -int JsonScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int next_slot_id) { +int JsonScannerWithJsonPathTest::create_src_tuple(TDescriptorTable& t_desc_table, + int next_slot_id) { const char* columnNames[] = {"k1", "kind", "ip", "value"}; for (int i = 0; i < COLUMN_NUMBERS; i++) { TSlotDescriptor slot_desc; @@ -115,7 +116,8 @@ int JsonScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int next_s return next_slot_id; } -int JsonScannerTest::create_dst_tuple(TDescriptorTable& t_desc_table, int next_slot_id) { +int JsonScannerWithJsonPathTest::create_dst_tuple(TDescriptorTable& t_desc_table, + int next_slot_id) { int32_t byteOffset = 8; { //k1 TSlotDescriptor slot_desc; @@ -237,7 +239,7 @@ int JsonScannerTest::create_dst_tuple(TDescriptorTable& t_desc_table, int next_s return next_slot_id; } -void JsonScannerTest::init_desc_table() { +void JsonScannerWithJsonPathTest::init_desc_table() { TDescriptorTable t_desc_table; // table descriptors @@ -261,7 +263,7 @@ void JsonScannerTest::init_desc_table() { _runtime_state.set_desc_tbl(_desc_tbl); } -void JsonScannerTest::create_expr_info() { +void JsonScannerWithJsonPathTest::create_expr_info() { TTypeDesc varchar_type; { TTypeNode node; @@ -342,7 +344,7 @@ void JsonScannerTest::create_expr_info() { _params.__set_src_tuple_id(TUPLE_ID_SRC); } -void JsonScannerTest::init() { +void JsonScannerWithJsonPathTest::init() { create_expr_info(); init_desc_table(); @@ -357,11 +359,11 @@ void JsonScannerTest::init() { _tnode.__isset.broker_scan_node = true; } -TEST_F(JsonScannerTest, normal) { +TEST_F(JsonScannerWithJsonPathTest, normal) { BrokerScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); auto status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // set scan range std::vector scan_ranges; @@ -389,21 +391,21 @@ TEST_F(JsonScannerTest, normal) { scan_node.set_scan_ranges(scan_ranges); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Get batch RowBatch batch(scan_node.row_desc(), _runtime_state.batch_size()); bool eof = false; status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(2, batch.num_rows()); - ASSERT_FALSE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(2, batch.num_rows()); + EXPECT_FALSE(eof); batch.reset(); status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, batch.num_rows()); - ASSERT_TRUE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, batch.num_rows()); + EXPECT_TRUE(eof); scan_node.close(&_runtime_state); { @@ -414,9 +416,3 @@ TEST_F(JsonScannerTest, normal) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/multi_bytes_separator_test.cpp b/be/test/exec/multi_bytes_separator_test.cpp index b6dc149376..9a99c354bb 100644 --- a/be/test/exec/multi_bytes_separator_test.cpp +++ b/be/test/exec/multi_bytes_separator_test.cpp @@ -15,8 +15,6 @@ // specific language governing permissions and limitations // under the License. -#include "exec/broker_scanner.h" - #include #include @@ -24,6 +22,7 @@ #include #include "common/object_pool.h" +#include "exec/broker_scanner.h" #include "exec/local_file_reader.h" #include "exprs/cast_functions.h" #include "gen_cpp/Descriptors_types.h" @@ -36,7 +35,7 @@ namespace doris { -class MultiBytesSeparatorTest: public testing::Test { +class MultiBytesSeparatorTest : public testing::Test { public: MultiBytesSeparatorTest() {} @@ -45,7 +44,6 @@ protected: virtual void TearDown() {} }; - TEST_F(MultiBytesSeparatorTest, normal) { TBrokerScanRangeParams params; params.column_separator = ','; @@ -58,7 +56,8 @@ TEST_F(MultiBytesSeparatorTest, normal) { const std::vector ranges; const std::vector broker_addresses; const std::vector pre_filter_texprs; - BrokerScanner scanner(nullptr, nullptr, params, ranges, broker_addresses, pre_filter_texprs, nullptr); + BrokerScanner scanner(nullptr, nullptr, params, ranges, broker_addresses, pre_filter_texprs, + nullptr); #define private public @@ -67,9 +66,9 @@ TEST_F(MultiBytesSeparatorTest, normal) { std::string line = "AAAA"; Slice s(line); scanner.split_line(s); - ASSERT_EQ(2, scanner._split_values.size()); - ASSERT_EQ(0, scanner._split_values[0].size); - ASSERT_EQ(0, scanner._split_values[1].size); + EXPECT_EQ(2, scanner._split_values.size()); + EXPECT_EQ(0, scanner._split_values[0].size); + EXPECT_EQ(0, scanner._split_values[1].size); } // 2. @@ -77,8 +76,8 @@ TEST_F(MultiBytesSeparatorTest, normal) { std::string line = "ABAA"; Slice s(line); scanner.split_line(s); - ASSERT_EQ(1, scanner._split_values.size()); - ASSERT_EQ(4, scanner._split_values[0].size); + EXPECT_EQ(1, scanner._split_values.size()); + EXPECT_EQ(4, scanner._split_values[0].size); } // 3. @@ -86,8 +85,8 @@ TEST_F(MultiBytesSeparatorTest, normal) { std::string line = ""; Slice s(line); scanner.split_line(s); - ASSERT_EQ(1, scanner._split_values.size()); - ASSERT_EQ(0, scanner._split_values[0].size); + EXPECT_EQ(1, scanner._split_values.size()); + EXPECT_EQ(0, scanner._split_values[0].size); } // 4. @@ -96,18 +95,12 @@ TEST_F(MultiBytesSeparatorTest, normal) { std::string line = "1234AAAAAAABAAAAAAAAAA"; Slice s(line); scanner.split_line(s); - ASSERT_EQ(4, scanner._split_values.size()); - ASSERT_EQ(4, scanner._split_values[0].size); - ASSERT_EQ(4, scanner._split_values[1].size); - ASSERT_EQ(0, scanner._split_values[2].size); - ASSERT_EQ(2, scanner._split_values[3].size); + EXPECT_EQ(4, scanner._split_values.size()); + EXPECT_EQ(4, scanner._split_values[0].size); + EXPECT_EQ(4, scanner._split_values[1].size); + EXPECT_EQ(0, scanner._split_values[2].size); + EXPECT_EQ(2, scanner._split_values[3].size); } } - } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/mysql_scan_node_test.cpp b/be/test/exec/mysql_scan_node_test.cpp index 9f553d7ed2..cc46f87c9a 100644 --- a/be/test/exec/mysql_scan_node_test.cpp +++ b/be/test/exec/mysql_scan_node_test.cpp @@ -173,22 +173,22 @@ protected: TEST_F(MysqlScanNodeTest, normal_use) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector scan_ranges; status = scan_node.set_scan_ranges(scan_ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::stringstream out; scan_node.debug_string(1, &out); LOG(WARNING) << out.str(); status = scan_node.open(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos = false; while (!eos) { status = scan_node.get_next(&_runtim_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { for (int i = 0; i < row_batch.num_rows(); ++i) { @@ -199,67 +199,67 @@ TEST_F(MysqlScanNodeTest, normal_use) { } status = scan_node.close(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(MysqlScanNodeTest, Prepare_fail_1) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node._tuple_id = 1; Status status = scan_node.prepare(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScanNodeTest, Prepare_fail_2) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); TableDescriptor* old = _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc; _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc = nullptr; Status status = scan_node.prepare(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc = old; } TEST_F(MysqlScanNodeTest, open_fail_1) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); scan_node._table_name = "no_such_table"; status = scan_node.open(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScanNodeTest, open_fail_3) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); scan_node._columns.clear(); scan_node._columns.push_back("id"); status = scan_node.open(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScanNodeTest, open_fail_2) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); scan_node._my_param.host = ""; status = scan_node.open(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScanNodeTest, invalid_input) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.prepare(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scan_node.open(&_runtim_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos = false; status = scan_node.get_next(nullptr, &row_batch, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); while (!eos) { status = scan_node.get_next(&_runtim_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < row_batch.num_rows(); ++i) { TupleRow* row = row_batch.get_row(i); @@ -270,22 +270,11 @@ TEST_F(MysqlScanNodeTest, invalid_input) { TEST_F(MysqlScanNodeTest, no_init) { MysqlScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.open(&_runtim_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos = false; status = scan_node.get_next(&_runtim_state, &row_batch, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/mysql_scanner_test.cpp b/be/test/exec/mysql_scanner_test.cpp index 56a9054263..4a95cef2b3 100644 --- a/be/test/exec/mysql_scanner_test.cpp +++ b/be/test/exec/mysql_scanner_test.cpp @@ -45,18 +45,18 @@ protected: TEST_F(MysqlScannerTest, normal_use) { MysqlScanner scanner(_param); Status status = scanner.open(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector fields; fields.push_back("*"); std::vector filters; filters.push_back("id = 1"); status = scanner.query("dim_lbs_device", fields, filters); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; char** buf; unsigned long* length; status = scanner.get_next_row(nullptr, &length, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); while (!eos) { status = scanner.get_next_row(&buf, &length, &eos); @@ -65,7 +65,7 @@ TEST_F(MysqlScannerTest, normal_use) { break; } - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < scanner.field_num(); ++i) { if (buf[i]) { @@ -84,44 +84,33 @@ TEST_F(MysqlScannerTest, no_init) { std::vector filters; filters.push_back("id = 1"); Status status = scanner.query("dim_lbs_device", fields, filters); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.query("select 1"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); bool eos = false; char** buf; unsigned long* length; status = scanner.get_next_row(&buf, &length, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScannerTest, query_failed) { MysqlScanner scanner(_param); Status status = scanner.open(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector fields; fields.push_back("*"); std::vector filters; filters.push_back("id = 1"); status = scanner.query("no_such_table", fields, filters); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(MysqlScannerTest, open_failed) { MysqlScannerParam invalid_param; MysqlScanner scanner(invalid_param); Status status = scanner.open(); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/new_olap_scan_node_test.cpp b/be/test/exec/new_olap_scan_node_test.cpp index d52f3e6476..ca78c58f41 100644 --- a/be/test/exec/new_olap_scan_node_test.cpp +++ b/be/test/exec/new_olap_scan_node_test.cpp @@ -284,10 +284,10 @@ private: TEST_F(TestOlapScanNode, SimpleTest) { OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); int num_rows = 0; @@ -296,13 +296,13 @@ TEST_F(TestOlapScanNode, SimpleTest) { while (!eos) { row_batch.reset(); status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); VLOG_CRITICAL << "num_rows: " << row_batch.num_rows(); num_rows += row_batch.num_rows(); } - ASSERT_EQ(num_rows, 1000); - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_EQ(num_rows, 1000); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } TEST_F(TestOlapScanNode, MultiColumnSingleVersionTest) { @@ -314,10 +314,10 @@ TEST_F(TestOlapScanNode, MultiColumnSingleVersionTest) { OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); int num_rows = 0; @@ -327,21 +327,21 @@ TEST_F(TestOlapScanNode, MultiColumnSingleVersionTest) { while (!eos) { row_batch.reset(); status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < row_batch.num_rows(); ++i) { TupleRow* row = row_batch.get_row(i); VLOG_NOTICE << "input row: " << print_row(row, scan_node._row_descriptor); - ASSERT_LT(data_index, data.size()); - ASSERT_EQ(data[data_index], print_row(row, scan_node._row_descriptor)); + EXPECT_LT(data_index, data.size()); + EXPECT_EQ(data[data_index], print_row(row, scan_node._row_descriptor)); ++data_index; } num_rows += row_batch.num_rows(); } - ASSERT_EQ(num_rows, data.size()); - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_EQ(num_rows, data.size()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } TEST_F(TestOlapScanNode, MultiColumnMultiVersionTest) { @@ -353,10 +353,10 @@ TEST_F(TestOlapScanNode, MultiColumnMultiVersionTest) { OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); int num_rows = 0; @@ -366,35 +366,23 @@ TEST_F(TestOlapScanNode, MultiColumnMultiVersionTest) { while (!eos) { row_batch.reset(); status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < row_batch.num_rows(); ++i) { TupleRow* row = row_batch.get_row(i); VLOG_NOTICE << "input row: " << print_row(row, scan_node._row_descriptor); - ASSERT_LT(data_index, data.size()); - ASSERT_EQ(data[data_index], print_row(row, scan_node._row_descriptor)); + EXPECT_LT(data_index, data.size()); + EXPECT_EQ(data[data_index], print_row(row, scan_node._row_descriptor)); ++data_index; } num_rows += row_batch.num_rows(); } - ASSERT_EQ(num_rows, data.size()); - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_EQ(num_rows, data.size()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} - /* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */ diff --git a/be/test/exec/olap_common_test.cpp b/be/test/exec/olap_common_test.cpp index 3ba0a03262..e44ae17a0f 100644 --- a/be/test/exec/olap_common_test.cpp +++ b/be/test/exec/olap_common_test.cpp @@ -15,13 +15,12 @@ // specific language governing permissions and limitations // under the License. +#include #include #include #include #include - -#include #define protected public #define private public @@ -30,8 +29,8 @@ #include "gen_cpp/Types_types.h" #include "runtime/descriptors.h" #include "util/cpu_info.h" -#include "util/runtime_profile.h" #include "util/logging.h" +#include "util/runtime_profile.h" namespace doris { @@ -44,7 +43,7 @@ void construct_scan_range(TPaloScanRange* doris_scan_range) { doris_scan_range->__set_version("0"); // Useless but it is required in TPaloScanRange doris_scan_range->__set_version_hash("0"); -// doris_scan_range->engine_table_name.push_back("ShowQStats"); + // doris_scan_range->engine_table_name.push_back("ShowQStats"); doris_scan_range->__set_db_name("olap"); TKeyRange key_range; key_range.__set_column_type(to_thrift(TYPE_INT)); @@ -64,92 +63,92 @@ public: TEST_F(ColumnValueRangeTest, ExceptionCase) { ColumnValueRange range1; - ASSERT_FALSE(range1.add_fixed_value(10).ok()); - ASSERT_FALSE(range1.add_range(FILTER_LESS_OR_EQUAL, 10).ok()); + EXPECT_FALSE(range1.add_fixed_value(10).ok()); + EXPECT_FALSE(range1.add_range(FILTER_LESS_OR_EQUAL, 10).ok()); } TEST_F(ColumnValueRangeTest, NormalCase) { ColumnValueRange range1("col", TYPE_INT); - ASSERT_TRUE(range1.add_fixed_value(10).ok()); - ASSERT_TRUE(range1.add_fixed_value(20).ok()); - ASSERT_TRUE(range1.add_fixed_value(30).ok()); + EXPECT_TRUE(range1.add_fixed_value(10).ok()); + EXPECT_TRUE(range1.add_fixed_value(20).ok()); + EXPECT_TRUE(range1.add_fixed_value(30).ok()); - ASSERT_TRUE(range1.is_fixed_value_range()); + EXPECT_TRUE(range1.is_fixed_value_range()); - ASSERT_TRUE(range1.add_range(FILTER_LESS, 30).ok()); - ASSERT_FALSE(range1.is_empty_value_range()); + EXPECT_TRUE(range1.add_range(FILTER_LESS, 30).ok()); + EXPECT_FALSE(range1.is_empty_value_range()); ColumnValueRange range2("col", TYPE_INT); - ASSERT_TRUE(range2.add_fixed_value(30).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_fixed_value(30).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.add_fixed_value(20).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_fixed_value(20).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.is_fixed_value_range()); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 50).ok()); - ASSERT_FALSE(range2.is_fixed_value_range()); + EXPECT_TRUE(range2.is_fixed_value_range()); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 50).ok()); + EXPECT_FALSE(range2.is_fixed_value_range()); - ASSERT_TRUE(range2.is_empty_value_range()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.is_empty_value_range()); + EXPECT_FALSE(range1.has_intersection(range2)); } TEST_F(ColumnValueRangeTest, FixedAddRangeTest) { ColumnValueRange range1("col", TYPE_INT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } - ASSERT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 10).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 10).ok()); std::set res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(0), 0); + EXPECT_EQ(res_set.count(0), 0); for (int i = 10; i < 100; i += 10) { - ASSERT_EQ(res_set.count(i), 1); + EXPECT_EQ(res_set.count(i), 1); } - ASSERT_TRUE(range1.add_range(FILTER_LARGER, 20).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LARGER, 20).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(10), 0); - ASSERT_EQ(res_set.count(20), 0); + EXPECT_EQ(res_set.count(10), 0); + EXPECT_EQ(res_set.count(20), 0); for (int i = 30; i < 100; i += 10) { - ASSERT_EQ(res_set.count(i), 1); + EXPECT_EQ(res_set.count(i), 1); } - ASSERT_TRUE(range1.add_range(FILTER_LESS, 90).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LESS, 90).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(90), 0); + EXPECT_EQ(res_set.count(90), 0); for (int i = 30; i < 90; i += 10) { - ASSERT_EQ(res_set.count(i), 1); + EXPECT_EQ(res_set.count(i), 1); } - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 70).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 70).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(80), 0); + EXPECT_EQ(res_set.count(80), 0); for (int i = 30; i < 80; i += 10) { - ASSERT_EQ(res_set.count(i), 1); + EXPECT_EQ(res_set.count(i), 1); } - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 30).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 30).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(30), 1); + EXPECT_EQ(res_set.count(30), 1); for (int i = 40; i < 80; i += 10) { - ASSERT_EQ(res_set.count(i), 0); + EXPECT_EQ(res_set.count(i), 0); } - ASSERT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 30).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 30).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(30), 1); + EXPECT_EQ(res_set.count(30), 1); - ASSERT_TRUE(range1.add_range(FILTER_LARGER, 30).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LARGER, 30).ok()); res_set = range1.get_fixed_value_set(); - ASSERT_EQ(res_set.count(30), 0); + EXPECT_EQ(res_set.count(30), 0); } TEST_F(ColumnValueRangeTest, ContainsNullTest) { @@ -157,21 +156,20 @@ TEST_F(ColumnValueRangeTest, ContainsNullTest) { // test fixed value range intersection with null and no null range for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } auto null_range = ColumnValueRange::create_empty_column_value_range(TYPE_INT); null_range.set_contain_null(true); - ASSERT_TRUE(!null_range.is_empty_value_range()); + EXPECT_TRUE(!null_range.is_empty_value_range()); null_range.intersection(range1); - ASSERT_TRUE(null_range.is_empty_value_range()); + EXPECT_TRUE(null_range.is_empty_value_range()); auto no_null_range = ColumnValueRange::create_empty_column_value_range(TYPE_INT); no_null_range.set_contain_null(false); no_null_range.intersection(range1); - ASSERT_EQ(no_null_range._fixed_values, range1._fixed_values); - ASSERT_EQ(no_null_range._contain_null, range1._contain_null); - + EXPECT_EQ(no_null_range._fixed_values, range1._fixed_values); + EXPECT_EQ(no_null_range._contain_null, range1._contain_null); // test scoped value range intersection with null and no null range range1.set_whole_value_range(); @@ -180,133 +178,132 @@ TEST_F(ColumnValueRangeTest, ContainsNullTest) { null_range = ColumnValueRange::create_empty_column_value_range(TYPE_INT); null_range.set_contain_null(true); - ASSERT_TRUE(!null_range.is_empty_value_range()); + EXPECT_TRUE(!null_range.is_empty_value_range()); null_range.intersection(range1); - ASSERT_TRUE(null_range.is_empty_value_range()); + EXPECT_TRUE(null_range.is_empty_value_range()); no_null_range = ColumnValueRange::create_empty_column_value_range(TYPE_INT); no_null_range.set_contain_null(false); no_null_range.intersection(range1); - ASSERT_TRUE(no_null_range._fixed_values.empty()); - ASSERT_EQ(no_null_range._low_value, range1._low_value); - ASSERT_EQ(no_null_range._high_value, range1._high_value); - ASSERT_EQ(no_null_range._contain_null, range1._contain_null); + EXPECT_TRUE(no_null_range._fixed_values.empty()); + EXPECT_EQ(no_null_range._low_value, range1._low_value); + EXPECT_EQ(no_null_range._high_value, range1._high_value); + EXPECT_EQ(no_null_range._contain_null, range1._contain_null); } TEST_F(ColumnValueRangeTest, RangeAddRangeTest) { ColumnValueRange range1("col", TYPE_INT); - ASSERT_EQ(range1.get_range_min_value(), std::numeric_limits::min()); - ASSERT_EQ(range1.get_range_max_value(), std::numeric_limits::max()); + EXPECT_EQ(range1.get_range_min_value(), std::numeric_limits::min()); + EXPECT_EQ(range1.get_range_max_value(), std::numeric_limits::max()); - ASSERT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_EQ(range1.get_range_min_value(), 20); + EXPECT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_EQ(range1.get_range_min_value(), 20); - ASSERT_TRUE(range1.add_range(FILTER_LARGER, 30).ok()); - ASSERT_EQ(range1.get_range_min_value(), 30); + EXPECT_TRUE(range1.add_range(FILTER_LARGER, 30).ok()); + EXPECT_EQ(range1.get_range_min_value(), 30); - ASSERT_TRUE(range1.add_range(FILTER_LESS, 100).ok()); - ASSERT_EQ(range1.get_range_max_value(), 100); + EXPECT_TRUE(range1.add_range(FILTER_LESS, 100).ok()); + EXPECT_EQ(range1.get_range_max_value(), 100); - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 90).ok()); - ASSERT_EQ(range1.get_range_max_value(), 90); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 90).ok()); + EXPECT_EQ(range1.get_range_max_value(), 90); - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 31).ok()); - ASSERT_EQ(range1.get_range_max_value(), 31); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 31).ok()); + EXPECT_EQ(range1.get_range_max_value(), 31); - ASSERT_TRUE(range1.add_range(FILTER_LESS, 31).ok()); - ASSERT_FALSE(range1.is_empty_value_range()); + EXPECT_TRUE(range1.add_range(FILTER_LESS, 31).ok()); + EXPECT_FALSE(range1.is_empty_value_range()); - ASSERT_TRUE(range1.add_range(FILTER_LESS, 30).ok()); - ASSERT_TRUE(range1.is_empty_value_range()); + EXPECT_TRUE(range1.add_range(FILTER_LESS, 30).ok()); + EXPECT_TRUE(range1.is_empty_value_range()); } TEST_F(ColumnValueRangeTest, RangeIntersectionTest) { ColumnValueRange range1("col", TYPE_INT); - ASSERT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); ColumnValueRange range2("col", TYPE_INT); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 100).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 100).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.has_intersection(range2)); // test intersection operation auto intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._low_value, 20); - ASSERT_EQ(intersection_range._low_op, FILTER_LARGER_OR_EQUAL); - ASSERT_EQ(intersection_range._high_value, 100); - ASSERT_EQ(intersection_range._high_op, FILTER_LESS); + EXPECT_EQ(intersection_range._low_value, 20); + EXPECT_EQ(intersection_range._low_op, FILTER_LARGER_OR_EQUAL); + EXPECT_EQ(intersection_range._high_value, 100); + EXPECT_EQ(intersection_range._high_op, FILTER_LESS); - - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 80).ok()); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 80).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._low_value, 40); - ASSERT_EQ(intersection_range._low_op, FILTER_LARGER); - ASSERT_EQ(intersection_range._high_value, 80); - ASSERT_EQ(intersection_range._high_op, FILTER_LESS_OR_EQUAL); + EXPECT_EQ(intersection_range._low_value, 40); + EXPECT_EQ(intersection_range._low_op, FILTER_LARGER); + EXPECT_EQ(intersection_range._high_value, 80); + EXPECT_EQ(intersection_range._high_op, FILTER_LESS_OR_EQUAL); - ASSERT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 40).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.add_range(FILTER_LESS_OR_EQUAL, 40).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_TRUE(intersection_range.is_empty_value_range()); + EXPECT_TRUE(intersection_range.is_empty_value_range()); } TEST_F(ColumnValueRangeTest, FixedValueIntersectionTest) { ColumnValueRange range1("col", TYPE_INT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } ColumnValueRange range2("col", TYPE_INT); for (int i = 50; i < 200; i += 10) { - ASSERT_TRUE(range2.add_fixed_value(i).ok()); + EXPECT_TRUE(range2.add_fixed_value(i).ok()); } - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.has_intersection(range2)); // test intersection operation auto intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._fixed_values.size(), 5); - ASSERT_TRUE(intersection_range._fixed_values.count(50) == 1); - ASSERT_TRUE(intersection_range._fixed_values.count(90) == 1); + EXPECT_EQ(intersection_range._fixed_values.size(), 5); + EXPECT_TRUE(intersection_range._fixed_values.count(50) == 1); + EXPECT_TRUE(intersection_range._fixed_values.count(90) == 1); - ASSERT_TRUE(range2.add_range(FILTER_LESS_OR_EQUAL, 70).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS_OR_EQUAL, 70).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._fixed_values.size(), 3); - ASSERT_TRUE(intersection_range._fixed_values.count(50) == 1); - ASSERT_TRUE(intersection_range._fixed_values.count(70) == 1); + EXPECT_EQ(intersection_range._fixed_values.size(), 3); + EXPECT_TRUE(intersection_range._fixed_values.count(50) == 1); + EXPECT_TRUE(intersection_range._fixed_values.count(70) == 1); - ASSERT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 50).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.add_range(FILTER_LARGER_OR_EQUAL, 50).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._fixed_values.size(), 3); - ASSERT_TRUE(intersection_range._fixed_values.count(50) == 1); - ASSERT_TRUE(intersection_range._fixed_values.count(70) == 1); + EXPECT_EQ(intersection_range._fixed_values.size(), 3); + EXPECT_TRUE(intersection_range._fixed_values.count(50) == 1); + EXPECT_TRUE(intersection_range._fixed_values.count(70) == 1); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 60).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 60).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_EQ(intersection_range._fixed_values.size(), 1); - ASSERT_TRUE(intersection_range._fixed_values.count(50) == 1); + EXPECT_EQ(intersection_range._fixed_values.size(), 1); + EXPECT_TRUE(intersection_range._fixed_values.count(50) == 1); - ASSERT_TRUE(range1.add_range(FILTER_LARGER, 50).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range1.add_range(FILTER_LARGER, 50).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); intersection_range = range1; intersection_range.intersection(range2); - ASSERT_TRUE(intersection_range.is_empty_value_range()); + EXPECT_TRUE(intersection_range.is_empty_value_range()); } TEST_F(ColumnValueRangeTest, FixedAndRangeIntersectionTest) { @@ -317,27 +314,27 @@ TEST_F(ColumnValueRangeTest, FixedAndRangeIntersectionTest) { ColumnValueRange range2("col", TYPE_TINYINT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); } case TYPE_SMALLINT: { @@ -345,27 +342,27 @@ TEST_F(ColumnValueRangeTest, FixedAndRangeIntersectionTest) { ColumnValueRange range2("col", TYPE_SMALLINT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); } case TYPE_INT: { @@ -373,27 +370,27 @@ TEST_F(ColumnValueRangeTest, FixedAndRangeIntersectionTest) { ColumnValueRange range2("col", TYPE_INT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); } case TYPE_BIGINT: { @@ -401,27 +398,27 @@ TEST_F(ColumnValueRangeTest, FixedAndRangeIntersectionTest) { ColumnValueRange range2("col", TYPE_BIGINT); for (int i = 0; i < 100; i += 10) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); - ASSERT_TRUE(range1.has_intersection(range2)); - ASSERT_TRUE(range2.has_intersection(range1)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.has_intersection(range1)); - ASSERT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER, 40).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); - ASSERT_FALSE(range1.has_intersection(range2)); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 0).ok()); + EXPECT_FALSE(range1.has_intersection(range2)); } default: @@ -443,7 +440,7 @@ TEST_F(OlapScanKeysTest, ExtendFixedTest) { ColumnValueRange range1("col", TYPE_BIGINT); for (int i = 0; i < 3; ++i) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } scan_keys.extend_scan_key(range1, 1024); @@ -451,73 +448,73 @@ TEST_F(OlapScanKeysTest, ExtendFixedTest) { std::vector> key_range; scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 3); + EXPECT_EQ(key_range.size(), 3); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2"); ColumnValueRange range2("col", TYPE_BIGINT); for (int i = 0; i < 2; ++i) { - ASSERT_TRUE(range2.add_fixed_value(i).ok()); + EXPECT_TRUE(range2.add_fixed_value(i).ok()); } scan_keys.extend_scan_key(range2, 1024); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 6); + EXPECT_EQ(key_range.size(), 6); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[3]->begin_scan_range), "0,1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[3]->end_scan_range), "0,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[3]->begin_scan_range), "0,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[3]->end_scan_range), "0,1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[4]->begin_scan_range), "1,1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[4]->end_scan_range), "1,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[4]->begin_scan_range), "1,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[4]->end_scan_range), "1,1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[5]->begin_scan_range), "2,1"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[5]->end_scan_range), "2,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[5]->begin_scan_range), "2,1"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[5]->end_scan_range), "2,1"); range2.set_whole_value_range(); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 100).ok()); scan_keys.extend_scan_key(range2, 1024); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 6); + EXPECT_EQ(key_range.size(), 6); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,0,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,0,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,0,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,0,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,0,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,0,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,0,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,0,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,0,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,0,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,0,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,0,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[3]->begin_scan_range), "0,1,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[3]->end_scan_range), "0,1,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[3]->begin_scan_range), "0,1,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[3]->end_scan_range), "0,1,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[4]->begin_scan_range), "1,1,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[4]->end_scan_range), "1,1,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[4]->begin_scan_range), "1,1,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[4]->end_scan_range), "1,1,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[5]->begin_scan_range), "2,1,100"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[5]->end_scan_range), "2,1,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[5]->begin_scan_range), "2,1,100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[5]->end_scan_range), "2,1,2147483647"); } TEST_F(OlapScanKeysTest, ExtendFixedAndRangeTest) { @@ -526,47 +523,48 @@ TEST_F(OlapScanKeysTest, ExtendFixedAndRangeTest) { ColumnValueRange range1("col", TYPE_BIGINT); for (int i = 0; i < 3; ++i) { - ASSERT_TRUE(range1.add_fixed_value(i).ok()); + EXPECT_TRUE(range1.add_fixed_value(i).ok()); } scan_keys.extend_scan_key(range1, 1024); ColumnValueRange range2("col", TYPE_BIGINT); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); scan_keys.extend_scan_key(range2, 1024); - std::vector> key_range;; + std::vector> key_range; + ; scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 3); + EXPECT_EQ(key_range.size(), 3); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,2147483647"); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 100).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 100).ok()); scan_keys.extend_scan_key(range2, 1024); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 3); + EXPECT_EQ(key_range.size(), 3); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "0,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->begin_scan_range), "1,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[1]->end_scan_range), "1,2147483647"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,2147483647"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->begin_scan_range), "2,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[2]->end_scan_range), "2,2147483647"); } TEST_F(OlapScanKeysTest, ExtendRangeTest) { @@ -574,81 +572,83 @@ TEST_F(OlapScanKeysTest, ExtendRangeTest) { config::doris_max_scan_key_num = 1; ColumnValueRange range2("col", TYPE_BIGINT); - ASSERT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); - ASSERT_TRUE(range2.add_range(FILTER_LESS_OR_EQUAL, 100).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LESS_OR_EQUAL, 100).ok()); - ASSERT_TRUE(scan_keys.extend_scan_key(range2, 1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range2, 1024).ok()); - std::vector> key_range;; + std::vector> key_range; + ; scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 81); + EXPECT_EQ(key_range.size(), 81); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[80]->end_scan_range), "100"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[80]->end_scan_range), "100"); - ASSERT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range2.add_range(FILTER_LESS, 50).ok()); - ASSERT_TRUE(scan_keys.extend_scan_key(range2, 1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range2, 1024).ok()); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 81); + EXPECT_EQ(key_range.size(), 81); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "20,20"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "20,49"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "20,20"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "20,49"); } TEST_F(OlapScanKeysTest, EachtypeTest) { - std::vector> key_range;; + std::vector> key_range; + ; { OlapScanKeys scan_keys; ColumnValueRange range("col", TYPE_TINYINT); - ASSERT_TRUE(scan_keys.extend_scan_key(range,1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); scan_keys.get_key_range(&key_range); // contain null, [-128, 127] - ASSERT_EQ(key_range.size(), 257); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "-128"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[256]->end_scan_range), "null"); + EXPECT_EQ(key_range.size(), 257); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "-128"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[256]->end_scan_range), "null"); - ASSERT_TRUE(range.add_range(FILTER_LESS, 50).ok()); + EXPECT_TRUE(range.add_range(FILTER_LESS, 50).ok()); scan_keys.clear(); - ASSERT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 178); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "-128"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[177]->end_scan_range), "49"); + EXPECT_EQ(key_range.size(), 178); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "-128"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[177]->end_scan_range), "49"); } { OlapScanKeys scan_keys; ColumnValueRange range("col", TYPE_SMALLINT); - ASSERT_TRUE(scan_keys.extend_scan_key(range,1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 1); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "null"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32767"); + EXPECT_EQ(key_range.size(), 1); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "null"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32767"); - ASSERT_TRUE(range.add_range(FILTER_LARGER, 0).ok()); + EXPECT_TRUE(range.add_range(FILTER_LARGER, 0).ok()); scan_keys.clear(); - ASSERT_TRUE(scan_keys.extend_scan_key(range,1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 1); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32767"); + EXPECT_EQ(key_range.size(), 1); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32767"); - ASSERT_TRUE(range.add_range(FILTER_LESS, 32766).ok()); + EXPECT_TRUE(range.add_range(FILTER_LESS, 32766).ok()); scan_keys.clear(); - ASSERT_TRUE(scan_keys.extend_scan_key(range,1024).ok()); + EXPECT_TRUE(scan_keys.extend_scan_key(range, 1024).ok()); scan_keys.get_key_range(&key_range); - ASSERT_EQ(key_range.size(), 1); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); - ASSERT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32766"); + EXPECT_EQ(key_range.size(), 1); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->begin_scan_range), "0"); + EXPECT_EQ(OlapScanKeys::to_print_key(key_range[0]->end_scan_range), "32766"); } } @@ -657,105 +657,92 @@ TEST_F(OlapScanKeysTest, ToOlapFilterTest) { std::vector filters; range.to_olap_filter(filters); - ASSERT_TRUE(filters.empty()); + EXPECT_TRUE(filters.empty()); range.set_contain_null(true); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, "is"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "null"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, "is"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "null"); range.set_contain_null(false); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, "is"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "not null"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, "is"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "not null"); - ASSERT_TRUE(range.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); + EXPECT_TRUE(range.add_range(FILTER_LARGER_OR_EQUAL, 20).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, ">="); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, ">="); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); - ASSERT_TRUE(range.add_range(FILTER_LESS, 100).ok()); + EXPECT_TRUE(range.add_range(FILTER_LESS, 100).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, ">="); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, ">="); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); - ASSERT_EQ(std::next(filters.begin(), 1)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 1)->condition_op, "<<"); - ASSERT_EQ(std::next(filters.begin(), 1)->condition_values[0], "100"); + EXPECT_EQ(std::next(filters.begin(), 1)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 1)->condition_op, "<<"); + EXPECT_EQ(std::next(filters.begin(), 1)->condition_values[0], "100"); range.set_whole_value_range(); - ASSERT_TRUE(range.add_range(FILTER_LESS_OR_EQUAL, 100).ok()); + EXPECT_TRUE(range.add_range(FILTER_LESS_OR_EQUAL, 100).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, "<="); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "100"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, "<="); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "100"); - ASSERT_TRUE(range.add_range(FILTER_LARGER, 20).ok()); + EXPECT_TRUE(range.add_range(FILTER_LARGER, 20).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, ">>"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); - ASSERT_EQ(std::next(filters.begin(), 1)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 1)->condition_op, "<="); - ASSERT_EQ(std::next(filters.begin(), 1)->condition_values[0], "100"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, ">>"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); + EXPECT_EQ(std::next(filters.begin(), 1)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 1)->condition_op, "<="); + EXPECT_EQ(std::next(filters.begin(), 1)->condition_values[0], "100"); range.set_whole_value_range(); - ASSERT_TRUE(range.add_fixed_value(30).ok()); - ASSERT_TRUE(range.add_fixed_value(40).ok()); - ASSERT_TRUE(range.add_fixed_value(50).ok()); - ASSERT_TRUE(range.add_fixed_value(20).ok()); + EXPECT_TRUE(range.add_fixed_value(30).ok()); + EXPECT_TRUE(range.add_fixed_value(40).ok()); + EXPECT_TRUE(range.add_fixed_value(50).ok()); + EXPECT_TRUE(range.add_fixed_value(20).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, "*="); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[1], "30"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[2], "40"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[3], "50"); - + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, "*="); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[1], "30"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[2], "40"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[3], "50"); + filters.clear(); range.to_in_condition(filters, false); - ASSERT_EQ(std::next(filters.begin(), 0)->column_name, "col"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_op, "!*="); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[1], "30"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[2], "40"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[3], "50"); + EXPECT_EQ(std::next(filters.begin(), 0)->column_name, "col"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_op, "!*="); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "20"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[1], "30"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[2], "40"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[3], "50"); - - ASSERT_TRUE(range.add_range(FILTER_LARGER, 20).ok()); + EXPECT_TRUE(range.add_range(FILTER_LARGER, 20).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "30"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[1], "40"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[2], "50"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "30"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[1], "40"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[2], "50"); - ASSERT_TRUE(range.add_range(FILTER_LESS_OR_EQUAL, 40).ok()); + EXPECT_TRUE(range.add_range(FILTER_LESS_OR_EQUAL, 40).ok()); filters.clear(); range.to_olap_filter(filters); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[0], "30"); - ASSERT_EQ(std::next(filters.begin(), 0)->condition_values[1], "40"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[0], "30"); + EXPECT_EQ(std::next(filters.begin(), 0)->condition_values[1], "40"); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/olap_scan_node_test.cpp b/be/test/exec/olap_scan_node_test.cpp index ff613156f7..4a4a4ff3c3 100644 --- a/be/test/exec/olap_scan_node_test.cpp +++ b/be/test/exec/olap_scan_node_test.cpp @@ -204,33 +204,33 @@ private: TEST_F(OlapScanNodeTest, NormalUse) { OlapScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scanRanges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scanRanges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num = std::min(row_batch.num_rows(), 10); - ASSERT_TRUE(num > 0); + EXPECT_TRUE(num > 0); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); LOG(WARNING) << "input row: " << print_row(row, scan_node._row_descriptor); if (0 == i) { - ASSERT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); + EXPECT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); } } eos = true; } - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } TEST_F(OlapScanNodeTest, PushDownBinaryPredicate) { @@ -264,7 +264,7 @@ TEST_F(OlapScanNodeTest, PushDownBinaryPredicate) { bin_pre._children.push_back(_obj_pool.add(new IntLiteral(TYPE_INT, &v))); Status status = bin_pre.prepare(&_runtime_stat, row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::list exprs; exprs.push_back(&bin_pre); @@ -272,30 +272,30 @@ TEST_F(OlapScanNodeTest, PushDownBinaryPredicate) { scan_node.push_down_predicate(&_runtime_stat, &exprs); status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num = std::min(row_batch.num_rows(), 10); - ASSERT_TRUE(num > 0); + EXPECT_TRUE(num > 0); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); LOG(WARNING) << "input row: " << print_row(row, scan_node._row_descriptor); - ASSERT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); + EXPECT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); } eos = true; } - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } TEST_F(OlapScanNodeTest, PushDownBinaryEqualPredicate) { @@ -329,7 +329,7 @@ TEST_F(OlapScanNodeTest, PushDownBinaryEqualPredicate) { bin_pre._children.push_back(_obj_pool.add(new IntLiteral(TYPE_INT, &v))); Status status = bin_pre.prepare(&_runtime_stat, row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::list exprs; exprs.push_back(&bin_pre); @@ -337,30 +337,30 @@ TEST_F(OlapScanNodeTest, PushDownBinaryEqualPredicate) { scan_node.push_down_predicate(&_runtime_stat, &exprs); status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num = std::min(row_batch.num_rows(), 10); - ASSERT_TRUE(num > 0); + EXPECT_TRUE(num > 0); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); LOG(WARNING) << "input row: " << print_row(row, scan_node._row_descriptor); - ASSERT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); + EXPECT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); } eos = true; } - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } TEST_F(OlapScanNodeTest, PushDownInPredicateCase) { @@ -390,7 +390,7 @@ TEST_F(OlapScanNodeTest, PushDownInPredicateCase) { in_pre._children.push_back(_obj_pool.add(new SlotRef(slot_node))); Status status = in_pre.prepare(&_runtime_stat, row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = -5000; i < -4999; ++i) { in_pre.insert(&i); @@ -402,42 +402,30 @@ TEST_F(OlapScanNodeTest, PushDownInPredicateCase) { scan_node.push_down_predicate(&_runtime_stat, &exprs); status = scan_node.prepare(&_runtime_stat); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(&_runtime_stat); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(scan_node.set_scan_ranges(_scan_ranges).ok()); RowBatch row_batch(scan_node._row_descriptor, _runtime_stat.batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(&_runtime_stat, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num = std::min(row_batch.num_rows(), 10); - ASSERT_TRUE(num > 0); + EXPECT_TRUE(num > 0); for (int i = 0; i < num; ++i) { TupleRow* row = row_batch.get_row(i); LOG(WARNING) << "input row: " << print_row(row, scan_node._row_descriptor); - ASSERT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); + EXPECT_EQ("[(-5000 -5000 -5000 1)]", print_row(row, scan_node._row_descriptor)); } eos = true; } - ASSERT_TRUE(scan_node.close(&_runtime_stat).ok()); + EXPECT_TRUE(scan_node.close(&_runtime_stat).ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/olap_scanner_test.cpp b/be/test/exec/olap_scanner_test.cpp index 82111a31f4..1daa7a92d7 100644 --- a/be/test/exec/olap_scanner_test.cpp +++ b/be/test/exec/olap_scanner_test.cpp @@ -80,15 +80,3 @@ void construct_one_tuple(TupleDescriptor& tuple_desc) { TEST(OlapIdlUtilTest, normalcase) {} } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/orc_scanner_test.cpp b/be/test/exec/orc_scanner_test.cpp index 4a3fe3390a..f5f99924f2 100644 --- a/be/test/exec/orc_scanner_test.cpp +++ b/be/test/exec/orc_scanner_test.cpp @@ -409,7 +409,7 @@ TEST_F(OrcScannerTest, normal) { ORCScanner scanner(&_runtime_state, _profile, params, ranges, _addresses, _pre_filter, &_counter); - ASSERT_TRUE(scanner.open().ok()); + EXPECT_TRUE(scanner.open().ok()); auto tracker = std::make_shared(); MemPool tuple_pool(tracker.get()); @@ -417,18 +417,18 @@ TEST_F(OrcScannerTest, normal) { Tuple* tuple = (Tuple*)tuple_pool.allocate(_desc_tbl->get_tuple_descriptor(1)->byte_size()); bool eof = false; - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(0 null doris 1.567 1.567000031471252 12345 1 doris)"); - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(1 true doris 1.567 1.567000031471252 12345 1 doris)"); - ASSERT_FALSE(eof); + EXPECT_FALSE(eof); for (int i = 2; i < 10; i++) { - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); } - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_TRUE(eof); scanner.close(); } @@ -533,17 +533,17 @@ TEST_F(OrcScannerTest, normal2) { ORCScanner scanner(&_runtime_state, _profile, params, ranges, _addresses, _pre_filter, &_counter); - ASSERT_TRUE(scanner.open().ok()); + EXPECT_TRUE(scanner.open().ok()); auto tracker = std::make_shared(); MemPool tuple_pool(tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(_desc_tbl->get_tuple_descriptor(1)->byte_size()); bool eof = false; - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(null)"); - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(true)"); + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(null)"); + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(true)"); scanner.close(); } @@ -883,23 +883,18 @@ TEST_F(OrcScannerTest, normal3) { ORCScanner scanner(&_runtime_state, _profile, params, ranges, _addresses, _pre_filter, &_counter); - ASSERT_TRUE(scanner.open().ok()); + EXPECT_TRUE(scanner.open().ok()); auto tracker = std::make_shared(); MemPool tuple_pool(tracker.get()); Tuple* tuple = (Tuple*)tuple_pool.allocate(_desc_tbl->get_tuple_descriptor(1)->byte_size()); bool eof = false; - ASSERT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); - ASSERT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), + EXPECT_TRUE(scanner.get_next(tuple, &tuple_pool, &eof, &_fill_tuple).ok()); + EXPECT_EQ(Tuple::to_string(tuple, *_desc_tbl->get_tuple_descriptor(1)), "(0.123456789 1.12 -1.12345 0.12345 0 1 2020-01-14 14:12:19 2020-02-10 " "-0.0014)"); scanner.close(); } } // end namespace doris -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/parquet_scanner_test.cpp b/be/test/exec/parquet_scanner_test.cpp index 7a1bf8a38d..8db72313ba 100644 --- a/be/test/exec/parquet_scanner_test.cpp +++ b/be/test/exec/parquet_scanner_test.cpp @@ -96,7 +96,7 @@ int ParquetScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int nex slot_desc.slotType = type; slot_desc.columnPos = i; // Skip the first 8 bytes These 8 bytes are used to indicate whether the field is a null value - slot_desc.byteOffset = i * 16 + 8; + slot_desc.byteOffset = i * 16 + 8; slot_desc.nullIndicatorByte = i / 8; slot_desc.nullIndicatorBit = i % 8; slot_desc.colName = columnNames[i]; @@ -111,7 +111,7 @@ int ParquetScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int nex TTupleDescriptor t_tuple_desc; t_tuple_desc.id = TUPLE_ID_SRC; //Here 8 bytes in order to handle null values - t_tuple_desc.byteSize = COLUMN_NUMBERS * 16 + 8; + t_tuple_desc.byteSize = COLUMN_NUMBERS * 16 + 8; t_tuple_desc.numNullBytes = 0; t_tuple_desc.tableId = 0; t_tuple_desc.__isset.tableId = true; @@ -121,8 +121,9 @@ int ParquetScannerTest::create_src_tuple(TDescriptorTable& t_desc_table, int nex } int ParquetScannerTest::create_dst_tuple(TDescriptorTable& t_desc_table, int next_slot_id) { - int32_t byteOffset = 8; // Skip the first 8 bytes These 8 bytes are used to indicate whether the field is a null value - { //log_version + int32_t byteOffset = + 8; // Skip the first 8 bytes These 8 bytes are used to indicate whether the field is a null value + { //log_version TSlotDescriptor slot_desc; slot_desc.id = next_slot_id++; @@ -424,7 +425,7 @@ TEST_F(ParquetScannerTest, normal) { BrokerScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); auto status = scan_node.prepare(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // set scan range std::vector scan_ranges; @@ -439,7 +440,7 @@ TEST_F(ParquetScannerTest, normal) { range.format_type = TFileFormatType::FORMAT_PARQUET; range.splittable = true; - std::vector columns_from_path{"value"}; + std::vector columns_from_path {"value"}; range.__set_columns_from_path(columns_from_path); range.__set_num_of_columns_from_file(19); #if 1 @@ -460,28 +461,28 @@ TEST_F(ParquetScannerTest, normal) { scan_node.set_scan_ranges(scan_ranges); status = scan_node.open(&_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Get batch RowBatch batch(scan_node.row_desc(), _runtime_state.batch_size()); bool eof = false; for (int i = 0; i < 14; i++) { status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(2048, batch.num_rows()); - ASSERT_FALSE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(2048, batch.num_rows()); + EXPECT_FALSE(eof); batch.reset(); } status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(1328, batch.num_rows()); - ASSERT_FALSE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(1328, batch.num_rows()); + EXPECT_FALSE(eof); batch.reset(); status = scan_node.get_next(&_runtime_state, &batch, &eof); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, batch.num_rows()); - ASSERT_TRUE(eof); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, batch.num_rows()); + EXPECT_TRUE(eof); scan_node.close(&_runtime_state); { @@ -492,9 +493,3 @@ TEST_F(ParquetScannerTest, normal) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/plain_text_line_reader_bzip_test.cpp b/be/test/exec/plain_text_line_reader_bzip_test.cpp index 8a2868a2fe..747313c803 100644 --- a/be/test/exec/plain_text_line_reader_bzip_test.cpp +++ b/be/test/exec/plain_text_line_reader_bzip_test.cpp @@ -40,11 +40,11 @@ TEST_F(PlainTextLineReaderTest, bzip2_normal_use) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/test_file.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -53,170 +53,170 @@ TEST_F(PlainTextLineReaderTest, bzip2_normal_use) { // 1,2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); // 1,2,3,4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(7, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(7, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); delete decompressor; } TEST_F(PlainTextLineReaderTest, bzip2_test_limit) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 8, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); delete decompressor; } TEST_F(PlainTextLineReaderTest, bzip2_test_limit2) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 6, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, bzip2_test_limit3) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, bzip2_test_limit4) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, bzip2_test_limit5) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.bz2", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::BZIP2, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 0, "\n", 1); const uint8_t* ptr; @@ -225,19 +225,8 @@ TEST_F(PlainTextLineReaderTest, bzip2_test_limit5) { // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/plain_text_line_reader_gzip_test.cpp b/be/test/exec/plain_text_line_reader_gzip_test.cpp index 2f6d190b49..1e461e8b82 100644 --- a/be/test/exec/plain_text_line_reader_gzip_test.cpp +++ b/be/test/exec/plain_text_line_reader_gzip_test.cpp @@ -24,9 +24,9 @@ namespace doris { -class PlainTextLineReaderTest : public testing::Test { +class PlainTextLineReaderGzipTest : public testing::Test { public: - PlainTextLineReaderTest() : _profile("TestProfile") {} + PlainTextLineReaderGzipTest() : _profile("TestProfile") {} protected: virtual void SetUp() {} @@ -36,15 +36,15 @@ private: RuntimeProfile _profile; }; -TEST_F(PlainTextLineReaderTest, gzip_normal_use) { +TEST_F(PlainTextLineReaderGzipTest, gzip_normal_use) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/test_file.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -53,50 +53,50 @@ TEST_F(PlainTextLineReaderTest, gzip_normal_use) { // 1,2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); // 1,2,3,4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(7, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(7, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); delete decompressor; } -TEST_F(PlainTextLineReaderTest, uncompressed_no_newline) { +TEST_F(PlainTextLineReaderGzipTest, uncompressed_no_newline) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/no_newline.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -105,154 +105,154 @@ TEST_F(PlainTextLineReaderTest, uncompressed_no_newline) { // 1,2,3 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_STREQ("1,2,3", std::string((char*)ptr, size).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_STREQ("1,2,3", std::string((char*)ptr, size).c_str()); + EXPECT_FALSE(eof); // 4,5 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_STREQ("4,5", std::string((char*)ptr, size).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_STREQ("4,5", std::string((char*)ptr, size).c_str()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); delete decompressor; } -TEST_F(PlainTextLineReaderTest, gzip_test_limit) { +TEST_F(PlainTextLineReaderGzipTest, gzip_test_limit) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 8, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } -TEST_F(PlainTextLineReaderTest, gzip_test_limit2) { +TEST_F(PlainTextLineReaderGzipTest, gzip_test_limit2) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 6, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); delete decompressor; } -TEST_F(PlainTextLineReaderTest, gzip_test_limit3) { +TEST_F(PlainTextLineReaderGzipTest, gzip_test_limit3) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } -TEST_F(PlainTextLineReaderTest, gzip_test_limit4) { +TEST_F(PlainTextLineReaderGzipTest, gzip_test_limit4) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } -TEST_F(PlainTextLineReaderTest, gzip_test_limit5) { +TEST_F(PlainTextLineReaderGzipTest, gzip_test_limit5) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.gz", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::GZIP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 0, "\n", 1); const uint8_t* ptr; @@ -261,19 +261,8 @@ TEST_F(PlainTextLineReaderTest, gzip_test_limit5) { // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/plain_text_line_reader_lz4frame_test.cpp b/be/test/exec/plain_text_line_reader_lz4frame_test.cpp index f78d7366da..0ebd218b28 100644 --- a/be/test/exec/plain_text_line_reader_lz4frame_test.cpp +++ b/be/test/exec/plain_text_line_reader_lz4frame_test.cpp @@ -40,11 +40,11 @@ TEST_F(PlainTextLineReaderTest, lz4_normal_use) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/test_file.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -53,170 +53,170 @@ TEST_F(PlainTextLineReaderTest, lz4_normal_use) { // 1,2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); // 1,2,3,4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(7, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(7, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); delete decompressor; } TEST_F(PlainTextLineReaderTest, lz4_test_limit) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 8, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); delete decompressor; } TEST_F(PlainTextLineReaderTest, lz4_test_limit2) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 6, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, lz4_test_limit3) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, lz4_test_limit4) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } TEST_F(PlainTextLineReaderTest, lz4_test_limit5) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lz4", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZ4FRAME, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 0, "\n", 1); const uint8_t* ptr; @@ -225,19 +225,8 @@ TEST_F(PlainTextLineReaderTest, lz4_test_limit5) { // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); delete decompressor; } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/plain_text_line_reader_lzop_test.cpp b/be/test/exec/plain_text_line_reader_lzop_test.cpp index 5f83afc399..f8f8b6090d 100644 --- a/be/test/exec/plain_text_line_reader_lzop_test.cpp +++ b/be/test/exec/plain_text_line_reader_lzop_test.cpp @@ -40,11 +40,11 @@ TEST_F(PlainTextLineReaderTest, lzop_normal_use) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/test_file.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -53,165 +53,165 @@ TEST_F(PlainTextLineReaderTest, lzop_normal_use) { // 1,2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); // 1,2,3,4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(7, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(7, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } TEST_F(PlainTextLineReaderTest, lzop_test_limit) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 8, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); } TEST_F(PlainTextLineReaderTest, lzop_test_limit2) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 6, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } TEST_F(PlainTextLineReaderTest, lzop_test_limit3) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } TEST_F(PlainTextLineReaderTest, lzop_test_limit4) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } TEST_F(PlainTextLineReaderTest, lzop_test_limit5) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 0, "\n", 1); const uint8_t* ptr; @@ -220,18 +220,18 @@ TEST_F(PlainTextLineReaderTest, lzop_test_limit5) { // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } TEST_F(PlainTextLineReaderTest, lzop_test_larger) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/larger.txt.lzo", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::LZOP, &decompressor); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -240,62 +240,51 @@ TEST_F(PlainTextLineReaderTest, lzop_test_larger) { // 1 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(20, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(20, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(30, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(30, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 3 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(9, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(9, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 5 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(30, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(30, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 6 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // 7 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_TRUE(eof); } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/plain_text_line_reader_uncompressed_test.cpp b/be/test/exec/plain_text_line_reader_uncompressed_test.cpp index 6568b4fbd8..b9361999b4 100644 --- a/be/test/exec/plain_text_line_reader_uncompressed_test.cpp +++ b/be/test/exec/plain_text_line_reader_uncompressed_test.cpp @@ -24,9 +24,9 @@ namespace doris { -class PlainTextLineReaderTest : public testing::Test { +class PlainTextLineReaderUncompressedTest : public testing::Test { public: - PlainTextLineReaderTest() : _profile("TestProfile") {} + PlainTextLineReaderUncompressedTest() : _profile("TestProfile") {} protected: virtual void SetUp() {} @@ -36,15 +36,15 @@ private: RuntimeProfile _profile; }; -TEST_F(PlainTextLineReaderTest, uncompressed_normal_use) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_normal_use) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/test_file.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -53,50 +53,50 @@ TEST_F(PlainTextLineReaderTest, uncompressed_normal_use) { // 1,2 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, size); + EXPECT_FALSE(eof); // 1,2,3,4 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(7, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(7, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_no_newline) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_no_newline) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/no_newline.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, -1, "\n", 1); const uint8_t* ptr; @@ -105,158 +105,158 @@ TEST_F(PlainTextLineReaderTest, uncompressed_no_newline) { // 1,2,3 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_STREQ("1,2,3", std::string((char*)ptr, size).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_STREQ("1,2,3", std::string((char*)ptr, size).c_str()); + EXPECT_FALSE(eof); // 4,5 st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(3, size); - ASSERT_STREQ("4,5", std::string((char*)ptr, size).c_str()); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(3, size); + EXPECT_STREQ("4,5", std::string((char*)ptr, size).c_str()); + EXPECT_FALSE(eof); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_limit) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_limit) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 8, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); + EXPECT_FALSE(eof); LOG(INFO) << std::string((const char*)ptr, size); st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_limit2) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_limit2) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 6, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_limit3) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_limit3) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_limit4) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_limit4) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 7, "\n", 1); const uint8_t* ptr; size_t size; bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, size); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, size); LOG(INFO) << std::string((const char*)ptr, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(eof); - ASSERT_EQ(0, size); + EXPECT_TRUE(st.ok()); + EXPECT_FALSE(eof); + EXPECT_EQ(0, size); // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_limit5) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_limit5) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/limit.csv", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 0, "\n", 1); const uint8_t* ptr; @@ -265,19 +265,19 @@ TEST_F(PlainTextLineReaderTest, uncompressed_test_limit5) { // Empty st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } -TEST_F(PlainTextLineReaderTest, uncompressed_test_empty) { +TEST_F(PlainTextLineReaderUncompressedTest, uncompressed_test_empty) { LocalFileReader file_reader("./be/test/exec/test_data/plain_text_line_reader/empty.txt", 0); auto st = file_reader.open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); Decompressor* decompressor; st = Decompressor::create_decompressor(CompressType::UNCOMPRESSED, &decompressor); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(decompressor == nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(decompressor == nullptr); // set min length larger than 0 to test PlainTextLineReader line_reader(&_profile, &file_reader, decompressor, 10, "\n", 1); @@ -286,19 +286,8 @@ TEST_F(PlainTextLineReaderTest, uncompressed_test_empty) { bool eof; st = line_reader.read_line(&ptr, &size, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(eof); } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/s3_reader_test.cpp b/be/test/exec/s3_reader_test.cpp index a750f7b319..3c11a19180 100644 --- a/be/test/exec/s3_reader_test.cpp +++ b/be/test/exec/s3_reader_test.cpp @@ -36,6 +36,9 @@ static const std::string SK = ""; static const std::string ENDPOINT = "http://s3.bj.bcebos.com"; static const std::string REGION = "bj"; static const std::string BUCKET = "s3://yang-repo/"; + +// remove DISABLED_ when need run this test +#define S3ReaderTest DISABLED_S3ReaderTest class S3ReaderTest : public testing::Test { public: S3ReaderTest() @@ -76,49 +79,41 @@ TEST_F(S3ReaderTest, normal) { std::string path = _s3_base_path + "/test_file"; std::unique_ptr writer(new S3Writer(_aws_properties, path, 0)); auto st = writer->open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); size_t l = 0; st = writer->write(reinterpret_cast(_content.c_str()), _content.length(), &l); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(_content.length(), l); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(_content.length(), l); st = writer->close(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::unique_ptr writer1(new S3Writer(_aws_properties, path, 0)); st = writer1->open(); - ASSERT_TRUE(st.is_already_exist()); + EXPECT_TRUE(st.is_already_exist()); std::unique_ptr reader(new S3Reader(_aws_properties, path, 0)); st = reader->open(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::unique_ptr reader1(new S3Reader(_aws_properties, path + "xx", 0)); st = reader1->open(); - ASSERT_TRUE(st.is_not_found()); - ASSERT_EQ(_content.length(), reader->size()); + EXPECT_TRUE(st.is_not_found()); + EXPECT_EQ(_content.length(), reader->size()); std::string verification_contents; verification_contents.resize(_content.length()); int64_t total_read = 0; bool eof = false; st = reader->read((uint8_t*)&verification_contents[0], _content.length(), &total_read, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(_content, verification_contents); - ASSERT_EQ(_content.length(), total_read); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(_content, verification_contents); + EXPECT_EQ(_content.length(), total_read); + EXPECT_FALSE(eof); st = reader->read((uint8_t*)&verification_contents[0], _content.length(), &total_read, &eof); - ASSERT_TRUE(eof); + EXPECT_TRUE(eof); int64_t t = 0; st = reader->tell(&t); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(_content.length(), t); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(_content.length(), t); st = reader->readat(_content.length(), _content.length(), (int64_t*)(&total_read), (uint8_t*)&verification_contents[0]); LOG(INFO) << total_read; - ASSERT_TRUE(total_read == 0); + EXPECT_TRUE(total_read == 0); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - int ret = 0; - // ak sk is secret - // ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/exec/schema_scan_node_test.cpp b/be/test/exec/schema_scan_node_test.cpp index 25c49d9d17..3027c7787c 100644 --- a/be/test/exec/schema_scan_node_test.cpp +++ b/be/test/exec/schema_scan_node_test.cpp @@ -112,24 +112,24 @@ private: TEST_F(SchemaScanNodeTest, normal_use) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.prepare(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector scan_ranges; status = scan_node.set_scan_ranges(scan_ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::stringstream out; scan_node.debug_string(1, &out); LOG(WARNING) << out.str(); status = scan_node.open(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos = false; while (!eos) { status = scan_node.get_next(&runtime_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { for (int i = 0; i < row_batch.num_rows(); ++i) { @@ -140,21 +140,21 @@ TEST_F(SchemaScanNodeTest, normal_use) { } status = scan_node.close(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(SchemaScanNodeTest, Prepare_fail_1) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); TableDescriptor* old = _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc; _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc = nullptr; Status status = scan_node.prepare(&runtime_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); _desc_tbl->_tuple_desc_map[(TupleId)0]->_table_desc = old; } TEST_F(SchemaScanNodeTest, Prepare_fail_2) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node._tuple_id = 1; Status status = scan_node.prepare(&runtime_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaScanNodeTest, dummy) { SchemaTableDescriptor* t_desc = @@ -162,24 +162,24 @@ TEST_F(SchemaScanNodeTest, dummy) { t_desc->_schema_table_type = TSchemaTableType::SCH_EVENTS; SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.prepare(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector scan_ranges; status = scan_node.set_scan_ranges(scan_ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::stringstream out; scan_node.debug_string(1, &out); LOG(WARNING) << out.str(); status = scan_node.open(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos = false; while (!eos) { status = scan_node.get_next(&runtime_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { for (int i = 0; i < row_batch.num_rows(); ++i) { @@ -190,52 +190,41 @@ TEST_F(SchemaScanNodeTest, dummy) { } status = scan_node.close(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); t_desc->_schema_table_type = TSchemaTableType::SCH_AUTHORS; } TEST_F(SchemaScanNodeTest, get_dest_desc_fail) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node._tuple_id = 1; Status status = scan_node.prepare(&runtime_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaScanNodeTest, invalid_param) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); Status status = scan_node.prepare(nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scan_node.prepare(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scan_node.open(&runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos; status = scan_node.get_next(nullptr, &row_batch, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaScanNodeTest, no_init) { SchemaScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); //Status status = scan_node.prepare(&runtime_state); - //ASSERT_TRUE(status.ok()); + //EXPECT_TRUE(status.ok()); Status status = scan_node.open(&runtime_state); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, 100); bool eos; status = scan_node.get_next(&runtime_state, &row_batch, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_authors_scanner_test.cpp b/be/test/exec/schema_scanner/schema_authors_scanner_test.cpp index 91d761845d..298d4439f2 100644 --- a/be/test/exec/schema_scanner/schema_authors_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_authors_scanner_test.cpp @@ -50,16 +50,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaAuthorScannerTest, normal_use) { SchemaAuthorsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; while (!eos) { status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < 3; ++i) { LOG(INFO) << ((StringValue*)tuple->get_slot(tuple_desc->slots()[i]->tuple_offset()))->ptr; @@ -70,40 +70,29 @@ TEST_F(SchemaAuthorScannerTest, normal_use) { TEST_F(SchemaAuthorScannerTest, use_with_no_init) { SchemaAuthorsScanner scanner; const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaAuthorScannerTest, invalid_param) { SchemaAuthorsScanner scanner; Status status = scanner.init(&_param, nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, nullptr, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_charsets_scanner_test.cpp b/be/test/exec/schema_scanner/schema_charsets_scanner_test.cpp index eb2cae61d6..83b77f5007 100644 --- a/be/test/exec/schema_scanner/schema_charsets_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_charsets_scanner_test.cpp @@ -51,16 +51,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaCharsetsScannerTest, normal_use) { SchemaCharsetsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; while (!eos) { status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { LOG(INFO) << print_tuple(tuple, *tuple_desc); } @@ -70,40 +70,29 @@ TEST_F(SchemaCharsetsScannerTest, normal_use) { TEST_F(SchemaCharsetsScannerTest, use_with_no_init) { SchemaCharsetsScanner scanner; const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCharsetsScannerTest, invalid_param) { SchemaCharsetsScanner scanner; Status status = scanner.init(&_param, nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, nullptr, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_collations_scanner_test.cpp b/be/test/exec/schema_scanner/schema_collations_scanner_test.cpp index 9f7a523a0c..e215ed3c0c 100644 --- a/be/test/exec/schema_scanner/schema_collations_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_collations_scanner_test.cpp @@ -51,16 +51,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaCollationsScannerTest, normal_use) { SchemaCollationsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; while (!eos) { status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { LOG(INFO) << print_tuple(tuple, *tuple_desc); } @@ -70,40 +70,29 @@ TEST_F(SchemaCollationsScannerTest, normal_use) { TEST_F(SchemaCollationsScannerTest, use_with_no_init) { SchemaCollationsScanner scanner; const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCollationsScannerTest, invalid_param) { SchemaCollationsScanner scanner; Status status = scanner.init(&_param, nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, nullptr, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_columns_scanner_test.cpp b/be/test/exec/schema_scanner/schema_columns_scanner_test.cpp index 3da4075903..d2d6c632b6 100644 --- a/be/test/exec/schema_scanner/schema_columns_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_columns_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaColumnsScannerTest, normal_use) { SchemaColumnsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaColumnsScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaColumnsScannerTest, one_column) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaColumnsScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaColumnsScannerTest, op_before_init) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaColumnsScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaColumnsScannerTest, input_fail) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaColumnsScannerTest, table_fail) { table_num = 1; @@ -160,16 +160,16 @@ TEST_F(SchemaColumnsScannerTest, table_fail) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_table_result = Status::InternalError("get table failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaColumnsScannerTest, desc_fail) { table_num = 1; @@ -177,16 +177,16 @@ TEST_F(SchemaColumnsScannerTest, desc_fail) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_desc_result = Status::InternalError("get desc failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaColumnsScannerTest, start_fail) { @@ -195,21 +195,10 @@ TEST_F(SchemaColumnsScannerTest, start_fail) { desc_num = 1; SchemaColumnsScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_create_table_scanner_test.cpp b/be/test/exec/schema_scanner/schema_create_table_scanner_test.cpp index 8520b81262..80ae9ec4f1 100644 --- a/be/test/exec/schema_scanner/schema_create_table_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_create_table_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaCreateTableScannerTest, normal_use) { SchemaCreateTableScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaCreateTableScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaCreateTableScannerTest, one_column) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaCreateTableScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaCreateTableScannerTest, op_before_init) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCreateTableScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaCreateTableScannerTest, input_fail) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCreateTableScannerTest, table_fail) { table_num = 1; @@ -160,16 +160,16 @@ TEST_F(SchemaCreateTableScannerTest, table_fail) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_table_result = Status::InternalError("get table failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCreateTableScannerTest, desc_fail) { table_num = 1; @@ -177,16 +177,16 @@ TEST_F(SchemaCreateTableScannerTest, desc_fail) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_desc_result = Status::InternalError("get desc failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaCreateTableScannerTest, start_fail) { @@ -195,21 +195,10 @@ TEST_F(SchemaCreateTableScannerTest, start_fail) { desc_num = 1; SchemaCreateTableScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_engines_scanner_test.cpp b/be/test/exec/schema_scanner/schema_engines_scanner_test.cpp index 44d6375f1e..15fb923ece 100644 --- a/be/test/exec/schema_scanner/schema_engines_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_engines_scanner_test.cpp @@ -51,16 +51,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaEnginesScannerTest, normal_use) { SchemaEnginesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; while (!eos) { status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { LOG(INFO) << print_tuple(tuple, *tuple_desc); } @@ -70,40 +70,29 @@ TEST_F(SchemaEnginesScannerTest, normal_use) { TEST_F(SchemaEnginesScannerTest, use_with_no_init) { SchemaEnginesScanner scanner; const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaEnginesScannerTest, invalid_param) { SchemaEnginesScanner scanner; Status status = scanner.init(&_param, nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, nullptr, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_open_tables_scanner_test.cpp b/be/test/exec/schema_scanner/schema_open_tables_scanner_test.cpp index 488e00eba2..bee3fb8ad4 100644 --- a/be/test/exec/schema_scanner/schema_open_tables_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_open_tables_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaOpenTablesScannerTest, normal_use) { SchemaOpenTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaOpenTablesScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaOpenTablesScannerTest, one_column) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaOpenTablesScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaOpenTablesScannerTest, op_before_init) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaOpenTablesScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaOpenTablesScannerTest, input_fail) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaOpenTablesScannerTest, table_fail) { table_num = 1; @@ -160,16 +160,16 @@ TEST_F(SchemaOpenTablesScannerTest, table_fail) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_table_result = Status::InternalError("get table failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaOpenTablesScannerTest, desc_fail) { table_num = 1; @@ -177,16 +177,16 @@ TEST_F(SchemaOpenTablesScannerTest, desc_fail) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_desc_result = Status::InternalError("get desc failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaOpenTablesScannerTest, start_fail) { @@ -195,21 +195,10 @@ TEST_F(SchemaOpenTablesScannerTest, start_fail) { desc_num = 1; SchemaOpenTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_schemata_scanner_test.cpp b/be/test/exec/schema_scanner/schema_schemata_scanner_test.cpp index ea823bed5d..b322fc36a9 100644 --- a/be/test/exec/schema_scanner/schema_schemata_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_schemata_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaSchemataScannerTest, normal_use) { SchemaSchemataScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaSchemataScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaSchemataScannerTest, one_column) { desc_num = 1; SchemaSchemataScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaSchemataScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaSchemataScannerTest, op_before_init) { desc_num = 1; SchemaSchemataScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaSchemataScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaSchemataScannerTest, input_fail) { desc_num = 1; SchemaSchemataScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaSchemataScannerTest, start_fail) { @@ -161,21 +161,10 @@ TEST_F(SchemaSchemataScannerTest, start_fail) { desc_num = 1; SchemaSchemataScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_table_names_scanner_test.cpp b/be/test/exec/schema_scanner/schema_table_names_scanner_test.cpp index 6e8ce962e4..cc38d22c80 100644 --- a/be/test/exec/schema_scanner/schema_table_names_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_table_names_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaTableNamesScannerTest, normal_use) { SchemaTableNamesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaTableNamesScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaTableNamesScannerTest, one_column) { desc_num = 1; SchemaTableNamesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaTableNamesScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaTableNamesScannerTest, op_before_init) { desc_num = 1; SchemaTableNamesScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTableNamesScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaTableNamesScannerTest, input_fail) { desc_num = 1; SchemaTableNamesScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTableNamesScannerTest, table_fail) { table_num = 1; @@ -160,16 +160,16 @@ TEST_F(SchemaTableNamesScannerTest, table_fail) { desc_num = 1; SchemaTableNamesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_table_result = Status::InternalError("get table failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTableNamesScannerTest, start_fail) { @@ -178,21 +178,10 @@ TEST_F(SchemaTableNamesScannerTest, start_fail) { desc_num = 1; SchemaTableNamesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_tables_scanner_test.cpp b/be/test/exec/schema_scanner/schema_tables_scanner_test.cpp index 7ccc12cb11..4fbc399fd9 100644 --- a/be/test/exec/schema_scanner/schema_tables_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_tables_scanner_test.cpp @@ -96,16 +96,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaTablesScannerTest, normal_use) { SchemaTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaTablesScannerTest, one_column) { table_num = 1; @@ -113,19 +113,19 @@ TEST_F(SchemaTablesScannerTest, one_column) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(eos); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(eos); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(eos); } TEST_F(SchemaTablesScannerTest, op_before_init) { table_num = 1; @@ -133,11 +133,11 @@ TEST_F(SchemaTablesScannerTest, op_before_init) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTablesScannerTest, input_fail) { table_num = 1; @@ -145,14 +145,14 @@ TEST_F(SchemaTablesScannerTest, input_fail) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.init(nullptr, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool eos = false; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTablesScannerTest, table_fail) { table_num = 1; @@ -160,16 +160,16 @@ TEST_F(SchemaTablesScannerTest, table_fail) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_table_result = Status::InternalError("get table failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTablesScannerTest, desc_fail) { table_num = 1; @@ -177,16 +177,16 @@ TEST_F(SchemaTablesScannerTest, desc_fail) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; s_desc_result = Status::InternalError("get desc failed"); status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaTablesScannerTest, start_fail) { @@ -195,21 +195,10 @@ TEST_F(SchemaTablesScannerTest, start_fail) { desc_num = 1; SchemaTablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); s_db_result = Status::InternalError("get db failed."); status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner/schema_variables_scanner_test.cpp b/be/test/exec/schema_scanner/schema_variables_scanner_test.cpp index 01f7f9614c..714d2cee80 100644 --- a/be/test/exec/schema_scanner/schema_variables_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_variables_scanner_test.cpp @@ -52,16 +52,16 @@ char g_tuple_buf[10000]; // enough for tuple TEST_F(SchemaVariablesScannerTest, normal_use) { SchemaVariablesScanner scanner; Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; while (!eos) { status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!eos) { LOG(INFO) << print_tuple(tuple, *tuple_desc); } @@ -71,40 +71,29 @@ TEST_F(SchemaVariablesScannerTest, normal_use) { TEST_F(SchemaVariablesScannerTest, use_with_no_init) { SchemaVariablesScanner scanner; const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaVariablesScannerTest, invalid_param) { SchemaVariablesScanner scanner; Status status = scanner.init(&_param, nullptr); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); + EXPECT_TRUE(nullptr != tuple_desc); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos = false; status = scanner.get_next_row(tuple, nullptr, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/schema_scanner_test.cpp b/be/test/exec/schema_scanner_test.cpp index 2f8c36a17b..4bb9d6ff8d 100644 --- a/be/test/exec/schema_scanner_test.cpp +++ b/be/test/exec/schema_scanner_test.cpp @@ -59,62 +59,51 @@ TEST_F(SchemaScannerTest, normal_use) { SchemaScanner scanner(s_test_columns, sizeof(s_test_columns) / sizeof(SchemaScanner::ColumnDesc)); Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); - ASSERT_EQ(65, tuple_desc->byte_size()); + EXPECT_TRUE(nullptr != tuple_desc); + EXPECT_EQ(65, tuple_desc->byte_size()); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(SchemaScannerTest, input_fail) { SchemaScanner scanner(s_test_columns, sizeof(s_test_columns) / sizeof(SchemaScanner::ColumnDesc)); Status status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.init(&_param, &_obj_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scanner.start((RuntimeState*)1); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr != tuple_desc); - ASSERT_EQ(65, tuple_desc->byte_size()); + EXPECT_TRUE(nullptr != tuple_desc); + EXPECT_EQ(65, tuple_desc->byte_size()); bool eos; status = scanner.get_next_row(nullptr, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaScannerTest, invalid_param) { SchemaScanner scanner(nullptr, sizeof(s_test_columns) / sizeof(SchemaScanner::ColumnDesc)); Status status = scanner.init(&_param, &_obj_pool); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(SchemaScannerTest, no_init_use) { SchemaScanner scanner(s_test_columns, sizeof(s_test_columns) / sizeof(SchemaScanner::ColumnDesc)); Status status = scanner.start((RuntimeState*)1); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); const TupleDescriptor* tuple_desc = scanner.tuple_desc(); - ASSERT_TRUE(nullptr == tuple_desc); + EXPECT_TRUE(nullptr == tuple_desc); Tuple* tuple = (Tuple*)g_tuple_buf; bool eos; status = scanner.get_next_row(tuple, &_mem_pool, &eos); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/set_executor_test.cpp b/be/test/exec/set_executor_test.cpp index deb60ea233..5628c90f32 100644 --- a/be/test/exec/set_executor_test.cpp +++ b/be/test/exec/set_executor_test.cpp @@ -84,7 +84,7 @@ TEST_F(SetExecutorTest, normal_case) { SetExecutor executor(&doris_server, params); RowDescriptor row_desc; Status status = executor.prepare((RuntimeState*)&_runtime_state, row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); LOG(INFO) << executor.debug_string(); } TEST_F(SetExecutorTest, failed_case) { @@ -107,19 +107,7 @@ TEST_F(SetExecutorTest, failed_case) { SetExecutor executor(&doris_server, params); RowDescriptor row_desc; Status status = executor.prepare((RuntimeState*)&_runtime_state, row_desc); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); LOG(INFO) << executor.debug_string(); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/tablet_info_test.cpp b/be/test/exec/tablet_info_test.cpp index 9a731de837..423737d86e 100644 --- a/be/test/exec/tablet_info_test.cpp +++ b/be/test/exec/tablet_info_test.cpp @@ -74,7 +74,7 @@ TEST_F(OlapTablePartitionParamTest, normal) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << schema->debug_string(); // (-oo, 10] | [10.50) | [60, +oo) @@ -135,13 +135,13 @@ TEST_F(OlapTablePartitionParamTest, normal) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << part.debug_string(); ObjectPool pool; DescriptorTbl* desc_tbl = nullptr; st = DescriptorTbl::create(&pool, t_desc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowDescriptor row_desc(*desc_tbl, {0}, {false}); TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); RowBatch batch(row_desc, 1024); @@ -160,8 +160,8 @@ TEST_F(OlapTablePartitionParamTest, normal) { // 9: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(10, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(10, partition->id); } // 13, 25, "abcd" { @@ -178,8 +178,8 @@ TEST_F(OlapTablePartitionParamTest, normal) { // 25: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(11, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(11, partition->id); } // 14, 50, "abcde" { @@ -196,7 +196,7 @@ TEST_F(OlapTablePartitionParamTest, normal) { // 50: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } // 15, 60, "abcdef" @@ -214,8 +214,8 @@ TEST_F(OlapTablePartitionParamTest, normal) { // 60: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(12, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(12, partition->id); } } @@ -233,7 +233,7 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << schema->debug_string(); // 1 | 2 | 3 | 4 | 5 | 6 @@ -327,13 +327,13 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << part.debug_string(); ObjectPool pool; DescriptorTbl* desc_tbl = nullptr; st = DescriptorTbl::create(&pool, t_desc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowDescriptor row_desc(*desc_tbl, {0}, {false}); TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); RowBatch batch(row_desc, 1024); @@ -352,8 +352,8 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { // 1: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(10, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(10, partition->id); } // 13, 3, "abcd" { @@ -370,8 +370,8 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { // 3: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(11, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(11, partition->id); } // 14, 50, "abcde" { @@ -388,7 +388,7 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { // 50: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } // 15, 6, "abcdef" @@ -406,8 +406,8 @@ TEST_F(OlapTablePartitionParamTest, single_list_partition) { // 6: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(12, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(12, partition->id); } } @@ -427,7 +427,7 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << schema->debug_string(); // 1 @@ -444,14 +444,14 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { node_2.num_children = 0; node_2.__isset.int_literal = true; node_2.int_literal.value = 2; - // beijing + // beijing TExprNode node_b; node_b.node_type = TExprNodeType::STRING_LITERAL; node_b.type = t_desc_tbl.slotDescriptors[2].slotType; node_b.num_children = 0; node_b.__isset.string_literal = true; node_b.string_literal.value = "beijing"; - // shanghai + // shanghai TExprNode node_s; node_s.node_type = TExprNodeType::STRING_LITERAL; node_s.type = t_desc_tbl.slotDescriptors[2].slotType; @@ -538,13 +538,13 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); LOG(INFO) << st.get_error_msg(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); LOG(INFO) << part.debug_string(); ObjectPool pool; DescriptorTbl* desc_tbl = nullptr; st = DescriptorTbl::create(&pool, t_desc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowDescriptor row_desc(*desc_tbl, {0}, {false}); TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); RowBatch batch(row_desc, 1024); @@ -563,8 +563,8 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { // 1, beijing const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(10, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(10, partition->id); } // 13, 2, "shanghai" { @@ -581,8 +581,8 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { // 2, shanghai const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(12, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(12, partition->id); } // 14, 50, "beijing" { @@ -599,7 +599,7 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { // 50, beijing const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } // 15, 1, "tianjin" @@ -617,8 +617,8 @@ TEST_F(OlapTablePartitionParamTest, multi_list_partition) { // 1, tianjin const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(11, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(11, partition->id); } } @@ -627,15 +627,15 @@ TEST_F(OlapTablePartitionParamTest, to_protobuf) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); POlapTableSchemaParam pschema; schema->to_protobuf(&pschema); { std::shared_ptr schema2(new OlapTableSchemaParam()); auto st = schema2->init(pschema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_STREQ(schema->debug_string().c_str(), schema2->debug_string().c_str()); + EXPECT_STREQ(schema->debug_string().c_str(), schema2->debug_string().c_str()); } } @@ -645,7 +645,7 @@ TEST_F(OlapTablePartitionParamTest, unknown_index_column) { std::shared_ptr schema(new OlapTableSchemaParam()); tschema.indexes[0].columns.push_back("unknown_col"); auto st = schema->init(tschema); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } TEST_F(OlapTablePartitionParamTest, unpartitioned) { @@ -653,7 +653,7 @@ TEST_F(OlapTablePartitionParamTest, unpartitioned) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // (-oo, 10] | [10.50) | [60, +oo) TOlapTablePartitionParam t_partition_param; @@ -671,12 +671,12 @@ TEST_F(OlapTablePartitionParamTest, unpartitioned) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ObjectPool pool; DescriptorTbl* desc_tbl = nullptr; st = DescriptorTbl::create(&pool, t_desc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowDescriptor row_desc(*desc_tbl, {0}, {false}); TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); RowBatch batch(row_desc, 1024); @@ -695,8 +695,8 @@ TEST_F(OlapTablePartitionParamTest, unpartitioned) { // 9: const OlapTablePartition* partition = nullptr; auto found = part.find_partition(tuple, &partition); - ASSERT_TRUE(found); - ASSERT_EQ(10, partition->id); + EXPECT_TRUE(found); + EXPECT_EQ(10, partition->id); } } @@ -705,7 +705,7 @@ TEST_F(OlapTablePartitionParamTest, unknown_partition_column) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // (-oo, 10] | [10.50) | [60, +oo) TOlapTablePartitionParam t_partition_param; @@ -724,7 +724,7 @@ TEST_F(OlapTablePartitionParamTest, unknown_partition_column) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } TEST_F(OlapTablePartitionParamTest, unknown_distributed_col) { @@ -732,7 +732,7 @@ TEST_F(OlapTablePartitionParamTest, unknown_distributed_col) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // (-oo, 10] | [10.50) | [60, +oo) TOlapTablePartitionParam t_partition_param; @@ -750,7 +750,7 @@ TEST_F(OlapTablePartitionParamTest, unknown_distributed_col) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } TEST_F(OlapTablePartitionParamTest, bad_index) { @@ -758,7 +758,7 @@ TEST_F(OlapTablePartitionParamTest, bad_index) { auto t_schema = get_schema(&t_desc_tbl); std::shared_ptr schema(new OlapTableSchemaParam()); auto st = schema->init(t_schema); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); { // (-oo, 10] | [10.50) | [60, +oo) @@ -776,7 +776,7 @@ TEST_F(OlapTablePartitionParamTest, bad_index) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } { // (-oo, 10] | [10.50) | [60, +oo) @@ -796,7 +796,7 @@ TEST_F(OlapTablePartitionParamTest, bad_index) { OlapTablePartitionParam part(schema, t_partition_param); st = part.init(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } } @@ -807,11 +807,11 @@ TEST_F(OlapTablePartitionParamTest, tableLoacation) { OlapTableLocationParam location(tparam); { auto loc = location.find_tablet(1); - ASSERT_TRUE(loc != nullptr); + EXPECT_TRUE(loc != nullptr); } { auto loc = location.find_tablet(2); - ASSERT_TRUE(loc == nullptr); + EXPECT_TRUE(loc == nullptr); } } @@ -822,17 +822,12 @@ TEST_F(OlapTablePartitionParamTest, NodesInfo) { DorisNodesInfo nodes(tinfo); { auto node = nodes.find_node(1); - ASSERT_TRUE(node != nullptr); + EXPECT_TRUE(node != nullptr); } { auto node = nodes.find_node(2); - ASSERT_TRUE(node == nullptr); + EXPECT_TRUE(node == nullptr); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/tablet_sink_test.cpp b/be/test/exec/tablet_sink_test.cpp index 5b0428d5d4..ff33954e7e 100644 --- a/be/test/exec/tablet_sink_test.cpp +++ b/be/test/exec/tablet_sink_test.cpp @@ -31,8 +31,8 @@ #include "runtime/runtime_state.h" #include "runtime/stream_load/load_stream_mgr.h" #include "runtime/thread_resource_mgr.h" -#include "runtime/types.h" #include "runtime/tuple_row.h" +#include "runtime/types.h" #include "service/brpc.h" #include "util/brpc_client_cache.h" #include "util/cpu_info.h" @@ -371,7 +371,7 @@ TEST_F(OlapTableSinkTest, normal) { // start brpc service first _server = new brpc::Server(); auto service = new TestInternalService(); - ASSERT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); + EXPECT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); brpc::ServerOptions options; { debug::ScopedLeakCheckDisabler disable_lsan; @@ -393,7 +393,7 @@ TEST_F(OlapTableSinkTest, normal) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); @@ -402,17 +402,17 @@ TEST_F(OlapTableSinkTest, normal) { RowDescriptor row_desc(*desc_tbl, {0}, {false}); OlapTableSink sink(&obj_pool, row_desc, {}, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // prepare st = sink.prepare(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // open st = sink.open(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // send RowBatch batch(row_desc, 1024); // 12, 9, "abc" @@ -460,25 +460,25 @@ TEST_F(OlapTableSinkTest, normal) { batch.commit_last_row(); } st = sink.send(&state, &batch); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // close st = sink.close(&state, Status::OK()); - ASSERT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") + EXPECT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") << st.to_string(); // each node has a eof - ASSERT_EQ(2, service->_eof_counters); - ASSERT_EQ(2 * 2, service->_row_counters); + EXPECT_EQ(2, service->_eof_counters); + EXPECT_EQ(2 * 2, service->_row_counters); // 2node * 2 - ASSERT_EQ(1, state.num_rows_load_filtered()); + EXPECT_EQ(1, state.num_rows_load_filtered()); } TEST_F(OlapTableSinkTest, convert) { // start brpc service first _server = new brpc::Server(); auto service = new TestInternalService(); - ASSERT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); + EXPECT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); brpc::ServerOptions options; { debug::ScopedLeakCheckDisabler disable_lsan; @@ -498,7 +498,7 @@ TEST_F(OlapTableSinkTest, convert) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); @@ -533,19 +533,19 @@ TEST_F(OlapTableSinkTest, convert) { exprs[2].nodes[0].slot_ref.tuple_id = 1; OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 1; // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // prepare st = sink.prepare(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // open st = sink.open(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // send RowBatch batch(row_desc, 1024); // 12, 9, "abc" @@ -593,18 +593,18 @@ TEST_F(OlapTableSinkTest, convert) { batch.commit_last_row(); } st = sink.send(&state, &batch); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // close st = sink.close(&state, Status::OK()); - ASSERT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") + EXPECT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") << st.to_string(); // each node has a eof - ASSERT_EQ(2, service->_eof_counters); - ASSERT_EQ(2 * 3, service->_row_counters); + EXPECT_EQ(2, service->_eof_counters); + EXPECT_EQ(2 * 3, service->_row_counters); // 2node * 2 - ASSERT_EQ(0, state.num_rows_load_filtered()); + EXPECT_EQ(0, state.num_rows_load_filtered()); } TEST_F(OlapTableSinkTest, init_fail1) { @@ -621,7 +621,7 @@ TEST_F(OlapTableSinkTest, init_fail1) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; RowDescriptor row_desc(*desc_tbl, {0}, {false}); @@ -639,26 +639,26 @@ TEST_F(OlapTableSinkTest, init_fail1) { { OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 5; // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.prepare(&state); EXPECT_FALSE(st.ok()); sink.close(&state, st); } { OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 1; // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.prepare(&state); EXPECT_FALSE(st.ok()); sink.close(&state, st); @@ -679,7 +679,7 @@ TEST_F(OlapTableSinkTest, init_fail3) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; RowDescriptor row_desc(*desc_tbl, {0}, {false}); @@ -712,13 +712,13 @@ TEST_F(OlapTableSinkTest, init_fail3) { exprs[2].nodes[0].slot_ref.tuple_id = 1; OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 1; // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.prepare(&state); EXPECT_FALSE(st.ok()); sink.close(&state, st); @@ -738,7 +738,7 @@ TEST_F(OlapTableSinkTest, init_fail4) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; RowDescriptor row_desc(*desc_tbl, {0}, {false}); @@ -771,14 +771,14 @@ TEST_F(OlapTableSinkTest, init_fail4) { exprs[2].nodes[0].slot_ref.tuple_id = 1; OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 1; // init t_data_sink.olap_table_sink.partition.partitions[0].indexes[0].tablets = {101, 102}; st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.prepare(&state); EXPECT_FALSE(st.ok()); sink.close(&state, st); @@ -788,7 +788,7 @@ TEST_F(OlapTableSinkTest, add_batch_failed) { // start brpc service first _server = new brpc::Server(); auto service = new TestInternalService(); - ASSERT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); + EXPECT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); brpc::ServerOptions options; { debug::ScopedLeakCheckDisabler disable_lsan; @@ -810,7 +810,7 @@ TEST_F(OlapTableSinkTest, add_batch_failed) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; RowDescriptor row_desc(*desc_tbl, {0}, {false}); @@ -843,17 +843,17 @@ TEST_F(OlapTableSinkTest, add_batch_failed) { exprs[2].nodes[0].slot_ref.tuple_id = 1; OlapTableSink sink(&obj_pool, row_desc, exprs, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // set output tuple_id t_data_sink.olap_table_sink.tuple_id = 1; // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.prepare(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = sink.open(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // send RowBatch batch(row_desc, 1024); TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); @@ -875,7 +875,7 @@ TEST_F(OlapTableSinkTest, add_batch_failed) { // Channels will be cancelled internally, coz brpc returns k_add_batch_status. k_add_batch_status = Status::InternalError("dummy failed"); st = sink.send(&state, &batch); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // Send batch multiple times, can make _cur_batch or _pending_batches(in channels) not empty. // To ensure the order of releasing resource is OK. @@ -884,14 +884,14 @@ TEST_F(OlapTableSinkTest, add_batch_failed) { // close st = sink.close(&state, Status::OK()); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } TEST_F(OlapTableSinkTest, decimal) { // start brpc service first _server = new brpc::Server(); auto service = new TestInternalService(); - ASSERT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); + EXPECT_EQ(_server->AddService(service, brpc::SERVER_OWNS_SERVICE), 0); brpc::ServerOptions options; { debug::ScopedLeakCheckDisabler disable_lsan; @@ -911,7 +911,7 @@ TEST_F(OlapTableSinkTest, decimal) { // crate desc_tabl DescriptorTbl* desc_tbl = nullptr; auto st = DescriptorTbl::create(&obj_pool, tdesc_tbl, &desc_tbl); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); state._desc_tbl = desc_tbl; TupleDescriptor* tuple_desc = desc_tbl->get_tuple_descriptor(0); @@ -923,17 +923,17 @@ TEST_F(OlapTableSinkTest, decimal) { service->_output_set = &output_set; OlapTableSink sink(&obj_pool, row_desc, {}, &st); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // init st = sink.init(t_data_sink); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // prepare st = sink.prepare(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // open st = sink.open(&state); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // send RowBatch batch(row_desc, 1024); // 12, 12.3 @@ -972,23 +972,17 @@ TEST_F(OlapTableSinkTest, decimal) { batch.commit_last_row(); } st = sink.send(&state, &batch); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // close st = sink.close(&state, Status::OK()); - ASSERT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") + EXPECT_TRUE(st.ok() || st.to_string() == "Internal error: wait close failed. ") << st.to_string(); - ASSERT_EQ(2, output_set.size()); - ASSERT_TRUE(output_set.count("[(12 12.3)]") > 0); - ASSERT_TRUE(output_set.count("[(13 123.12)]") > 0); - // ASSERT_TRUE(output_set.count("[(14 999.99)]") > 0); + EXPECT_EQ(2, output_set.size()); + EXPECT_TRUE(output_set.count("[(12 12.3)]") > 0); + EXPECT_TRUE(output_set.count("[(13 123.12)]") > 0); + // EXPECT_TRUE(output_set.count("[(14 999.99)]") > 0); } } // namespace stream_load } // namespace doris - -int main(int argc, char* argv[]) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exec/unix_odbc_test.cpp b/be/test/exec/unix_odbc_test.cpp index a9d3f9708a..051393f11e 100644 --- a/be/test/exec/unix_odbc_test.cpp +++ b/be/test/exec/unix_odbc_test.cpp @@ -16,13 +16,3 @@ // under the License. #include - -int main(int argc, char* argv[]) { - SQLRETURN ret; - SQLHENV env; - - /* Allocate an environment handle */ - ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env); - - return ret; -} diff --git a/be/test/exprs/CMakeLists.txt b/be/test/exprs/CMakeLists.txt deleted file mode 100644 index 814ed58507..0000000000 --- a/be/test/exprs/CMakeLists.txt +++ /dev/null @@ -1,43 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/exprs") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/exprs") - -ADD_BE_TEST(json_function_test) -#ADD_BE_TEST(binary_predicate_test) -#ADD_BE_TEST(in_predicate_test) -#ADD_BE_TEST(expr-test) -#ADD_BE_TEST(hybrid_set_test) -ADD_BE_TEST(string_functions_test) -ADD_BE_TEST(timestamp_functions_test) -ADD_BE_TEST(percentile_approx_test) -ADD_BE_TEST(percentile_test) -ADD_BE_TEST(bitmap_function_test) -ADD_BE_TEST(hll_function_test) -ADD_BE_TEST(encryption_functions_test) -#ADD_BE_TEST(in-predicate-test) -ADD_BE_TEST(math_functions_test) -ADD_BE_TEST(topn_function_test) -ADD_BE_TEST(runtime_filter_test) -ADD_BE_TEST(bloom_filter_predicate_test) -ADD_BE_TEST(array_functions_test) -ADD_BE_TEST(quantile_function_test) -ADD_BE_TEST(window_funnel_test) diff --git a/be/test/exprs/array_functions_test.cpp b/be/test/exprs/array_functions_test.cpp index 8ed72a1ce6..2c07dd9b62 100644 --- a/be/test/exprs/array_functions_test.cpp +++ b/be/test/exprs/array_functions_test.cpp @@ -75,8 +75,3 @@ TEST_F(ArrayFunctionsTest, array) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/binary_predicate_test.cpp b/be/test/exprs/binary_predicate_test.cpp index 6a05e23ebd..88d1566cd3 100644 --- a/be/test/exprs/binary_predicate_test.cpp +++ b/be/test/exprs/binary_predicate_test.cpp @@ -60,8 +60,8 @@ public: ttbl.slotDescriptors.push_back(slot_desc); DescriptorTbl* desc_tbl = nullptr; - ASSERT_TRUE(DescriptorTbl::create(_object_pool, ttbl, &desc_tbl).ok()); - ASSERT_TRUE(desc_tbl != nullptr); + EXPECT_TRUE(DescriptorTbl::create(_object_pool, ttbl, &desc_tbl).ok()); + EXPECT_TRUE(desc_tbl != nullptr); _runtime_state->set_desc_tbl(desc_tbl); std::vector row_tuples; @@ -151,14 +151,14 @@ private: TEST_F(BinaryOpTest, PrepareTest) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); } TEST_F(BinaryOpTest, NormalTest) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); int capacity = 256; VectorizedRowBatch* vec_row_batch = object_pool()->add(new VectorizedRowBatch(_schema, capacity)); @@ -172,23 +172,23 @@ TEST_F(BinaryOpTest, NormalTest) { vec_row_batch->set_size(capacity); expr->evaluate(vec_row_batch); - ASSERT_EQ(vec_row_batch->size(), 10); + EXPECT_EQ(vec_row_batch->size(), 10); Tuple tuple; int vv = 0; while (vec_row_batch->get_next_tuple(&tuple, *runtime_state()->desc_tbl().get_tuple_descriptor(0))) { - ASSERT_EQ(vv++, *reinterpret_cast(tuple.get_slot(4))); + EXPECT_EQ(vv++, *reinterpret_cast(tuple.get_slot(4))); } } TEST_F(BinaryOpTest, SimplePerformanceTest) { - ASSERT_EQ(1, _row_desc->tuple_descriptors().size()); + EXPECT_EQ(1, _row_desc->tuple_descriptors().size()); for (int capacity = 128; capacity <= 1024 * 128; capacity *= 2) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(runtime_state(), *row_desc()).ok()); int size = 1024 * 1024 / capacity; VectorizedRowBatch* vec_row_batches[size]; srand(time(nullptr)); diff --git a/be/test/exprs/bitmap_function_test.cpp b/be/test/exprs/bitmap_function_test.cpp index cffc9d71b2..69c465ec86 100644 --- a/be/test/exprs/bitmap_function_test.cpp +++ b/be/test/exprs/bitmap_function_test.cpp @@ -66,7 +66,7 @@ TEST_F(BitmapFunctionsTest, bitmap_empty) { BitmapValue bitmap; StringVal expected = convert_bitmap_to_string(ctx, bitmap); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, to_bitmap) { @@ -78,7 +78,7 @@ TEST_F(BitmapFunctionsTest, to_bitmap) { BitmapValue bitmap(val); StringVal expected = convert_bitmap_to_string(ctx, bitmap); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -86,19 +86,19 @@ TEST_F(BitmapFunctionsTest, to_bitmap_null) { StringVal input = StringVal::null(); StringVal result = BitmapFunctions::to_bitmap(ctx, input); - ASSERT_EQ(StringVal::null(), result); + EXPECT_EQ(StringVal::null(), result); } TEST_F(BitmapFunctionsTest, to_bitmap_invalid_argument) { StringVal input = AnyValUtil::from_string_temp(ctx, std::string("-1")); StringVal result = BitmapFunctions::to_bitmap(ctx, input); - ASSERT_EQ(StringVal::null(), result); + EXPECT_EQ(StringVal::null(), result); } TEST_F(BitmapFunctionsTest, to_bitmap_out_of_range) { StringVal input = AnyValUtil::from_string_temp(ctx, std::string("18446744073709551616")); StringVal result = BitmapFunctions::to_bitmap(ctx, input); - ASSERT_EQ(StringVal::null(), result); + EXPECT_EQ(StringVal::null(), result); } TEST_F(BitmapFunctionsTest, bitmap_union_int) { @@ -111,7 +111,7 @@ TEST_F(BitmapFunctionsTest, bitmap_union_int) { BigIntVal result = BitmapFunctions::bitmap_finalize(ctx, dst); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_get_value) { @@ -122,20 +122,20 @@ TEST_F(BitmapFunctionsTest, bitmap_get_value) { BigIntVal result = BitmapFunctions::bitmap_get_value(ctx, dst); BigIntVal expected(1); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); IntVal src2(1234567); BitmapFunctions::bitmap_update_int(ctx, src2, &dst); result = BitmapFunctions::bitmap_get_value(ctx, dst); expected.val = 2; - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); BigIntVal finalize_result = BitmapFunctions::bitmap_finalize(ctx, dst); - ASSERT_EQ(result, finalize_result); + EXPECT_EQ(result, finalize_result); BigIntVal null_bitmap = BitmapFunctions::bitmap_get_value(ctx, StringVal::null()); - ASSERT_EQ(BigIntVal(0), null_bitmap); + EXPECT_EQ(BigIntVal(0), null_bitmap); } TEST_F(BitmapFunctionsTest, bitmap_union) { @@ -163,7 +163,7 @@ TEST_F(BitmapFunctionsTest, bitmap_union) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, serialized); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } // test bitmap_intersect @@ -185,7 +185,7 @@ TEST_F(BitmapFunctionsTest, bitmap_intersect) { StringVal serialized = BitmapFunctions::bitmap_serialize(ctx, dst); BigIntVal result = BitmapFunctions::bitmap_count(ctx, serialized); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } // test bitmap_intersect with null dst @@ -196,7 +196,7 @@ TEST_F(BitmapFunctionsTest, bitmap_intersect_empty) { StringVal serialized = BitmapFunctions::bitmap_serialize(ctx, dst); BigIntVal result = BitmapFunctions::bitmap_count(ctx, serialized); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_count) { @@ -207,35 +207,35 @@ TEST_F(BitmapFunctionsTest, bitmap_count) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(3); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); BigIntVal null_bitmap = BitmapFunctions::bitmap_count(ctx, StringVal::null()); - ASSERT_EQ(BigIntVal(0), null_bitmap); + EXPECT_EQ(BigIntVal(0), null_bitmap); } TEST_F(BitmapFunctionsTest, bitmap_min) { BigIntVal result = BitmapFunctions::bitmap_min(ctx, StringVal::null()); - ASSERT_TRUE(result.is_null); + EXPECT_TRUE(result.is_null); BitmapValue bitmap1; StringVal empty_str = convert_bitmap_to_string(ctx, bitmap1); result = BitmapFunctions::bitmap_min(ctx, empty_str); - ASSERT_TRUE(result.is_null); + EXPECT_TRUE(result.is_null); BitmapValue bitmap2 = BitmapValue(1024); StringVal bitmap_str = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_min(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(1024), result); + EXPECT_EQ(BigIntVal(1024), result); BitmapValue bitmap3 = BitmapValue({1024, 1}); bitmap_str = convert_bitmap_to_string(ctx, bitmap3); result = BitmapFunctions::bitmap_min(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(1), result); + EXPECT_EQ(BigIntVal(1), result); BitmapValue bitmap4 = BitmapValue({1024, 3, 2}); bitmap_str = convert_bitmap_to_string(ctx, bitmap4); result = BitmapFunctions::bitmap_min(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(2), result); + EXPECT_EQ(BigIntVal(2), result); } // test intersect_count @@ -271,10 +271,10 @@ void test_bitmap_intersect(FunctionContext* ctx, ValType key1, ValType key2) { intersect2.update(detail::get_val(key1), bitmap1); intersect2.update(detail::get_val(key2), bitmap2); StringVal expected = convert_bitmap_intersect_to_string(ctx, intersect2); - ASSERT_EQ(expected, intersect1); + EXPECT_EQ(expected, intersect1); BitmapIntersect intersect2_serde((char*)expected.ptr); - ASSERT_EQ(1, intersect2_serde.intersect_count()); + EXPECT_EQ(1, intersect2_serde.intersect_count()); StringVal dst2; BitmapFunctions::bitmap_intersect_init(ctx, &dst2); @@ -282,7 +282,7 @@ void test_bitmap_intersect(FunctionContext* ctx, ValType key1, ValType key2) { BigIntVal result = BitmapFunctions::bitmap_intersect_finalize(ctx, dst2); BigIntVal expected_count(1); - ASSERT_EQ(expected_count, result); + EXPECT_EQ(expected_count, result); } TEST_F(BitmapFunctionsTest, test_bitmap_intersect) { @@ -325,7 +325,7 @@ TEST_F(BitmapFunctionsTest, bitmap_or) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(6); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_or_variable) { @@ -333,7 +333,7 @@ TEST_F(BitmapFunctionsTest, bitmap_or_variable) { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -344,8 +344,8 @@ TEST_F(BitmapFunctionsTest, bitmap_or_variable) { StringVal bitmap_result = BitmapFunctions::bitmap_or(ctx, bitmap_src1, 3, bitmap_strs); BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); - BigIntVal expected(7);//0,1,5,33,1024,2019,18446744073709551615 - ASSERT_EQ(expected, result); + BigIntVal expected(7); //0,1,5,33,1024,2019,18446744073709551615 + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -361,7 +361,7 @@ TEST_F(BitmapFunctionsTest, bitmap_or_variable) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -376,7 +376,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(1); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_and_variable) { @@ -393,14 +393,14 @@ TEST_F(BitmapFunctionsTest, bitmap_and_variable) { StringVal bitmap_result = BitmapFunctions::bitmap_and(ctx, bitmap_src1, 2, bitmap_strs); BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); - BigIntVal expected(1);//0 - ASSERT_EQ(expected, result); + BigIntVal expected(1); //0 + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -412,7 +412,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_variable) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -428,7 +428,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_variable) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -443,7 +443,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(4); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_xor_variable) { @@ -459,15 +459,15 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_variable) { StringVal bitmap_result = BitmapFunctions::bitmap_xor(ctx, bitmap_src1, 2, bitmap_strs); BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); - + BigIntVal expected(5); //0,1,5,1024,18446744073709551615 - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -477,9 +477,9 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_variable) { StringVal bitmap_result = BitmapFunctions::bitmap_xor(ctx, bitmap_src1, 3, bitmap_strs); BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); - + BigIntVal expected(6); //0,1,5,1024,2019,18446744073709551615 - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -495,7 +495,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_variable) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_result); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -510,7 +510,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(4); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -522,7 +522,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(0); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -534,7 +534,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(6); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } } @@ -550,15 +550,15 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_variable) { StringVal bitmap_strs[2] = {bitmap_src2, bitmap_src3}; BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src1, 2, bitmap_strs); - + BigIntVal expected(5); //0,1,5,1024,18446744073709551615 - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -567,9 +567,9 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_variable) { StringVal bitmap_strs[3] = {bitmap_src2, bitmap_src3, bitmap_src4}; BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src1, 3, bitmap_strs); - + BigIntVal expected(6); //0,1,5,1024,2019,18446744073709551615 - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -582,7 +582,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_variable) { StringVal bitmap_strs[3] = {bitmap_src2, bitmap_src3, StringVal::null()}; //test null BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src1, 3, bitmap_strs); - ASSERT_EQ(BigIntVal::null(), result); + EXPECT_EQ(BigIntVal::null(), result); } } @@ -597,7 +597,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_64) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(4); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({14123400000000000501ull, 2, 1498760000000000503ull}); @@ -609,7 +609,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_64) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(0); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({15000000000000000501ull, 2, 1200000000000000503ull}); @@ -621,7 +621,7 @@ TEST_F(BitmapFunctionsTest, bitmap_xor_count_64) { BigIntVal result = BitmapFunctions::bitmap_xor_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(6); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } } @@ -631,24 +631,24 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); bitmap1 = BitmapValue({0, 1, 2, std::numeric_limits::min()}); bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(3, result.val); + EXPECT_EQ(3, result.val); bitmap1 = BitmapValue({1, 2, 3}); bitmap2 = BitmapValue({3, 4, 5}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(1, result.val); + EXPECT_EQ(1, result.val); } TEST_F(BitmapFunctionsTest, bitmap_and_count_variable) { @@ -663,14 +663,14 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count_variable) { StringVal bitmap_strs[2] = {bitmap_src2, bitmap_src3}; BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, 2, bitmap_strs); - BigIntVal expected(1);//0 - ASSERT_EQ(expected, result); + BigIntVal expected(1); //0 + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -680,7 +680,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count_variable) { BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, 3, bitmap_strs); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -693,7 +693,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count_variable) { StringVal bitmap_strs[3] = {bitmap_src2, bitmap_src3, StringVal::null()}; //test null BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, 3, bitmap_strs); - ASSERT_EQ(BigIntVal::null(), result); + EXPECT_EQ(BigIntVal::null(), result); } } @@ -703,10 +703,10 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count_64) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); bitmap1 = BitmapValue({11598000000000000501ull, 2, 1923400000000000503ull, std::numeric_limits::min()}); @@ -715,14 +715,14 @@ TEST_F(BitmapFunctionsTest, bitmap_and_count_64) { bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(3, result.val); + EXPECT_EQ(3, result.val); bitmap1 = BitmapValue({15555500000000000501ull, 2, 1400000000000000503ull}); bitmap2 = BitmapValue({1400000000000000503ull, 5, 1400324000000000506ull}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_and_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(1, result.val); + EXPECT_EQ(1, result.val); } TEST_F(BitmapFunctionsTest, bitmap_or_count) { @@ -731,24 +731,24 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(3, result.val); + EXPECT_EQ(3, result.val); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); bitmap1 = BitmapValue({0, 1, 2, std::numeric_limits::min()}); bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(4, result.val); + EXPECT_EQ(4, result.val); bitmap1 = BitmapValue({1, 2, 3}); bitmap2 = BitmapValue({3, 4, 5}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(5, result.val); + EXPECT_EQ(5, result.val); } TEST_F(BitmapFunctionsTest, bitmap_or_count_variable) { @@ -756,7 +756,7 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count_variable) { BitmapValue bitmap1({1024, 1, 2019}); BitmapValue bitmap2({0, 33, std::numeric_limits::min()}); BitmapValue bitmap3({33, 5, std::numeric_limits::max()}); - BitmapValue bitmap_empty; //test empty + BitmapValue bitmap_empty; //test empty StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); @@ -766,8 +766,8 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count_variable) { BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, 3, bitmap_strs); - BigIntVal expected(7);//0,1,5,33,1024,2019,18446744073709551615 - ASSERT_EQ(expected, result); + BigIntVal expected(7); //0,1,5,33,1024,2019,18446744073709551615 + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1024, 1, 2019}); @@ -780,7 +780,7 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count_variable) { StringVal bitmap_strs[3] = {bitmap_src2, bitmap_src3, StringVal::null()}; //test null BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, 3, bitmap_strs); - ASSERT_EQ(BigIntVal::null(), result); + EXPECT_EQ(BigIntVal::null(), result); } } @@ -790,10 +790,10 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count_64) { StringVal bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); StringVal bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); BigIntVal result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(3, result.val); + EXPECT_EQ(3, result.val); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, StringVal::null()); - ASSERT_EQ(0, result.val); + EXPECT_EQ(0, result.val); bitmap1 = BitmapValue({11870000000000000501ull, 2, 1378900000000000503ull, std::numeric_limits::min()}); @@ -802,14 +802,14 @@ TEST_F(BitmapFunctionsTest, bitmap_or_count_64) { bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(5, result.val); + EXPECT_EQ(5, result.val); bitmap1 = BitmapValue({17870000000000000501ull, 2, 1400000000000000503ull}); bitmap2 = BitmapValue({1400000000000000503ull, 5, 1678900000000000503ull}); bitmap_src1 = convert_bitmap_to_string(ctx, bitmap1); bitmap_src2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_or_count(ctx, bitmap_src1, bitmap_src2); - ASSERT_EQ(5, result.val); + EXPECT_EQ(5, result.val); } TEST_F(BitmapFunctionsTest, bitmap_not) { @@ -823,7 +823,7 @@ TEST_F(BitmapFunctionsTest, bitmap_not) { StringVal bitmap_str = BitmapFunctions::bitmap_not(ctx, bitmap_src, bitmap_dst); BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); // result is single bitmap1 = BitmapValue({1024, 1, 2019}); @@ -835,7 +835,7 @@ TEST_F(BitmapFunctionsTest, bitmap_not) { bitmap_str = BitmapFunctions::bitmap_not(ctx, bitmap_src, bitmap_dst); result = BitmapFunctions::bitmap_count(ctx, bitmap_str); expected = BigIntVal(1); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); // result is empty bitmap1 = BitmapValue({1024, 1, 2019}); @@ -847,7 +847,7 @@ TEST_F(BitmapFunctionsTest, bitmap_not) { bitmap_str = BitmapFunctions::bitmap_not(ctx, bitmap_src, bitmap_dst); result = BitmapFunctions::bitmap_count(ctx, bitmap_str); expected = BigIntVal(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); bitmap1 = BitmapValue(1); bitmap2 = BitmapValue({2, 1}); @@ -856,7 +856,7 @@ TEST_F(BitmapFunctionsTest, bitmap_not) { bitmap_dst = convert_bitmap_to_string(ctx, bitmap2); bitmap_str = BitmapFunctions::bitmap_not(ctx, bitmap_src, bitmap_dst); result = BitmapFunctions::bitmap_count(ctx, bitmap_str); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(BitmapFunctionsTest, bitmap_and_not) { @@ -871,7 +871,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1, 2, 3}); @@ -884,7 +884,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(0); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { BitmapValue bitmap1({1, 2, 3}); @@ -897,7 +897,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not) { BigIntVal result = BitmapFunctions::bitmap_count(ctx, bitmap_str); BigIntVal expected(3); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -912,7 +912,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(2); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -924,7 +924,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(0); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } { BitmapValue bitmap1({1, 2, 3}); @@ -936,7 +936,7 @@ TEST_F(BitmapFunctionsTest, bitmap_and_not_count) { BigIntVal result = BitmapFunctions::bitmap_and_not_count(ctx, bitmap_src, bitmap_dst); BigIntVal expected(3); - ASSERT_EQ(expected.val, result.val); + EXPECT_EQ(expected.val, result.val); } } @@ -945,11 +945,11 @@ TEST_F(BitmapFunctionsTest, bitmap_contains) { StringVal bitmap_str = convert_bitmap_to_string(ctx, bitmap); BooleanVal result = BitmapFunctions::bitmap_contains(ctx, bitmap_str, 5); BooleanVal expected(true); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); BooleanVal result2 = BitmapFunctions::bitmap_contains(ctx, bitmap_str, 10); BooleanVal expected2(false); - ASSERT_EQ(expected2, result2); + EXPECT_EQ(expected2, result2); } TEST_F(BitmapFunctionsTest, bitmap_has_any) { @@ -960,13 +960,13 @@ TEST_F(BitmapFunctionsTest, bitmap_has_any) { StringVal rhs = convert_bitmap_to_string(ctx, bitmap2); BooleanVal result = BitmapFunctions::bitmap_has_any(ctx, lhs, rhs); BooleanVal expected(true); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); BitmapValue bitmap3(10); StringVal r3 = convert_bitmap_to_string(ctx, bitmap3); BooleanVal result1 = BitmapFunctions::bitmap_has_any(ctx, lhs, r3); BooleanVal expected2(false); - ASSERT_EQ(expected2, result1); + EXPECT_EQ(expected2, result1); } TEST_F(BitmapFunctionsTest, bitmap_has_all) { @@ -977,33 +977,33 @@ TEST_F(BitmapFunctionsTest, bitmap_has_all) { StringVal string_val1 = convert_bitmap_to_string(ctx, bitmap1); StringVal string_val2 = convert_bitmap_to_string(ctx, bitmap2); BooleanVal result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal {true}, result); + EXPECT_EQ(BooleanVal {true}, result); bitmap1 = BitmapValue({0, 1, 2}); bitmap2 = BitmapValue({0, 1, 2, std::numeric_limits::max()}); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal {false}, result); + EXPECT_EQ(BooleanVal {false}, result); bitmap1 = BitmapValue(); bitmap2 = BitmapValue({0, 1, 2}); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal {false}, result); + EXPECT_EQ(BooleanVal {false}, result); bitmap1 = BitmapValue(); bitmap2 = BitmapValue(); string_val1 = convert_bitmap_to_string(ctx, bitmap1); string_val2 = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, string_val2); - ASSERT_EQ(BooleanVal {true}, result); + EXPECT_EQ(BooleanVal {true}, result); bitmap1 = BitmapValue(); string_val1 = convert_bitmap_to_string(ctx, bitmap1); result = BitmapFunctions::bitmap_has_all(ctx, string_val1, StringVal::null()); - ASSERT_TRUE(result.is_null); + EXPECT_TRUE(result.is_null); } TEST_F(BitmapFunctionsTest, bitmap_from_string) { @@ -1011,61 +1011,61 @@ TEST_F(BitmapFunctionsTest, bitmap_from_string) { { StringVal val = StringVal("0,1,2"); auto bitmap_str = BitmapFunctions::bitmap_from_string(utils.get_fn_ctx(), val); - ASSERT_FALSE(bitmap_str.is_null); + EXPECT_FALSE(bitmap_str.is_null); BitmapValue bitmap((const char*)bitmap_str.ptr); - ASSERT_TRUE(bitmap.contains(0)); - ASSERT_TRUE(bitmap.contains(1)); - ASSERT_TRUE(bitmap.contains(2)); + EXPECT_TRUE(bitmap.contains(0)); + EXPECT_TRUE(bitmap.contains(1)); + EXPECT_TRUE(bitmap.contains(2)); } { StringVal val = StringVal("a,b,1,2"); auto bitmap_str = BitmapFunctions::bitmap_from_string(utils.get_fn_ctx(), val); - ASSERT_TRUE(bitmap_str.is_null); + EXPECT_TRUE(bitmap_str.is_null); } { StringVal val = StringVal("-1,1,2"); auto bitmap_str = BitmapFunctions::bitmap_from_string(utils.get_fn_ctx(), val); - ASSERT_TRUE(bitmap_str.is_null); + EXPECT_TRUE(bitmap_str.is_null); } } TEST_F(BitmapFunctionsTest, bitmap_max) { BigIntVal result = BitmapFunctions::bitmap_max(ctx, StringVal::null()); - ASSERT_TRUE(result.is_null); + EXPECT_TRUE(result.is_null); BitmapValue bitmap1; StringVal empty_str = convert_bitmap_to_string(ctx, bitmap1); result = BitmapFunctions::bitmap_max(ctx, empty_str); - ASSERT_TRUE(result.is_null); + EXPECT_TRUE(result.is_null); BitmapValue bitmap2 = BitmapValue(1024); StringVal bitmap_str = convert_bitmap_to_string(ctx, bitmap2); result = BitmapFunctions::bitmap_max(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(1024), result); + EXPECT_EQ(BigIntVal(1024), result); BitmapValue bitmap3 = BitmapValue({1024, 1}); bitmap_str = convert_bitmap_to_string(ctx, bitmap3); result = BitmapFunctions::bitmap_max(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(1024), result); + EXPECT_EQ(BigIntVal(1024), result); BitmapValue bitmap4 = BitmapValue({1024, 3, 2}); bitmap_str = convert_bitmap_to_string(ctx, bitmap4); result = BitmapFunctions::bitmap_max(ctx, bitmap_str); - ASSERT_EQ(BigIntVal(1024), result); + EXPECT_EQ(BigIntVal(1024), result); } TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { // null StringVal res = BitmapFunctions::bitmap_subset_in_range(ctx, StringVal::null(), BigIntVal(1), BigIntVal(3)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // empty BitmapValue bitmap0; StringVal empty_str = convert_bitmap_to_string(ctx, bitmap0); res = BitmapFunctions::bitmap_subset_in_range(ctx, empty_str, BigIntVal(1), BigIntVal(3)); BigIntVal result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(0), result); + EXPECT_EQ(BigIntVal(0), result); // normal BitmapValue bitmap1({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, @@ -1075,51 +1075,51 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_in_range) { StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(30), BigIntVal(200)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(5), result); + EXPECT_EQ(BigIntVal(5), result); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(0), BigIntVal(1)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(1), result); + EXPECT_EQ(BigIntVal(1), result); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(11), BigIntVal(15)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(4), result); + EXPECT_EQ(BigIntVal(4), result); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(11), DecimalV2Value::MAX_INT64); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(27), result); + EXPECT_EQ(BigIntVal(27), result); // innormal // start >= end res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(30), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(20), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // negative range res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(-10), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(10), BigIntVal(-20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(-10), BigIntVal(-20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // null range res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal(10), BigIntVal::null()); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_in_range(ctx, bitmap_src, BigIntVal::null(), BigIntVal::null()); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); } TEST_F(BitmapFunctionsTest, sub_bitmap) { @@ -1131,69 +1131,69 @@ TEST_F(BitmapFunctionsTest, sub_bitmap) { StringVal res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(6)); BitmapValue bitmap2({30, 31, 32, 33, 100, 200}); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap2)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap2)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(100)); BitmapValue bitmap3({30, 31, 32, 33, 100, 200, 500}); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap3)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap3)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(INT64_MAX)); BitmapValue bitmap4({30, 31, 32, 33, 100, 200, 500}); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap4)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap4)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(0), BigIntVal(2)); BitmapValue bitmap5({0, 1}); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap5)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap5)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(-1), BigIntVal(2)); BitmapValue bitmap6(500); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap6)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap6)); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(-7), BigIntVal(6)); BitmapValue bitmap7({30, 31, 32, 33, 100, 200}); - ASSERT_EQ(res, convert_bitmap_to_string(ctx, bitmap7)); + EXPECT_EQ(res, convert_bitmap_to_string(ctx, bitmap7)); // null res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(0), BigIntVal(0)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(100), BigIntVal(6)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(-100), BigIntVal(6)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(30), BigIntVal(INT64_MIN)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, StringVal::null(), BigIntVal(1), BigIntVal(3)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal::null(), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::sub_bitmap(ctx, bitmap_src, BigIntVal(10), BigIntVal::null()); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // empty BitmapValue bitmap0; StringVal empty_str = convert_bitmap_to_string(ctx, bitmap0); res = BitmapFunctions::sub_bitmap(ctx, empty_str, BigIntVal(0), BigIntVal(3)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); } TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { // null StringVal res = BitmapFunctions::bitmap_subset_limit(ctx, StringVal::null(), BigIntVal(1), BigIntVal(3)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // empty BitmapValue bitmap0; StringVal empty_str = convert_bitmap_to_string(ctx, bitmap0); res = BitmapFunctions::bitmap_subset_limit(ctx, empty_str, BigIntVal(10), BigIntVal(20)); BigIntVal result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(0), result); + EXPECT_EQ(BigIntVal(0), result); // normal BitmapValue bitmap1({0, 1, 2, 3, 4, 5, 6, 7, 45, 47, 49, 43, 8, 9, @@ -1203,47 +1203,42 @@ TEST_F(BitmapFunctionsTest, bitmap_subset_limit) { StringVal bitmap_src = convert_bitmap_to_string(ctx, bitmap1); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(4), BigIntVal(10)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(10), result); + EXPECT_EQ(BigIntVal(10), result); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(0), BigIntVal(1)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(1), result); + EXPECT_EQ(BigIntVal(1), result); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(35), BigIntVal(10)); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(7), result); + EXPECT_EQ(BigIntVal(7), result); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(31), DecimalV2Value::MAX_INT64); result = BitmapFunctions::bitmap_count(ctx, res); - ASSERT_EQ(BigIntVal(10), result); + EXPECT_EQ(BigIntVal(10), result); // abnormal // negative range_start and cardinality_limit res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(-10), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(10), BigIntVal(-20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(-10), BigIntVal(-20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); // null range res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal::null(), BigIntVal(20)); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal(10), BigIntVal::null()); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); res = BitmapFunctions::bitmap_subset_limit(ctx, bitmap_src, BigIntVal::null(), BigIntVal::null()); - ASSERT_TRUE(res.is_null); + EXPECT_TRUE(res.is_null); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/bloom_filter_predicate_test.cpp b/be/test/exprs/bloom_filter_predicate_test.cpp index 84a0e0364e..abedc9a59f 100644 --- a/be/test/exprs/bloom_filter_predicate_test.cpp +++ b/be/test/exprs/bloom_filter_predicate_test.cpp @@ -32,7 +32,7 @@ public: TEST_F(BloomFilterPredicateTest, bloom_filter_func_int_test) { std::unique_ptr func(create_bloom_filter(PrimitiveType::TYPE_INT)); - ASSERT_TRUE(func->init(1024, 0.05).ok()); + EXPECT_TRUE(func->init(1024, 0.05).ok()); const int data_size = 1024; int data[data_size]; for (int i = 0; i < data_size; i++) { @@ -40,11 +40,11 @@ TEST_F(BloomFilterPredicateTest, bloom_filter_func_int_test) { func->insert((const void*)&data[i]); } for (int i = 0; i < data_size; i++) { - ASSERT_TRUE(func->find((const void*)&data[i])); + EXPECT_TRUE(func->find((const void*)&data[i])); } // test not exist val int not_exist_val = 0x3355ff; - ASSERT_FALSE(func->find((const void*)¬_exist_val)); + EXPECT_FALSE(func->find((const void*)¬_exist_val)); // TEST null value func->insert(nullptr); func->find(nullptr); @@ -52,7 +52,7 @@ TEST_F(BloomFilterPredicateTest, bloom_filter_func_int_test) { TEST_F(BloomFilterPredicateTest, bloom_filter_func_stringval_test) { std::unique_ptr func(create_bloom_filter(PrimitiveType::TYPE_VARCHAR)); - ASSERT_TRUE(func->init(1024, 0.05).ok()); + EXPECT_TRUE(func->init(1024, 0.05).ok()); ObjectPool obj_pool; const int data_size = 1024; StringValue data[data_size]; @@ -62,16 +62,16 @@ TEST_F(BloomFilterPredicateTest, bloom_filter_func_stringval_test) { func->insert((const void*)&data[i]); } for (int i = 0; i < data_size; i++) { - ASSERT_TRUE(func->find((const void*)&data[i])); + EXPECT_TRUE(func->find((const void*)&data[i])); } // test not exist value std::string not_exist_str = "0x3355ff"; StringValue not_exist_val(not_exist_str); - ASSERT_FALSE(func->find((const void*)¬_exist_val)); + EXPECT_FALSE(func->find((const void*)¬_exist_val)); // test fixed char func.reset(create_bloom_filter(PrimitiveType::TYPE_CHAR)); - ASSERT_TRUE(func->init(1024, 0.05).ok()); + EXPECT_TRUE(func->init(1024, 0.05).ok()); auto varchar_true_str = obj_pool.add(new std::string("true")); StringValue varchar_true(*varchar_true_str); @@ -93,8 +93,8 @@ TEST_F(BloomFilterPredicateTest, bloom_filter_func_stringval_test) { fixed_char_false.ptr = false_buf; fixed_char_false.len = 10; - ASSERT_TRUE(func->find_olap_engine((const void*)&fixed_char_true)); - ASSERT_TRUE(func->find_olap_engine((const void*)&fixed_char_false)); + EXPECT_TRUE(func->find_olap_engine((const void*)&fixed_char_true)); + EXPECT_TRUE(func->find_olap_engine((const void*)&fixed_char_false)); func->find(nullptr); } @@ -106,12 +106,7 @@ TEST_F(BloomFilterPredicateTest, bloom_filter_size_test) { char* data = nullptr; int len; func->get_data(&data, &len); - ASSERT_EQ(length, len); + EXPECT_EQ(length, len); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/encryption_functions_test.cpp b/be/test/exprs/encryption_functions_test.cpp index ec01fd94df..26dc7c2fa4 100644 --- a/be/test/exprs/encryption_functions_test.cpp +++ b/be/test/exprs/encryption_functions_test.cpp @@ -48,14 +48,14 @@ TEST_F(EncryptionFunctionsTest, from_base64) { StringVal result = EncryptionFunctions::from_base64(context.get(), doris_udf::StringVal("aGVsbG8=")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal result = EncryptionFunctions::from_base64(context.get(), doris_udf::StringVal::null()); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -66,13 +66,13 @@ TEST_F(EncryptionFunctionsTest, to_base64) { StringVal result = EncryptionFunctions::to_base64(context.get(), doris_udf::StringVal("hello")); StringVal expected = doris_udf::StringVal("aGVsbG8="); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal result = EncryptionFunctions::to_base64(context.get(), doris_udf::StringVal::null()); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -84,7 +84,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { StringVal result = EncryptionFunctions::aes_decrypt(context.get(), encryptWord, doris_udf::StringVal("key")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -93,7 +93,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { StringVal result = EncryptionFunctions::aes_decrypt(context.get(), encryptWord, doris_udf::StringVal("key")); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { @@ -105,7 +105,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal::null(), doris_udf::StringVal("AES_128_ECB")); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { @@ -116,7 +116,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal::null(), doris_udf::StringVal("AES_128_ECB")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { @@ -127,7 +127,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_256_CBC")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -137,7 +137,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_CFB")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -147,7 +147,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_CFB1")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -157,7 +157,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_CFB8")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -167,7 +167,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_CFB128")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -177,7 +177,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_CTR")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::aes_encrypt( @@ -187,7 +187,7 @@ TEST_F(EncryptionFunctionsTest, aes_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("AES_192_OFB")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } @@ -199,7 +199,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { StringVal result = EncryptionFunctions::sm4_decrypt(context.get(), encryptWord, doris_udf::StringVal("key")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::sm4_encrypt( @@ -208,7 +208,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { StringVal result = EncryptionFunctions::sm4_decrypt(context.get(), encryptWord, doris_udf::StringVal("key")); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { @@ -220,7 +220,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal::null(), doris_udf::StringVal("SM4_128_ECB")); StringVal expected = doris_udf::StringVal::null(); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { @@ -231,7 +231,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("SM4_128_CBC")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::sm4_encrypt( @@ -241,7 +241,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("SM4_128_CFB128")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::sm4_encrypt( @@ -251,7 +251,7 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("SM4_128_CTR")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } { StringVal encryptWord = EncryptionFunctions::sm4_encrypt( @@ -261,18 +261,8 @@ TEST_F(EncryptionFunctionsTest, sm4_decrypt) { context.get(), encryptWord, doris_udf::StringVal("key"), doris_udf::StringVal("01234567890"), doris_udf::StringVal("SM4_128_OFB")); StringVal expected = doris_udf::StringVal("hello"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/hll_function_test.cpp b/be/test/exprs/hll_function_test.cpp index 5734d61e36..d7948d4d2a 100644 --- a/be/test/exprs/hll_function_test.cpp +++ b/be/test/exprs/hll_function_test.cpp @@ -61,7 +61,7 @@ TEST_F(HllFunctionsTest, hll_hash) { int64_t cardinality = hll.estimate_cardinality(); int64_t expected = 1; - ASSERT_EQ(expected, cardinality); + EXPECT_EQ(expected, cardinality); } TEST_F(HllFunctionsTest, hll_hash_null) { @@ -72,7 +72,7 @@ TEST_F(HllFunctionsTest, hll_hash_null) { int64_t cardinality = hll.estimate_cardinality(); int64_t expected = 0; - ASSERT_EQ(expected, cardinality); + EXPECT_EQ(expected, cardinality); } TEST_F(HllFunctionsTest, hll_update) { @@ -85,7 +85,7 @@ TEST_F(HllFunctionsTest, hll_update) { BigIntVal result = HllFunctions::hll_finalize(ctx, dst); BigIntVal expected(2); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(HllFunctionsTest, hll_merge) { @@ -104,12 +104,7 @@ TEST_F(HllFunctionsTest, hll_merge) { HyperLogLog hll(Slice(serialized.ptr, serialized.len)); BigIntVal expected(1); - ASSERT_EQ(expected, hll.estimate_cardinality()); + EXPECT_EQ(expected, hll.estimate_cardinality()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/hybrid_set_test.cpp b/be/test/exprs/hybrid_set_test.cpp index 4a93e90418..681c79af1f 100644 --- a/be/test/exprs/hybrid_set_test.cpp +++ b/be/test/exprs/hybrid_set_test.cpp @@ -46,7 +46,7 @@ TEST_F(HybridSetTest, bool) { a = false; set->insert(&a); - ASSERT_EQ(2, set->size()); + EXPECT_EQ(2, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -55,9 +55,9 @@ TEST_F(HybridSetTest, bool) { } a = true; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = false; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); } TEST_F(HybridSetTest, tinyint) { @@ -75,7 +75,7 @@ TEST_F(HybridSetTest, tinyint) { a = 4; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); @@ -85,17 +85,17 @@ TEST_F(HybridSetTest, tinyint) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, smallint) { HybridSetBase* set = create_set(TYPE_SMALLINT); @@ -112,7 +112,7 @@ TEST_F(HybridSetTest, smallint) { a = 4; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -121,17 +121,17 @@ TEST_F(HybridSetTest, smallint) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, int) { HybridSetBase* set = create_set(TYPE_INT); @@ -148,7 +148,7 @@ TEST_F(HybridSetTest, int) { a = 4; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -157,17 +157,17 @@ TEST_F(HybridSetTest, int) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, bigint) { HybridSetBase* set = create_set(TYPE_BIGINT); @@ -184,7 +184,7 @@ TEST_F(HybridSetTest, bigint) { a = 4; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -193,17 +193,17 @@ TEST_F(HybridSetTest, bigint) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, float) { HybridSetBase* set = create_set(TYPE_FLOAT); @@ -220,7 +220,7 @@ TEST_F(HybridSetTest, float) { a = 4.1; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -229,17 +229,17 @@ TEST_F(HybridSetTest, float) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5.1; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, double) { HybridSetBase* set = create_set(TYPE_DOUBLE); @@ -256,7 +256,7 @@ TEST_F(HybridSetTest, double) { a = 4.1; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -265,17 +265,17 @@ TEST_F(HybridSetTest, double) { } a = 0; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 1.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 2.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 3.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 4.1; - ASSERT_TRUE(set->find(&a)); + EXPECT_TRUE(set->find(&a)); a = 5.1; - ASSERT_FALSE(set->find(&a)); + EXPECT_FALSE(set->find(&a)); } TEST_F(HybridSetTest, string) { HybridSetBase* set = create_set(TYPE_VARCHAR); @@ -299,7 +299,7 @@ TEST_F(HybridSetTest, string) { a.len = 4; set->insert(&a); - ASSERT_EQ(5, set->size()); + EXPECT_EQ(5, set->size()); HybridSetBase::IteratorBase* base = set->begin(); while (base->has_next()) { @@ -315,17 +315,17 @@ TEST_F(HybridSetTest, string) { b.ptr = buf1; b.len = 0; - ASSERT_TRUE(set->find(&b)); + EXPECT_TRUE(set->find(&b)); b.len = 1; - ASSERT_TRUE(set->find(&b)); + EXPECT_TRUE(set->find(&b)); b.len = 2; - ASSERT_TRUE(set->find(&b)); + EXPECT_TRUE(set->find(&b)); b.len = 3; - ASSERT_TRUE(set->find(&b)); + EXPECT_TRUE(set->find(&b)); b.len = 4; - ASSERT_TRUE(set->find(&b)); + EXPECT_TRUE(set->find(&b)); b.len = 5; - ASSERT_FALSE(set->find(&b)); + EXPECT_FALSE(set->find(&b)); } TEST_F(HybridSetTest, timestamp) { CpuInfo::init(); @@ -354,7 +354,7 @@ TEST_F(HybridSetTest, timestamp) { LOG(INFO) << ((DateTimeValue*)base->get_value())->debug_string(); base->next(); } - ASSERT_EQ(2, set->size()); + EXPECT_EQ(2, set->size()); char s11[] = "2012-01-20 01:10:01"; char s12[] = "1990-10-20 10:10:10.123456 "; @@ -366,25 +366,14 @@ TEST_F(HybridSetTest, timestamp) { DateTimeValue v13; v13.from_date_str(s13, strlen(s13)); - ASSERT_TRUE(set->find(&v11)); - ASSERT_TRUE(set->find(&v12)); - ASSERT_TRUE(set->find(&v13)); + EXPECT_TRUE(set->find(&v11)); + EXPECT_TRUE(set->find(&v12)); + EXPECT_TRUE(set->find(&v13)); char s23[] = "1992-10-20 10:10:10.123456"; DateTimeValue v23; v23.from_date_str(s23, strlen(s23)); - ASSERT_FALSE(set->find(&v23)); + EXPECT_FALSE(set->find(&v23)); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/in_op_test.cpp b/be/test/exprs/in_op_test.cpp index 3de904beb9..9e0413d7b8 100644 --- a/be/test/exprs/in_op_test.cpp +++ b/be/test/exprs/in_op_test.cpp @@ -59,8 +59,8 @@ public: ttbl.slotDescriptors.push_back(slot_desc); DescriptorTbl* desc_tbl = nullptr; - ASSERT_TRUE(DescriptorTbl::create(_object_pool, ttbl, &desc_tbl).ok()); - ASSERT_TRUE(desc_tbl != nullptr); + EXPECT_TRUE(DescriptorTbl::create(_object_pool, ttbl, &desc_tbl).ok()); + EXPECT_TRUE(desc_tbl != nullptr); _runtime_state->set_desc_tbl(desc_tbl); std::vector row_tuples; @@ -142,14 +142,14 @@ private: TEST_F(InOpTest, PrepareTest) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); } TEST_F(InOpTest, NormalTest) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); int capacity = 256; VectorizedRowBatch* vec_row_batch = _object_pool->add( new VectorizedRowBatch(*_runtime_state->desc_tbl().get_tuple_descriptor(0), capacity)); @@ -163,21 +163,21 @@ TEST_F(InOpTest, NormalTest) { vec_row_batch->set_size(capacity); expr->evaluate(vec_row_batch); - ASSERT_EQ(vec_row_batch->size(), 128); + EXPECT_EQ(vec_row_batch->size(), 128); Tuple tuple; int vv = 0; while (vec_row_batch->get_next_tuple(&tuple)) { - ASSERT_EQ(vv++, *reinterpret_cast(tuple.get_slot(4))); + EXPECT_EQ(vv++, *reinterpret_cast(tuple.get_slot(4))); } } TEST_F(InOpTest, SimplePerformanceTest) { for (int capacity = 128; capacity <= 1024 * 128; capacity *= 2) { Expr* expr = create_expr(); - ASSERT_TRUE(expr != nullptr); - ASSERT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); + EXPECT_TRUE(expr != nullptr); + EXPECT_TRUE(expr->prepare(_runtime_state, *_row_desc).ok()); int size = 1024 * 1024 / capacity; VectorizedRowBatch* vec_row_batches[size]; srand(time(nullptr)); diff --git a/be/test/exprs/in_predicate_test.cpp b/be/test/exprs/in_predicate_test.cpp index 89e87e443c..20bb32a045 100644 --- a/be/test/exprs/in_predicate_test.cpp +++ b/be/test/exprs/in_predicate_test.cpp @@ -67,28 +67,28 @@ TEST_F(InPredicateTest, push_100_const) { InPredicate in_pre(_in_node); in_pre._children.push_back(_obj_pool.add(new SlotRef(TYPE_INT, 0))); Status status = in_pre.prepare(&_runtime_stat, _row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < 100; ++i) { in_pre.insert(&i); } - ASSERT_EQ(100, in_pre._hybird_set->size()); - ASSERT_EQ(1, in_pre._children.size()); + EXPECT_EQ(100, in_pre._hybird_set->size()); + EXPECT_EQ(1, in_pre._children.size()); for (int i = 0; i < 100; ++i) { _data[0] = i; - ASSERT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); + EXPECT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); } _data[0] = 101; - ASSERT_FALSE(*(bool*)in_pre.get_value(&_tuple_row)); + EXPECT_FALSE(*(bool*)in_pre.get_value(&_tuple_row)); } TEST_F(InPredicateTest, no_child) { InPredicate in_pre(_in_node); Status status = in_pre.prepare(&_runtime_stat, _row_desc); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(InPredicateTest, diff_type) { InPredicate in_pre(_in_node); @@ -100,42 +100,30 @@ TEST_F(InPredicateTest, diff_type) { } Status status = in_pre.prepare(&_runtime_stat, _row_desc); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(InPredicateTest, 100_const) { InPredicate in_pre(_in_node); init_in_pre(&in_pre); Status status = in_pre.prepare(&_runtime_stat, _row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = in_pre.prepare(&_runtime_stat, _row_desc); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(100, in_pre._hybird_set->size()); - ASSERT_EQ(2, in_pre._children.size()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(100, in_pre._hybird_set->size()); + EXPECT_EQ(2, in_pre._children.size()); for (int i = 0; i < 100; ++i) { _data[0] = i; - ASSERT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); + EXPECT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); } _data[0] = 101; - ASSERT_FALSE(*(bool*)in_pre.get_value(&_tuple_row)); + EXPECT_FALSE(*(bool*)in_pre.get_value(&_tuple_row)); _data[1] = 101; - ASSERT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); + EXPECT_TRUE(*(bool*)in_pre.get_value(&_tuple_row)); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} - -/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */ +\n \ No newline at end of file diff --git a/be/test/exprs/json_function_test.cpp b/be/test/exprs/json_function_test.cpp index 3273c7415a..36a87e27be 100644 --- a/be/test/exprs/json_function_test.cpp +++ b/be/test/exprs/json_function_test.cpp @@ -45,7 +45,7 @@ TEST_F(JsonFunctionTest, string) { rapidjson::Document document1; rapidjson::Value* res1 = JsonFunctions::get_json_object(nullptr, json_string, path_string, JSON_FUN_STRING, &document1); - ASSERT_EQ(std::string(res1->GetString()), "name"); + EXPECT_EQ(std::string(res1->GetString()), "name"); std::string json_string2("{\"price a\": [0,1,2],\"couponFee\":0}"); std::string path_string2("$.price a"); @@ -55,7 +55,7 @@ TEST_F(JsonFunctionTest, string) { rapidjson::StringBuffer buf2; rapidjson::Writer writer2(buf2); res2->Accept(writer2); - ASSERT_EQ(std::string(buf2.GetString()), "[0,1,2]"); + EXPECT_EQ(std::string(buf2.GetString()), "[0,1,2]"); std::string json_string3("{\"price a\": [],\"couponFee\":0}"); std::string path_string3("$.price a"); @@ -65,14 +65,14 @@ TEST_F(JsonFunctionTest, string) { rapidjson::StringBuffer buf3; rapidjson::Writer writer3(buf3); res3->Accept(writer3); - ASSERT_EQ(std::string(buf3.GetString()), "[]"); + EXPECT_EQ(std::string(buf3.GetString()), "[]"); std::string json_string4("{\"price a\": [],\"couponFee\":null}"); std::string path_string4("$.couponFee"); rapidjson::Document document4; rapidjson::Value* res4 = JsonFunctions::get_json_object(nullptr, json_string4, path_string4, JSON_FUN_STRING, &document4); - ASSERT_TRUE(res4->IsNull()); + EXPECT_TRUE(res4->IsNull()); std::string json_string5( "{\"blockNames\": {}," @@ -85,7 +85,7 @@ TEST_F(JsonFunctionTest, string) { rapidjson::StringBuffer buf5_1; rapidjson::Writer writer5_1(buf5_1); res5_1->Accept(writer5_1); - ASSERT_EQ(std::string(buf5_1.GetString()), "{}"); + EXPECT_EQ(std::string(buf5_1.GetString()), "{}"); std::string path_string5_2("$.seatCategories.areas.blockIds"); rapidjson::Document document5_2; @@ -94,7 +94,7 @@ TEST_F(JsonFunctionTest, string) { rapidjson::StringBuffer buf5_2; rapidjson::Writer writer5_2(buf5_2); res5_2->Accept(writer5_2); - ASSERT_EQ(std::string(buf5_2.GetString()), "[]"); + EXPECT_EQ(std::string(buf5_2.GetString()), "[]"); std::string path_string5_3("$.seatCategories.areas[0].areaId"); rapidjson::Document document5_3; @@ -103,29 +103,29 @@ TEST_F(JsonFunctionTest, string) { rapidjson::StringBuffer buf5_3; rapidjson::Writer writer5_3(buf5_3); res5_3->Accept(writer5_3); - ASSERT_EQ(std::string(buf5_3.GetString()), "205705999"); + EXPECT_EQ(std::string(buf5_3.GetString()), "205705999"); } TEST_F(JsonFunctionTest, json_quote) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(StringVal::null(), JsonFunctions::json_quote(context, StringVal::null())); + EXPECT_EQ(StringVal::null(), JsonFunctions::json_quote(context, StringVal::null())); doris_udf::StringVal res1 = JsonFunctions::json_quote(context, StringVal("null")); - ASSERT_EQ(std::string("\"null\""), std::string((char*)res1.ptr, res1.len)); + EXPECT_EQ(std::string("\"null\""), std::string((char*)res1.ptr, res1.len)); doris_udf::StringVal res2 = JsonFunctions::json_quote(context, StringVal("[1, 2, 3]")); - ASSERT_EQ(std::string("\"[1, 2, 3]\""), std::string((char*)res2.ptr, res2.len)); + EXPECT_EQ(std::string("\"[1, 2, 3]\""), std::string((char*)res2.ptr, res2.len)); doris_udf::StringVal res3 = JsonFunctions::json_quote(context, StringVal("\n\b\r\t")); - ASSERT_EQ(std::string("\"\\n\\b\\r\\t\""), std::string((char*)res3.ptr, res3.len)); + EXPECT_EQ(std::string("\"\\n\\b\\r\\t\""), std::string((char*)res3.ptr, res3.len)); doris_udf::StringVal res4 = JsonFunctions::json_quote(context, StringVal("\"")); - ASSERT_EQ(std::string("\"\\\"\""), std::string((char*)res4.ptr, res4.len)); + EXPECT_EQ(std::string("\"\\\"\""), std::string((char*)res4.ptr, res4.len)); - doris_udf::StringVal json_str= {""}; + doris_udf::StringVal json_str = {""}; doris_udf::StringVal res5 = JsonFunctions::json_quote(context, json_str); - ASSERT_EQ(std::string("\"\""), std::string((char*)res5.ptr, res5.len)); + EXPECT_EQ(std::string("\"\""), std::string((char*)res5.ptr, res5.len)); delete context; } @@ -134,19 +134,19 @@ TEST_F(JsonFunctionTest, json_array) { doris_udf::StringVal json_str1[2] = {"[1,2,3]", "5"}; doris_udf::StringVal res1 = JsonFunctions::json_array(context, 2, json_str1); - ASSERT_EQ(std::string("[\"[1,2,3]\"]"), std::string((char*)res1.ptr, res1.len)); + EXPECT_EQ(std::string("[\"[1,2,3]\"]"), std::string((char*)res1.ptr, res1.len)); doris_udf::StringVal json_str2[4] = {"1", "abc", "null", "250"}; doris_udf::StringVal res2 = JsonFunctions::json_array(context, 4, json_str2); - ASSERT_EQ(std::string("[1,\"abc\",null]"), std::string((char*)res2.ptr, res2.len)); + EXPECT_EQ(std::string("[1,\"abc\",null]"), std::string((char*)res2.ptr, res2.len)); - doris_udf::StringVal json_str3[1]= {""}; + doris_udf::StringVal json_str3[1] = {""}; doris_udf::StringVal res3 = JsonFunctions::json_array(context, 1, json_str3); - ASSERT_EQ(std::string("[]"), std::string((char*)res3.ptr, res3.len)); + EXPECT_EQ(std::string("[]"), std::string((char*)res3.ptr, res3.len)); - doris_udf::StringVal json_str4[2]= {"null","0"}; + doris_udf::StringVal json_str4[2] = {"null", "0"}; doris_udf::StringVal res4 = JsonFunctions::json_array(context, 2, json_str4); - ASSERT_EQ(std::string("[null]"), std::string((char*)res4.ptr, res4.len)); + EXPECT_EQ(std::string("[null]"), std::string((char*)res4.ptr, res4.len)); delete context; } @@ -154,20 +154,20 @@ TEST_F(JsonFunctionTest, json_object) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); doris_udf::StringVal json_str1[3] = {"id", "87", "52"}; doris_udf::StringVal res1 = JsonFunctions::json_object(context, 3, json_str1); - ASSERT_EQ(std::string("{\"id\":87}"), std::string((char*)res1.ptr, res1.len)); + EXPECT_EQ(std::string("{\"id\":87}"), std::string((char*)res1.ptr, res1.len)); doris_udf::StringVal json_str2[5] = {"name", "Jack", "score", "[87,98,90]", "5555"}; doris_udf::StringVal res2 = JsonFunctions::json_object(context, 5, json_str2); - ASSERT_EQ(std::string("{\"name\":\"Jack\",\"score\":\"[87,98,90]\"}"), + EXPECT_EQ(std::string("{\"name\":\"Jack\",\"score\":\"[87,98,90]\"}"), std::string((char*)res2.ptr, res2.len)); - doris_udf::StringVal json_str3[3] = {"key", "null","50"}; + doris_udf::StringVal json_str3[3] = {"key", "null", "50"}; doris_udf::StringVal res3 = JsonFunctions::json_object(context, 3, json_str3); - ASSERT_EQ(std::string("{\"key\":null}"), std::string((char*)res3.ptr, res3.len)); + EXPECT_EQ(std::string("{\"key\":null}"), std::string((char*)res3.ptr, res3.len)); - doris_udf::StringVal json_str4[1]= {""}; + doris_udf::StringVal json_str4[1] = {""}; doris_udf::StringVal res4 = JsonFunctions::json_object(context, 1, json_str4); - ASSERT_EQ(std::string("{}"), std::string((char*)res4.ptr, res4.len)); + EXPECT_EQ(std::string("{}"), std::string((char*)res4.ptr, res4.len)); delete context; } @@ -177,7 +177,7 @@ TEST_F(JsonFunctionTest, int) { rapidjson::Document document; rapidjson::Value* res = JsonFunctions::get_json_object(nullptr, json_string, path_string, JSON_FUN_INT, &document); - ASSERT_EQ(res->GetInt(), 11); + EXPECT_EQ(res->GetInt(), 11); std::string json_string1( "{\"list\":[{\"id\":[{\"aa\":1}]},{\"id\":[{\"aa\":\"cc\"}]}," @@ -186,27 +186,27 @@ TEST_F(JsonFunctionTest, int) { rapidjson::Document document1; rapidjson::Value* res1 = JsonFunctions::get_json_object(nullptr, json_string1, path_string1, JSON_FUN_INT, &document1); - ASSERT_EQ(res1->GetInt(), 1); + EXPECT_EQ(res1->GetInt(), 1); std::string json_string2("[1,2,3,5,8,0]"); std::string path_string2("$.[3]"); rapidjson::Document document2; rapidjson::Value* res2 = JsonFunctions::get_json_object(nullptr, json_string2, path_string2, JSON_FUN_INT, &document2); - ASSERT_EQ(res2->GetInt(), 5); + EXPECT_EQ(res2->GetInt(), 5); std::string json_string3("{\"price a\": [0,1,2],\"couponFee\":0.0}"); std::string path_string3_1("$.price a[3]"); rapidjson::Document document3_1; rapidjson::Value* res3_1 = JsonFunctions::get_json_object(nullptr, json_string3, path_string3_1, JSON_FUN_INT, &document3_1); - ASSERT_TRUE(res3_1 == nullptr); + EXPECT_TRUE(res3_1 == nullptr); std::string path_string3_2("$.couponFee"); rapidjson::Document document3_2; rapidjson::Value* res3_2 = JsonFunctions::get_json_object(nullptr, json_string3, path_string3_2, JSON_FUN_INT, &document3_2); - ASSERT_FALSE(res3_2->IsInt()); + EXPECT_FALSE(res3_2->IsInt()); } TEST_F(JsonFunctionTest, double) { @@ -215,13 +215,13 @@ TEST_F(JsonFunctionTest, double) { rapidjson::Document document; rapidjson::Value* res = JsonFunctions::get_json_object(nullptr, json_string, path_string, JSON_FUN_DOUBLE, &document); - ASSERT_EQ(res->GetDouble(), 123000.789); + EXPECT_EQ(res->GetDouble(), 123000.789); std::string path_string2("$.age"); rapidjson::Document document2; rapidjson::Value* res2 = JsonFunctions::get_json_object(nullptr, json_string, path_string2, JSON_FUN_DOUBLE, &document2); - ASSERT_EQ(res2->GetInt(), 11); + EXPECT_EQ(res2->GetInt(), 11); } TEST_F(JsonFunctionTest, special_char) { @@ -230,24 +230,24 @@ TEST_F(JsonFunctionTest, special_char) { rapidjson::Document document; rapidjson::Value* res = JsonFunctions::get_json_object(nullptr, json_string, path_string, JSON_FUN_DOUBLE, &document); - ASSERT_FALSE(res->GetString() == nullptr); - ASSERT_EQ(std::string(res->GetString()), "v2"); + EXPECT_FALSE(res->GetString() == nullptr); + EXPECT_EQ(std::string(res->GetString()), "v2"); std::string json_string2("{\"key with|\": [\"v1\", \"v2\"]}"); std::string path_string2("$.key with|[0]"); rapidjson::Document document2; rapidjson::Value* res2 = JsonFunctions::get_json_object(nullptr, json_string2, path_string2, JSON_FUN_DOUBLE, &document2); - ASSERT_FALSE(res2->GetString() == nullptr); - ASSERT_EQ(std::string(res2->GetString()), "v1"); + EXPECT_FALSE(res2->GetString() == nullptr); + EXPECT_EQ(std::string(res2->GetString()), "v1"); std::string json_string3("{\"key with.dot\": [{\"key2.dot\":\"v1\"}, {\"key3.dot\":\"v2\"}]}"); std::string path_string3("$.\"key with.dot\"[0].\"key2.dot\""); rapidjson::Document document3; rapidjson::Value* res3 = JsonFunctions::get_json_object(nullptr, json_string3, path_string3, JSON_FUN_DOUBLE, &document3); - ASSERT_FALSE(res3->GetString() == nullptr); - ASSERT_EQ(std::string(res3->GetString()), "v1"); + EXPECT_FALSE(res3->GetString() == nullptr); + EXPECT_EQ(std::string(res3->GetString()), "v1"); } TEST_F(JsonFunctionTest, json_path1) { @@ -257,30 +257,25 @@ TEST_F(JsonFunctionTest, json_path1) { "\"keyname\":{\"ip\":\"10.20.10.1\",\"value\":20}}]"); rapidjson::Document jsonDoc; if (jsonDoc.Parse(json_raw_data.c_str()).HasParseError()) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } rapidjson::Value* res3; res3 = JsonFunctions::get_json_array_from_parsed_json("$.[*].keyname.ip", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); - for (int i = 0; i < res3->Size(); i++) { - std::cout << (*res3)[i].GetString() << std::endl; - } + EXPECT_TRUE(res3->IsArray()); res3 = JsonFunctions::get_json_array_from_parsed_json("$.[*].k1", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); - for (int i = 0; i < res3->Size(); i++) { - std::cout << (*res3)[i].GetString() << std::endl; - } + EXPECT_TRUE(res3->IsArray()); - res3 = JsonFunctions::get_json_array_from_parsed_json("$", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); + res3 = JsonFunctions::get_json_array_from_parsed_json("$", &jsonDoc, jsonDoc.GetAllocator(), + &wrap_explicitly); + EXPECT_TRUE(res3->IsArray()); rapidjson::StringBuffer buffer; buffer.Clear(); rapidjson::Writer writer(buffer); (*res3)[0].Accept(writer); - ASSERT_EQ(json_raw_data, std::string(buffer.GetString())); + EXPECT_EQ(json_raw_data, std::string(buffer.GetString())); } TEST_F(JsonFunctionTest, json_path_get_nullobject) { @@ -290,21 +285,13 @@ TEST_F(JsonFunctionTest, json_path_get_nullobject) { "\"c\":\"c2\"},{\"a\":\"a3\", \"b\":\"b3\", \"c\":\"c3\"}]"); rapidjson::Document jsonDoc; if (jsonDoc.Parse(json_raw_data.c_str()).HasParseError()) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } - rapidjson::Value* res3 = JsonFunctions::get_json_array_from_parsed_json("$.[*].b", &jsonDoc, - jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); - ASSERT_EQ(res3->Size(), 3); - for (int i = 0; i < res3->Size(); i++) { - if ((*res3)[i].GetType() == rapidjson::Type::kNullType) { - std::cout << "null "; - } else { - std::cout << (*res3)[i].GetString() << " "; - } - } - std::cout << " " << std::endl; + rapidjson::Value* res3 = JsonFunctions::get_json_array_from_parsed_json( + "$.[*].b", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); + EXPECT_TRUE(res3->IsArray()); + EXPECT_EQ(res3->Size(), 3); } TEST_F(JsonFunctionTest, json_path_test) { @@ -313,75 +300,46 @@ TEST_F(JsonFunctionTest, json_path_test) { std::string json_raw_data("[{\"a\":\"a1\", \"b\":\"b1\"}, {\"a\":\"a2\", \"b\":\"b2\"}]"); rapidjson::Document jsonDoc; if (jsonDoc.Parse(json_raw_data.c_str()).HasParseError()) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } rapidjson::Value* res3 = JsonFunctions::get_json_array_from_parsed_json( "$.[*].a", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); - ASSERT_EQ(res3->Size(), 2); - for (int i = 0; i < res3->Size(); i++) { - if ((*res3)[i].GetType() == rapidjson::Type::kNullType) { - std::cout << "null "; - } else { - std::cout << (*res3)[i].GetString() << " "; - } - } - std::cout << " " << std::endl; + EXPECT_TRUE(res3->IsArray()); + EXPECT_EQ(res3->Size(), 2); } { - std::string json_raw_data("{\"a\":[\"a1\",\"a2\"], \"b\":[\"b1\",\"b2\"], \"c\":[\"c1\"], \"d\":[], \"e\":\"e1\"}"); + std::string json_raw_data( + "{\"a\":[\"a1\",\"a2\"], \"b\":[\"b1\",\"b2\"], \"c\":[\"c1\"], \"d\":[], " + "\"e\":\"e1\"}"); rapidjson::Document jsonDoc; if (jsonDoc.Parse(json_raw_data.c_str()).HasParseError()) { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } rapidjson::Value* res3 = JsonFunctions::get_json_array_from_parsed_json( "$.a", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res3->IsArray()); - ASSERT_EQ(res3->Size(), 2); - for (int i = 0; i < res3->Size(); i++) { - if ((*res3)[i].GetType() == rapidjson::Type::kNullType) { - std::cout << "null "; - } else { - std::cout << (*res3)[i].GetString() << " "; - } - } - std::cout << " " << std::endl; + EXPECT_TRUE(res3->IsArray()); + EXPECT_EQ(res3->Size(), 2); rapidjson::Value* res4 = JsonFunctions::get_json_array_from_parsed_json( "$.c", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res4->IsArray()); - ASSERT_EQ(res4->Size(), 1); - ASSERT_FALSE(wrap_explicitly); + EXPECT_TRUE(res4->IsArray()); + EXPECT_EQ(res4->Size(), 1); + EXPECT_FALSE(wrap_explicitly); rapidjson::Value* res5 = JsonFunctions::get_json_array_from_parsed_json( "$.d", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res5->IsArray()); - ASSERT_EQ(res5->Size(), 0); - ASSERT_FALSE(wrap_explicitly); + EXPECT_TRUE(res5->IsArray()); + EXPECT_EQ(res5->Size(), 0); + EXPECT_FALSE(wrap_explicitly); rapidjson::Value* res6 = JsonFunctions::get_json_array_from_parsed_json( "$.e", &jsonDoc, jsonDoc.GetAllocator(), &wrap_explicitly); - ASSERT_TRUE(res6->IsArray()); - ASSERT_EQ(res6->Size(), 1); - ASSERT_TRUE(wrap_explicitly); + EXPECT_TRUE(res6->IsArray()); + EXPECT_EQ(res6->Size(), 1); + EXPECT_TRUE(wrap_explicitly); } } } // namespace doris - -int main(int argc, char** argv) { - std::string home(getenv("DORIS_HOME")); - if (home.empty()) { - home = "."; - } - std::string conffile = home + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/math_functions_test.cpp b/be/test/exprs/math_functions_test.cpp index c9008d89ad..1c8f12a6f5 100644 --- a/be/test/exprs/math_functions_test.cpp +++ b/be/test/exprs/math_functions_test.cpp @@ -24,8 +24,8 @@ #include "exprs/anyval_util.h" #include "exprs/expr_context.h" -#include "test_util/test_util.h" #include "testutil/function_utils.h" +#include "testutil/test_util.h" #include "util/logging.h" namespace doris { @@ -50,28 +50,28 @@ TEST_F(MathFunctionsTest, abs) { FloatVal fv2(0.1f); FloatVal fv3(FLT_MAX); FloatVal fv4(FLT_MIN); - ASSERT_EQ(fv1, MathFunctions::abs(ctx, FloatVal(0.0))); - ASSERT_EQ(fv1, MathFunctions::abs(ctx, FloatVal(-0.0))); - ASSERT_EQ(fv2, MathFunctions::abs(ctx, FloatVal(0.1))); - ASSERT_EQ(fv2, MathFunctions::abs(ctx, FloatVal(-0.1))); - ASSERT_EQ(fv3, MathFunctions::abs(ctx, FloatVal(FLT_MAX))); - ASSERT_EQ(fv3, MathFunctions::abs(ctx, FloatVal(-FLT_MAX))); - ASSERT_EQ(fv4, MathFunctions::abs(ctx, FloatVal(FLT_MIN))); - ASSERT_EQ(fv4, MathFunctions::abs(ctx, FloatVal(-FLT_MIN))); + EXPECT_EQ(fv1, MathFunctions::abs(ctx, FloatVal(0.0))); + EXPECT_EQ(fv1, MathFunctions::abs(ctx, FloatVal(-0.0))); + EXPECT_EQ(fv2, MathFunctions::abs(ctx, FloatVal(0.1))); + EXPECT_EQ(fv2, MathFunctions::abs(ctx, FloatVal(-0.1))); + EXPECT_EQ(fv3, MathFunctions::abs(ctx, FloatVal(FLT_MAX))); + EXPECT_EQ(fv3, MathFunctions::abs(ctx, FloatVal(-FLT_MAX))); + EXPECT_EQ(fv4, MathFunctions::abs(ctx, FloatVal(FLT_MIN))); + EXPECT_EQ(fv4, MathFunctions::abs(ctx, FloatVal(-FLT_MIN))); // DoubleVal DoubleVal dv1(0.0); DoubleVal dv2(0.1); DoubleVal dv3(DBL_MAX); DoubleVal dv4(DBL_MIN); - ASSERT_EQ(dv1, MathFunctions::abs(ctx, DoubleVal(0.0))); - ASSERT_EQ(dv1, MathFunctions::abs(ctx, DoubleVal(-0.0))); - ASSERT_EQ(dv2, MathFunctions::abs(ctx, DoubleVal(0.1))); - ASSERT_EQ(dv2, MathFunctions::abs(ctx, DoubleVal(-0.1))); - ASSERT_EQ(dv3, MathFunctions::abs(ctx, DoubleVal(DBL_MAX))); - ASSERT_EQ(dv3, MathFunctions::abs(ctx, DoubleVal(-DBL_MAX))); - ASSERT_EQ(dv4, MathFunctions::abs(ctx, DoubleVal(DBL_MIN))); - ASSERT_EQ(dv4, MathFunctions::abs(ctx, DoubleVal(-DBL_MIN))); + EXPECT_EQ(dv1, MathFunctions::abs(ctx, DoubleVal(0.0))); + EXPECT_EQ(dv1, MathFunctions::abs(ctx, DoubleVal(-0.0))); + EXPECT_EQ(dv2, MathFunctions::abs(ctx, DoubleVal(0.1))); + EXPECT_EQ(dv2, MathFunctions::abs(ctx, DoubleVal(-0.1))); + EXPECT_EQ(dv3, MathFunctions::abs(ctx, DoubleVal(DBL_MAX))); + EXPECT_EQ(dv3, MathFunctions::abs(ctx, DoubleVal(-DBL_MAX))); + EXPECT_EQ(dv4, MathFunctions::abs(ctx, DoubleVal(DBL_MIN))); + EXPECT_EQ(dv4, MathFunctions::abs(ctx, DoubleVal(-DBL_MIN))); // LargeIntVal LargeIntVal liv1(0); @@ -80,20 +80,20 @@ TEST_F(MathFunctionsTest, abs) { LargeIntVal liv4(__int128(INT64_MAX)); LargeIntVal liv5(-__int128(INT64_MIN)); - ASSERT_EQ(liv1, MathFunctions::abs(ctx, LargeIntVal(0))); - ASSERT_EQ(liv1, MathFunctions::abs(ctx, LargeIntVal(-0))); - ASSERT_EQ(liv2, MathFunctions::abs(ctx, LargeIntVal(1))); - ASSERT_EQ(liv2, MathFunctions::abs(ctx, LargeIntVal(-1))); - ASSERT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(MAX_INT128))); - ASSERT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(-MAX_INT128))); - ASSERT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(MIN_INT128 + 1))); + EXPECT_EQ(liv1, MathFunctions::abs(ctx, LargeIntVal(0))); + EXPECT_EQ(liv1, MathFunctions::abs(ctx, LargeIntVal(-0))); + EXPECT_EQ(liv2, MathFunctions::abs(ctx, LargeIntVal(1))); + EXPECT_EQ(liv2, MathFunctions::abs(ctx, LargeIntVal(-1))); + EXPECT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(MAX_INT128))); + EXPECT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(-MAX_INT128))); + EXPECT_EQ(liv3, MathFunctions::abs(ctx, LargeIntVal(MIN_INT128 + 1))); // BigIntVal - ASSERT_EQ(liv1, MathFunctions::abs(ctx, BigIntVal(0))); - ASSERT_EQ(liv1, MathFunctions::abs(ctx, BigIntVal(-0))); - ASSERT_EQ(liv2, MathFunctions::abs(ctx, BigIntVal(1))); - ASSERT_EQ(liv2, MathFunctions::abs(ctx, BigIntVal(-1))); - ASSERT_EQ(liv4, MathFunctions::abs(ctx, BigIntVal(INT64_MAX))); - ASSERT_EQ(liv5, MathFunctions::abs(ctx, BigIntVal(INT64_MIN))); + EXPECT_EQ(liv1, MathFunctions::abs(ctx, BigIntVal(0))); + EXPECT_EQ(liv1, MathFunctions::abs(ctx, BigIntVal(-0))); + EXPECT_EQ(liv2, MathFunctions::abs(ctx, BigIntVal(1))); + EXPECT_EQ(liv2, MathFunctions::abs(ctx, BigIntVal(-1))); + EXPECT_EQ(liv4, MathFunctions::abs(ctx, BigIntVal(INT64_MAX))); + EXPECT_EQ(liv5, MathFunctions::abs(ctx, BigIntVal(INT64_MIN))); // IntVal BigIntVal biv1(0); @@ -101,36 +101,36 @@ TEST_F(MathFunctionsTest, abs) { BigIntVal biv3(int64_t(INT32_MAX)); BigIntVal biv4(-int64_t(INT32_MIN)); - ASSERT_EQ(biv1, MathFunctions::abs(ctx, IntVal(0))); - ASSERT_EQ(biv1, MathFunctions::abs(ctx, IntVal(-0))); - ASSERT_EQ(biv2, MathFunctions::abs(ctx, IntVal(1))); - ASSERT_EQ(biv2, MathFunctions::abs(ctx, IntVal(-1))); - ASSERT_EQ(biv3, MathFunctions::abs(ctx, IntVal(INT32_MAX))); - ASSERT_EQ(biv4, MathFunctions::abs(ctx, IntVal(INT32_MIN))); + EXPECT_EQ(biv1, MathFunctions::abs(ctx, IntVal(0))); + EXPECT_EQ(biv1, MathFunctions::abs(ctx, IntVal(-0))); + EXPECT_EQ(biv2, MathFunctions::abs(ctx, IntVal(1))); + EXPECT_EQ(biv2, MathFunctions::abs(ctx, IntVal(-1))); + EXPECT_EQ(biv3, MathFunctions::abs(ctx, IntVal(INT32_MAX))); + EXPECT_EQ(biv4, MathFunctions::abs(ctx, IntVal(INT32_MIN))); // SmallIntVal IntVal iv1(0); IntVal iv2(1); IntVal iv3(int32_t(INT16_MAX)); IntVal iv4(-int32_t(INT16_MIN)); - ASSERT_EQ(iv1, MathFunctions::abs(ctx, SmallIntVal(0))); - ASSERT_EQ(iv1, MathFunctions::abs(ctx, SmallIntVal(-0))); - ASSERT_EQ(iv2, MathFunctions::abs(ctx, SmallIntVal(1))); - ASSERT_EQ(iv2, MathFunctions::abs(ctx, SmallIntVal(-1))); - ASSERT_EQ(iv3, MathFunctions::abs(ctx, SmallIntVal(INT16_MAX))); - ASSERT_EQ(iv4, MathFunctions::abs(ctx, SmallIntVal(INT16_MIN))); + EXPECT_EQ(iv1, MathFunctions::abs(ctx, SmallIntVal(0))); + EXPECT_EQ(iv1, MathFunctions::abs(ctx, SmallIntVal(-0))); + EXPECT_EQ(iv2, MathFunctions::abs(ctx, SmallIntVal(1))); + EXPECT_EQ(iv2, MathFunctions::abs(ctx, SmallIntVal(-1))); + EXPECT_EQ(iv3, MathFunctions::abs(ctx, SmallIntVal(INT16_MAX))); + EXPECT_EQ(iv4, MathFunctions::abs(ctx, SmallIntVal(INT16_MIN))); //TinyIntVal SmallIntVal siv1(0); SmallIntVal siv2(1); SmallIntVal siv3(int16_t(INT8_MAX)); SmallIntVal siv4(-int16_t(INT8_MIN)); - ASSERT_EQ(siv1, MathFunctions::abs(ctx, TinyIntVal(0))); - ASSERT_EQ(siv1, MathFunctions::abs(ctx, TinyIntVal(-0))); - ASSERT_EQ(siv2, MathFunctions::abs(ctx, TinyIntVal(1))); - ASSERT_EQ(siv2, MathFunctions::abs(ctx, TinyIntVal(-1))); - ASSERT_EQ(siv3, MathFunctions::abs(ctx, TinyIntVal(INT8_MAX))); - ASSERT_EQ(siv4, MathFunctions::abs(ctx, TinyIntVal(INT8_MIN))); + EXPECT_EQ(siv1, MathFunctions::abs(ctx, TinyIntVal(0))); + EXPECT_EQ(siv1, MathFunctions::abs(ctx, TinyIntVal(-0))); + EXPECT_EQ(siv2, MathFunctions::abs(ctx, TinyIntVal(1))); + EXPECT_EQ(siv2, MathFunctions::abs(ctx, TinyIntVal(-1))); + EXPECT_EQ(siv3, MathFunctions::abs(ctx, TinyIntVal(INT8_MAX))); + EXPECT_EQ(siv4, MathFunctions::abs(ctx, TinyIntVal(INT8_MIN))); } TEST_F(MathFunctionsTest, rand) { @@ -155,7 +155,7 @@ TEST_F(MathFunctionsTest, rand) { DoubleVal dv2 = MathFunctions::rand_seed(ctx1, BigIntVal(0)); MathFunctions::rand_close(ctx1, FunctionContext::THREAD_LOCAL); - ASSERT_EQ(dv1.val, dv2.val); + EXPECT_EQ(dv1.val, dv2.val); delete utils1; MathFunctions::rand_prepare(ctx, FunctionContext::THREAD_LOCAL); @@ -166,105 +166,81 @@ TEST_F(MathFunctionsTest, rand) { DoubleVal dv4 = MathFunctions::rand(ctx); MathFunctions::rand_close(ctx, FunctionContext::THREAD_LOCAL); - ASSERT_NE(dv3.val, dv4.val); + EXPECT_NE(dv3.val, dv4.val); } TEST_F(MathFunctionsTest, hex_int) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - - ASSERT_EQ(StringVal::null(), - MathFunctions::hex_string(context, StringVal::null())); - - ASSERT_EQ(StringVal("7FFFFFFFFFFFFFFF"), - MathFunctions::hex_int(context, BigIntVal(9223372036854775807))); //BigIntVal max_value - - ASSERT_EQ(StringVal("FFE5853AB393E6C0"), + + EXPECT_EQ(StringVal::null(), MathFunctions::hex_string(context, StringVal::null())); + + EXPECT_EQ( + StringVal("7FFFFFFFFFFFFFFF"), + MathFunctions::hex_int(context, BigIntVal(9223372036854775807))); //BigIntVal max_value + + EXPECT_EQ(StringVal("FFE5853AB393E6C0"), MathFunctions::hex_int(context, BigIntVal(-7453337203775808))); - - ASSERT_EQ(StringVal("0"), - MathFunctions::hex_int(context, BigIntVal(0))); - - ASSERT_EQ(StringVal("C"), - MathFunctions::hex_int(context, BigIntVal(12))); - - ASSERT_EQ(StringVal("90"), - MathFunctions::hex_int(context, BigIntVal(144))); - - ASSERT_EQ(StringVal("FFFFFFFFFFFFFFFF"), - MathFunctions::hex_int(context, BigIntVal(-1))); - - ASSERT_EQ(StringVal("FFFFFFFFFFFFFFFE"), - MathFunctions::hex_int(context, BigIntVal(-2))); - - ASSERT_EQ(StringVal("24EC1"), - MathFunctions::hex_int(context, BigIntVal(151233))); - + + EXPECT_EQ(StringVal("0"), MathFunctions::hex_int(context, BigIntVal(0))); + + EXPECT_EQ(StringVal("C"), MathFunctions::hex_int(context, BigIntVal(12))); + + EXPECT_EQ(StringVal("90"), MathFunctions::hex_int(context, BigIntVal(144))); + + EXPECT_EQ(StringVal("FFFFFFFFFFFFFFFF"), MathFunctions::hex_int(context, BigIntVal(-1))); + + EXPECT_EQ(StringVal("FFFFFFFFFFFFFFFE"), MathFunctions::hex_int(context, BigIntVal(-2))); + + EXPECT_EQ(StringVal("24EC1"), MathFunctions::hex_int(context, BigIntVal(151233))); + delete context; } TEST_F(MathFunctionsTest, hex_string) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - - ASSERT_EQ(StringVal::null(), - MathFunctions::hex_string(context, StringVal::null())); - - ASSERT_EQ(StringVal("30"), - MathFunctions::hex_string(context, StringVal("0"))); - ASSERT_EQ(StringVal("31"), - MathFunctions::hex_string(context, StringVal("1"))); + EXPECT_EQ(StringVal::null(), MathFunctions::hex_string(context, StringVal::null())); - ASSERT_EQ(StringVal("313233"), - MathFunctions::hex_string(context, StringVal("123"))); + EXPECT_EQ(StringVal("30"), MathFunctions::hex_string(context, StringVal("0"))); - ASSERT_EQ(StringVal("41"), - MathFunctions::hex_string(context, StringVal("A"))); + EXPECT_EQ(StringVal("31"), MathFunctions::hex_string(context, StringVal("1"))); - ASSERT_EQ(StringVal("61"), - MathFunctions::hex_string(context, StringVal("a"))); + EXPECT_EQ(StringVal("313233"), MathFunctions::hex_string(context, StringVal("123"))); - ASSERT_EQ(StringVal("E68891"), - MathFunctions::hex_string(context, StringVal("我"))); + EXPECT_EQ(StringVal("41"), MathFunctions::hex_string(context, StringVal("A"))); + + EXPECT_EQ(StringVal("61"), MathFunctions::hex_string(context, StringVal("a"))); + + EXPECT_EQ(StringVal("E68891"), MathFunctions::hex_string(context, StringVal("我"))); + + EXPECT_EQ(StringVal("3F"), MathFunctions::hex_string(context, StringVal("?"))); - ASSERT_EQ(StringVal("3F"), - MathFunctions::hex_string(context, StringVal("?"))); - delete context; } TEST_F(MathFunctionsTest, unhex) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - - ASSERT_EQ(StringVal::null(), - MathFunctions::unhex(context, StringVal::null())); - - ASSERT_EQ(StringVal("123"), - MathFunctions::unhex(context, StringVal("313233"))); - ASSERT_EQ(StringVal(""), - MathFunctions::unhex(context, StringVal("@!#"))); - - ASSERT_EQ(StringVal(""), - MathFunctions::unhex(context, StringVal("@@"))); - - ASSERT_EQ(StringVal("a"), - MathFunctions::unhex(context, StringVal("61"))); - - ASSERT_EQ(StringVal("123"), - MathFunctions::unhex(context, StringVal("313233"))); - - ASSERT_EQ(StringVal(""), - MathFunctions::unhex(context, StringVal("我"))); - - ASSERT_EQ(StringVal("？"), - MathFunctions::unhex(context, StringVal("EFBC9F"))); - + EXPECT_EQ(StringVal::null(), MathFunctions::unhex(context, StringVal::null())); + + EXPECT_EQ(StringVal("123"), MathFunctions::unhex(context, StringVal("313233"))); + + EXPECT_EQ(StringVal(""), MathFunctions::unhex(context, StringVal("@!#"))); + + EXPECT_EQ(StringVal(""), MathFunctions::unhex(context, StringVal("@@"))); + + EXPECT_EQ(StringVal("a"), MathFunctions::unhex(context, StringVal("61"))); + + EXPECT_EQ(StringVal("123"), MathFunctions::unhex(context, StringVal("313233"))); + + EXPECT_EQ(StringVal(""), MathFunctions::unhex(context, StringVal("我"))); + + EXPECT_EQ(StringVal("？"), MathFunctions::unhex(context, StringVal("EFBC9F"))); + delete context; } - TEST_F(MathFunctionsTest, round_up_to) { - DoubleVal r0(0); DoubleVal r1(1); DoubleVal r2(3); @@ -274,31 +250,21 @@ TEST_F(MathFunctionsTest, round_up_to) { DoubleVal r6(222500); - ASSERT_EQ(r0, MathFunctions::round_up_to(ctx, DoubleVal(0), IntVal(0))); - ASSERT_EQ(r1, MathFunctions::round_up_to(ctx, DoubleVal(0.5), IntVal(0))); - ASSERT_EQ(r1, MathFunctions::round_up_to(ctx, DoubleVal(0.51), IntVal(0))); + EXPECT_EQ(r0, MathFunctions::round_up_to(ctx, DoubleVal(0), IntVal(0))); + EXPECT_EQ(r1, MathFunctions::round_up_to(ctx, DoubleVal(0.5), IntVal(0))); + EXPECT_EQ(r1, MathFunctions::round_up_to(ctx, DoubleVal(0.51), IntVal(0))); // not 2 - ASSERT_EQ(r2, MathFunctions::round_up_to(ctx, DoubleVal(2.5), IntVal(0))); - ASSERT_EQ(r3, MathFunctions::round_up_to(ctx, DoubleVal(3.5), IntVal(0))); + EXPECT_EQ(r2, MathFunctions::round_up_to(ctx, DoubleVal(2.5), IntVal(0))); + EXPECT_EQ(r3, MathFunctions::round_up_to(ctx, DoubleVal(3.5), IntVal(0))); - ASSERT_EQ(r4, MathFunctions::round_up_to(ctx, DoubleVal(3.5451), IntVal(1))); - ASSERT_EQ(r5, MathFunctions::round_up_to(ctx, DoubleVal(3.5451), IntVal(2))); + EXPECT_EQ(r4, MathFunctions::round_up_to(ctx, DoubleVal(3.5451), IntVal(1))); + EXPECT_EQ(r5, MathFunctions::round_up_to(ctx, DoubleVal(3.5451), IntVal(2))); // not 3.54 - ASSERT_EQ(r5, MathFunctions::round_up_to(ctx, DoubleVal(3.5450), IntVal(2))); + EXPECT_EQ(r5, MathFunctions::round_up_to(ctx, DoubleVal(3.5450), IntVal(2))); // not 222400 - ASSERT_EQ(r6, MathFunctions::round_up_to(ctx, DoubleVal(222450.00), IntVal(-2))); + EXPECT_EQ(r6, MathFunctions::round_up_to(ctx, DoubleVal(222450.00), IntVal(-2))); } -}// namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file +} // namespace doris diff --git a/be/test/exprs/percentile_approx_test.cpp b/be/test/exprs/percentile_approx_test.cpp index 57a65359ad..b7f4e51d01 100644 --- a/be/test/exprs/percentile_approx_test.cpp +++ b/be/test/exprs/percentile_approx_test.cpp @@ -46,7 +46,7 @@ TEST_F(PercentileApproxTest, testSample) { AggregateFunctions::percentile_approx_init(context, &stringVal2); AggregateFunctions::percentile_approx_merge(context, s, &stringVal2); DoubleVal v = AggregateFunctions::percentile_approx_finalize(context, stringVal2); - ASSERT_EQ(v.val, 2); + EXPECT_EQ(v.val, 2); delete futil; } @@ -64,7 +64,7 @@ TEST_F(PercentileApproxTest, testNoMerge) { AggregateFunctions::percentile_approx_update(context, val2, doubleQ, &stringVal1); DoubleVal v = AggregateFunctions::percentile_approx_finalize(context, stringVal1); - ASSERT_EQ(v.val, 2); + EXPECT_EQ(v.val, 2); delete futil; } @@ -87,7 +87,7 @@ TEST_F(PercentileApproxTest, testSerialize) { AggregateFunctions::percentile_approx_init(context, &stringVal2); AggregateFunctions::percentile_approx_merge(context, serialized, &stringVal2); DoubleVal v = AggregateFunctions::percentile_approx_finalize(context, stringVal2); - ASSERT_DOUBLE_EQ(v.val, 99900.5); + EXPECT_DOUBLE_EQ(v.val, 99900.5); // merge init percentile stringVal3 should not change the correct result AggregateFunctions::percentile_approx_init(context, &stringVal); @@ -106,7 +106,7 @@ TEST_F(PercentileApproxTest, testSerialize) { AggregateFunctions::percentile_approx_merge(context, serialized, &stringVal2); AggregateFunctions::percentile_approx_merge(context, serialized2, &stringVal2); v = AggregateFunctions::percentile_approx_finalize(context, stringVal2); - ASSERT_DOUBLE_EQ(v.val, 99900.5); + EXPECT_DOUBLE_EQ(v.val, 99900.5); delete futil; } @@ -135,13 +135,8 @@ TEST_F(PercentileApproxTest, testNullVale) { AggregateFunctions::percentile_approx_init(context, &stringVal2); AggregateFunctions::percentile_approx_merge(context, serialized, &stringVal2); DoubleVal v = AggregateFunctions::percentile_approx_finalize(context, stringVal2); - ASSERT_FLOAT_EQ(v.val, 99900.665999999997); + EXPECT_FLOAT_EQ(v.val, 99900.665999999997); delete futil; } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/percentile_test.cpp b/be/test/exprs/percentile_test.cpp index 8054d08624..bae6774365 100644 --- a/be/test/exprs/percentile_test.cpp +++ b/be/test/exprs/percentile_test.cpp @@ -46,7 +46,7 @@ TEST_F(PercentileTest, testSample) { AggregateFunctions::percentile_init(context, &stringVal2); AggregateFunctions::percentile_merge(context, s, &stringVal2); DoubleVal v = AggregateFunctions::percentile_finalize(context, stringVal2); - ASSERT_EQ(v.val, 1.9); + EXPECT_EQ(v.val, 1.9); delete futil; } @@ -64,7 +64,7 @@ TEST_F(PercentileTest, testNoMerge) { AggregateFunctions::percentile_update(context, val2, doubleQ, &stringVal1); DoubleVal v = AggregateFunctions::percentile_finalize(context, stringVal1); - ASSERT_EQ(v.val, 1.9); + EXPECT_EQ(v.val, 1.9); delete futil; } @@ -87,7 +87,7 @@ TEST_F(PercentileTest, testSerialize) { AggregateFunctions::percentile_init(context, &stringVal2); AggregateFunctions::percentile_merge(context, serialized, &stringVal2); DoubleVal v = AggregateFunctions::percentile_finalize(context, stringVal2); - ASSERT_DOUBLE_EQ(v.val, 99900.001); + EXPECT_DOUBLE_EQ(v.val, 99900.001); // merge init percentile stringVal3 should not change the correct result AggregateFunctions::percentile_init(context, &stringVal); @@ -106,14 +106,9 @@ TEST_F(PercentileTest, testSerialize) { AggregateFunctions::percentile_merge(context, serialized, &stringVal2); AggregateFunctions::percentile_merge(context, serialized2, &stringVal2); v = AggregateFunctions::percentile_finalize(context, stringVal2); - ASSERT_DOUBLE_EQ(v.val, 99900.001); + EXPECT_DOUBLE_EQ(v.val, 99900.001); delete futil; } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/quantile_function_test.cpp b/be/test/exprs/quantile_function_test.cpp index 46c95413fd..89593702d0 100644 --- a/be/test/exprs/quantile_function_test.cpp +++ b/be/test/exprs/quantile_function_test.cpp @@ -64,7 +64,7 @@ TEST_F(QuantileStateFunctionsTest, to_quantile_state) { DoubleQuantileState state(compression); state.add_value(5000); StringVal expected = convert_quantile_state_to_string(ctx, state); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(QuantileStateFunctionsTest, quantile_union) { @@ -105,7 +105,7 @@ TEST_F(QuantileStateFunctionsTest, quantile_union) { StringVal result = QuantileStateFunctions::quantile_state_serialize(ctx, dst); StringVal expected = convert_quantile_state_to_string(ctx, expect); - ASSERT_EQ(result, expected); + EXPECT_EQ(result, expected); } TEST_F(QuantileStateFunctionsTest, quantile_percent) { @@ -124,12 +124,7 @@ TEST_F(QuantileStateFunctionsTest, quantile_percent) { StringVal input = convert_quantile_state_to_string(ctx, state); DoubleVal result = QuantileStateFunctions::quantile_percent(ctx, input); DoubleVal expected(3); - ASSERT_EQ(result, expected); + EXPECT_EQ(result, expected); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/runtime_filter_test.cpp b/be/test/exprs/runtime_filter_test.cpp index c96841a2c9..a3e8f6b672 100644 --- a/be/test/exprs/runtime_filter_test.cpp +++ b/be/test/exprs/runtime_filter_test.cpp @@ -150,19 +150,19 @@ TEST_F(RuntimeFilterTest, runtime_filter_basic_test) { // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_TRUE(!expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_TRUE(!expr_context_list.empty()); // test data in for (TupleRow& row : *tuple_rows) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } // test not exist data for (TupleRow& row : *not_exist_data) { for (ExprContext* ctx : expr_context_list) { - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -170,7 +170,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_basic_test) { for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -194,23 +194,23 @@ TEST_F(RuntimeFilterTest, runtime_filter_merge_in_filter_test) { insert(runtime_filter2, build_expr_ctx, rows2); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_TRUE(!expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_TRUE(!expr_context_list.empty()); // test data in for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -218,7 +218,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_merge_in_filter_test) { for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -242,23 +242,23 @@ TEST_F(RuntimeFilterTest, runtime_filter_ignore_in_filter_test) { insert(runtime_filter2, build_expr_ctx, rows2); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(runtime_filter->is_ignored()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(runtime_filter->is_ignored()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_TRUE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_TRUE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -266,7 +266,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_ignore_in_filter_test) { for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -284,32 +284,32 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_in_test) { IRuntimeFilter* runtime_filter = create_runtime_filter( TRuntimeFilterType::IN_OR_BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter, build_expr_ctx, rows1); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); IRuntimeFilter* runtime_filter2 = create_runtime_filter(TRuntimeFilterType::IN, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter2, build_expr_ctx, rows2); - ASSERT_FALSE(runtime_filter2->is_bloomfilter()); + EXPECT_FALSE(runtime_filter2->is_bloomfilter()); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(runtime_filter->is_ignored()); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(runtime_filter->is_ignored()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_FALSE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_FALSE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -317,7 +317,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_in_test) { for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -335,32 +335,32 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_in_upgrade_ IRuntimeFilter* runtime_filter = create_runtime_filter( TRuntimeFilterType::IN_OR_BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter, build_expr_ctx, rows1); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); IRuntimeFilter* runtime_filter2 = create_runtime_filter(TRuntimeFilterType::IN, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter2, build_expr_ctx, rows2); - ASSERT_FALSE(runtime_filter2->is_bloomfilter()); + EXPECT_FALSE(runtime_filter2->is_bloomfilter()); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(runtime_filter->is_ignored()); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(runtime_filter->is_ignored()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_FALSE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_FALSE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -368,7 +368,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_in_upgrade_ for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -386,32 +386,32 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_bloom_filte IRuntimeFilter* runtime_filter = create_runtime_filter( TRuntimeFilterType::IN_OR_BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter, build_expr_ctx, rows1); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); IRuntimeFilter* runtime_filter2 = create_runtime_filter(TRuntimeFilterType::BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter2, build_expr_ctx, rows2); - ASSERT_TRUE(runtime_filter2->is_bloomfilter()); + EXPECT_TRUE(runtime_filter2->is_bloomfilter()); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(runtime_filter->is_ignored()); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(runtime_filter->is_ignored()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_FALSE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_FALSE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -419,7 +419,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_in_merge_bloom_filte for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -437,34 +437,34 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_bloom_filter_merge_i IRuntimeFilter* runtime_filter = create_runtime_filter( TRuntimeFilterType::IN_OR_BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter, build_expr_ctx, rows1); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); runtime_filter->change_to_bloom_filter(); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); IRuntimeFilter* runtime_filter2 = create_runtime_filter(TRuntimeFilterType::IN, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter2, build_expr_ctx, rows2); - ASSERT_FALSE(runtime_filter2->is_bloomfilter()); + EXPECT_FALSE(runtime_filter2->is_bloomfilter()); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(runtime_filter->is_ignored()); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(runtime_filter->is_ignored()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_FALSE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_FALSE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -472,7 +472,7 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_bloom_filter_merge_i for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } @@ -490,34 +490,34 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_bloom_filter_merge_b IRuntimeFilter* runtime_filter = create_runtime_filter( TRuntimeFilterType::IN_OR_BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter, build_expr_ctx, rows1); - ASSERT_FALSE(runtime_filter->is_bloomfilter()); + EXPECT_FALSE(runtime_filter->is_bloomfilter()); runtime_filter->change_to_bloom_filter(); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); IRuntimeFilter* runtime_filter2 = create_runtime_filter(TRuntimeFilterType::BLOOM, &options, _runtime_stat.get(), &_obj_pool); insert(runtime_filter2, build_expr_ctx, rows2); - ASSERT_TRUE(runtime_filter2->is_bloomfilter()); + EXPECT_TRUE(runtime_filter2->is_bloomfilter()); Status status = runtime_filter->merge_from(runtime_filter2->get_wrapper()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(runtime_filter->is_ignored()); - ASSERT_TRUE(runtime_filter->is_bloomfilter()); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(runtime_filter->is_ignored()); + EXPECT_TRUE(runtime_filter->is_bloomfilter()); // get expr context from filter std::list expr_context_list; - ASSERT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); - ASSERT_FALSE(expr_context_list.empty()); + EXPECT_TRUE(runtime_filter->get_push_expr_ctxs(&expr_context_list, prob_expr_ctx).ok()); + EXPECT_FALSE(expr_context_list.empty()); for (TupleRow& row : *rows1) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } for (TupleRow& row : *rows2) { for (ExprContext* ctx : expr_context_list) { - ASSERT_TRUE(ctx->get_boolean_val(&row).val); + EXPECT_TRUE(ctx->get_boolean_val(&row).val); } } @@ -525,13 +525,8 @@ TEST_F(RuntimeFilterTest, runtime_filter_in_or_bloom_filter_bloom_filter_merge_b for (ExprContext* ctx : expr_context_list) { TupleRow row; row._tuples[0] = nullptr; - ASSERT_FALSE(ctx->get_boolean_val(&row).val); + EXPECT_FALSE(ctx->get_boolean_val(&row).val); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/exprs/string_functions_test.cpp b/be/test/exprs/string_functions_test.cpp index acae0e871e..ec762d4f45 100644 --- a/be/test/exprs/string_functions_test.cpp +++ b/be/test/exprs/string_functions_test.cpp @@ -24,8 +24,8 @@ #include #include "exprs/anyval_util.h" -#include "test_util/test_util.h" #include "testutil/function_utils.h" +#include "testutil/test_util.h" #include "util/logging.h" #include "util/simd/vstring_function.h" @@ -52,7 +52,7 @@ TEST_F(StringFunctionsTest, do_money_format_for_bigint_bench) { BigIntVal bigIntVal(9223372036854775807); for (int i = 0; i < LOOP_LESS_OR_MORE(10, 10000000); i++) { StringVal result = StringFunctions::money_format(context, bigIntVal); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } delete context; } @@ -65,7 +65,7 @@ TEST_F(StringFunctionsTest, do_money_format_for_decimalv2_bench) { dv1.to_decimal_val(&decimalV2Val); for (int i = 0; i < LOOP_LESS_OR_MORE(10, 10000000); i++) { StringVal result = StringFunctions::money_format(context, decimalV2Val); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } delete context; } @@ -75,15 +75,15 @@ TEST_F(StringFunctionsTest, money_format_bigint) { StringVal result = StringFunctions::money_format(context, doris_udf::BigIntVal(123456)); StringVal expected = AnyValUtil::from_string(ctx, std::string("123,456.00")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::BigIntVal(-123456)); expected = AnyValUtil::from_string(ctx, std::string("-123,456.00")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::BigIntVal(9223372036854775807)); expected = AnyValUtil::from_string(ctx, std::string("9,223,372,036,854,775,807.00")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); delete context; } @@ -93,13 +93,13 @@ TEST_F(StringFunctionsTest, money_format_large_int) { StringVal result = StringFunctions::money_format(context, doris_udf::LargeIntVal(value)); StringVal expected = AnyValUtil::from_string_temp( context, std::string("170,141,183,460,469,231,731,687,303,715,884,105,727.00")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); value = MIN_INT128; result = StringFunctions::money_format(context, doris_udf::LargeIntVal(value)); expected = AnyValUtil::from_string_temp( context, std::string("-170,141,183,460,469,231,731,687,303,715,884,105,728.00")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); delete context; } @@ -108,23 +108,23 @@ TEST_F(StringFunctionsTest, money_format_double) { StringVal result = StringFunctions::money_format(context, doris_udf::DoubleVal(1234.456)); StringVal expected = AnyValUtil::from_string(ctx, std::string("1,234.46")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::DoubleVal(1234.45)); expected = AnyValUtil::from_string(ctx, std::string("1,234.45")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::DoubleVal(1234.4)); expected = AnyValUtil::from_string(ctx, std::string("1,234.40")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::DoubleVal(1234.454)); expected = AnyValUtil::from_string(ctx, std::string("1,234.45")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); result = StringFunctions::money_format(context, doris_udf::DoubleVal(-36854775807.039)); expected = AnyValUtil::from_string(ctx, std::string("-36,854,775,807.04")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); delete context; } @@ -138,7 +138,7 @@ TEST_F(StringFunctionsTest, money_format_decimal_v2) { StringVal result = StringFunctions::money_format(context, value1); StringVal expected = AnyValUtil::from_string(ctx, std::string("3,333,333,333.22")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); DecimalV2Value dv2(std::string("-740740740.71604938271975308642")); DecimalV2Val value2; @@ -146,44 +146,44 @@ TEST_F(StringFunctionsTest, money_format_decimal_v2) { result = StringFunctions::money_format(context, value2); expected = AnyValUtil::from_string(ctx, std::string("-740,740,740.72")); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); delete context; } TEST_F(StringFunctionsTest, split_part) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("hello")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("hello")), StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 1)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("word")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("word")), StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 2)); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 3)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 1)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string(" word")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string(" word")), StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 2)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("2019年9")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("2019年9")), StringFunctions::split_part(context, StringVal("2019年9月8日"), StringVal("月"), 1)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 1)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("bcd")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("bcd")), StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 2)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("bd")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("bd")), StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 3)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 4)); - ASSERT_EQ( + EXPECT_EQ( AnyValUtil::from_string(ctx, std::string("#123")), StringFunctions::split_part(context, StringVal("abc###123###234"), StringVal("##"), 2)); @@ -196,34 +196,34 @@ TEST_F(StringFunctionsTest, ends_with) { doris_udf::BooleanVal trueRet = doris_udf::BooleanVal(true); doris_udf::BooleanVal nullRet = doris_udf::BooleanVal::null(); - ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal(""), StringVal(""))); + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal(""), StringVal(""))); - ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal(""))); + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal(""))); - ASSERT_EQ(falseRet, StringFunctions::ends_with(context, StringVal(""), StringVal("hello"))); + EXPECT_EQ(falseRet, StringFunctions::ends_with(context, StringVal(""), StringVal("hello"))); - ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal("hello"))); + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal("hello"))); - ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal(" "), StringVal(" "))); + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal(" "), StringVal(" "))); - ASSERT_EQ(falseRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal(" "))); + EXPECT_EQ(falseRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal(" "))); - ASSERT_EQ(falseRet, StringFunctions::ends_with(context, StringVal(" "), StringVal("hello"))); + EXPECT_EQ(falseRet, StringFunctions::ends_with(context, StringVal(" "), StringVal("hello"))); - ASSERT_EQ(falseRet, + EXPECT_EQ(falseRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("hello"))); - ASSERT_EQ(trueRet, + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("doris"))); - ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"), + EXPECT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("hello doris"))); - ASSERT_EQ(nullRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal::null())); + EXPECT_EQ(nullRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal::null())); - ASSERT_EQ(nullRet, StringFunctions::ends_with(context, StringVal::null(), StringVal("hello"))); + EXPECT_EQ(nullRet, StringFunctions::ends_with(context, StringVal::null(), StringVal("hello"))); - ASSERT_EQ(nullRet, StringFunctions::ends_with(context, StringVal::null(), StringVal::null())); + EXPECT_EQ(nullRet, StringFunctions::ends_with(context, StringVal::null(), StringVal::null())); delete context; } @@ -233,37 +233,37 @@ TEST_F(StringFunctionsTest, starts_with) { doris_udf::BooleanVal trueRet = doris_udf::BooleanVal(true); doris_udf::BooleanVal nullRet = doris_udf::BooleanVal::null(); - ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal(""), StringVal(""))); + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal(""), StringVal(""))); - ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal(" "), StringVal(" "))); + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal(" "), StringVal(" "))); - ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal(""))); + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal(""))); - ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(""), StringVal("hello"))); + EXPECT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(""), StringVal("hello"))); - ASSERT_EQ(trueRet, + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal("hello"))); - ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal(" "))); + EXPECT_EQ(falseRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal(" "))); - ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(" "), StringVal("world"))); + EXPECT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(" "), StringVal("world"))); - ASSERT_EQ(trueRet, + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("hello"))); - ASSERT_EQ(falseRet, + EXPECT_EQ(falseRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("world"))); - ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"), + EXPECT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("hello world"))); - ASSERT_EQ(nullRet, + EXPECT_EQ(nullRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal::null())); - ASSERT_EQ(nullRet, + EXPECT_EQ(nullRet, StringFunctions::starts_with(context, StringVal::null(), StringVal("hello world"))); - ASSERT_EQ(nullRet, StringFunctions::starts_with(context, StringVal::null(), StringVal::null())); + EXPECT_EQ(nullRet, StringFunctions::starts_with(context, StringVal::null(), StringVal::null())); delete context; } @@ -272,26 +272,26 @@ TEST_F(StringFunctionsTest, null_or_empty) { doris_udf::BooleanVal falseRet = doris_udf::BooleanVal(false); doris_udf::BooleanVal trueRet = doris_udf::BooleanVal(true); - ASSERT_EQ(trueRet, StringFunctions::null_or_empty(context, StringVal(""))); + EXPECT_EQ(trueRet, StringFunctions::null_or_empty(context, StringVal(""))); - ASSERT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal(" "))); + EXPECT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal(" "))); - ASSERT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("hello"))); + EXPECT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("hello"))); - ASSERT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("doris"))); + EXPECT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("doris"))); - ASSERT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("111"))); + EXPECT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("111"))); - ASSERT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("."))); + EXPECT_EQ(falseRet, StringFunctions::null_or_empty(context, StringVal("."))); - ASSERT_EQ(trueRet, StringFunctions::null_or_empty(context, StringVal::null())); + EXPECT_EQ(trueRet, StringFunctions::null_or_empty(context, StringVal::null())); delete context; } TEST_F(StringFunctionsTest, left) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::left(context, StringVal(""), 10)); delete context; } @@ -299,36 +299,36 @@ TEST_F(StringFunctionsTest, left) { TEST_F(StringFunctionsTest, substring) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::substring(context, StringVal("hello word"), 0, 5)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("hello")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("hello")), StringFunctions::substring(context, StringVal("hello word"), 1, 5)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("word")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("word")), StringFunctions::substring(context, StringVal("hello word"), 7, 4)); - ASSERT_EQ(StringVal::null(), StringFunctions::substring(context, StringVal::null(), 1, 0)); + EXPECT_EQ(StringVal::null(), StringFunctions::substring(context, StringVal::null(), 1, 0)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::substring(context, StringVal("hello word"), 1, 0)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string(" word")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string(" word")), StringFunctions::substring(context, StringVal("hello word"), -5, 5)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("hello word 你")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("hello word 你")), StringFunctions::substring(context, StringVal("hello word 你好"), 1, 12)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("好")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("好")), StringFunctions::substring(context, StringVal("hello word 你好"), 13, 1)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::substring(context, StringVal("hello word 你好"), 1, 0)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("rd 你好")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("rd 你好")), StringFunctions::substring(context, StringVal("hello word 你好"), -5, 5)); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("h")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("h")), StringFunctions::substring(context, StringVal("hello word 你好"), 1, 1)); delete context; } @@ -337,311 +337,311 @@ TEST_F(StringFunctionsTest, reverse) { FunctionUtils fu; doris_udf::FunctionContext* context = fu.get_fn_ctx(); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("olleh")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("olleh")), StringFunctions::reverse(context, StringVal("hello"))); - ASSERT_EQ(StringVal::null(), StringFunctions::reverse(context, StringVal::null())); + EXPECT_EQ(StringVal::null(), StringFunctions::reverse(context, StringVal::null())); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("")), StringFunctions::reverse(context, StringVal(""))); - ASSERT_EQ(AnyValUtil::from_string(ctx, std::string("好你olleh")), + EXPECT_EQ(AnyValUtil::from_string(ctx, std::string("好你olleh")), StringFunctions::reverse(context, StringVal("hello你好"))); } TEST_F(StringFunctionsTest, length) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(IntVal(5), StringFunctions::length(context, StringVal("hello"))); - ASSERT_EQ(IntVal(5), StringFunctions::char_utf8_length(context, StringVal("hello"))); - ASSERT_EQ(IntVal::null(), StringFunctions::length(context, StringVal::null())); - ASSERT_EQ(IntVal::null(), StringFunctions::char_utf8_length(context, StringVal::null())); + EXPECT_EQ(IntVal(5), StringFunctions::length(context, StringVal("hello"))); + EXPECT_EQ(IntVal(5), StringFunctions::char_utf8_length(context, StringVal("hello"))); + EXPECT_EQ(IntVal::null(), StringFunctions::length(context, StringVal::null())); + EXPECT_EQ(IntVal::null(), StringFunctions::char_utf8_length(context, StringVal::null())); - ASSERT_EQ(IntVal(0), StringFunctions::length(context, StringVal(""))); - ASSERT_EQ(IntVal(0), StringFunctions::char_utf8_length(context, StringVal(""))); + EXPECT_EQ(IntVal(0), StringFunctions::length(context, StringVal(""))); + EXPECT_EQ(IntVal(0), StringFunctions::char_utf8_length(context, StringVal(""))); - ASSERT_EQ(IntVal(11), StringFunctions::length(context, StringVal("hello你好"))); + EXPECT_EQ(IntVal(11), StringFunctions::length(context, StringVal("hello你好"))); - ASSERT_EQ(IntVal(7), StringFunctions::char_utf8_length(context, StringVal("hello你好"))); + EXPECT_EQ(IntVal(7), StringFunctions::char_utf8_length(context, StringVal("hello你好"))); delete context; } TEST_F(StringFunctionsTest, append_trailing_char_if_absent) { - ASSERT_EQ(StringVal("ac"), + EXPECT_EQ(StringVal("ac"), StringFunctions::append_trailing_char_if_absent(ctx, StringVal("a"), StringVal("c"))); - ASSERT_EQ(StringVal("c"), + EXPECT_EQ(StringVal("c"), StringFunctions::append_trailing_char_if_absent(ctx, StringVal("c"), StringVal("c"))); - ASSERT_EQ(StringVal("123c"), StringFunctions::append_trailing_char_if_absent( + EXPECT_EQ(StringVal("123c"), StringFunctions::append_trailing_char_if_absent( ctx, StringVal("123c"), StringVal("c"))); - ASSERT_EQ(StringVal("c"), + EXPECT_EQ(StringVal("c"), StringFunctions::append_trailing_char_if_absent(ctx, StringVal(""), StringVal("c"))); - ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( + EXPECT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( ctx, StringVal::null(), StringVal("c"))); - ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( + EXPECT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( ctx, StringVal("a"), StringVal::null())); - ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( + EXPECT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent( ctx, StringVal("a"), StringVal("abc"))); } TEST_F(StringFunctionsTest, instr) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(IntVal(4), StringFunctions::instr(context, StringVal("foobarbar"), StringVal("bar"))); - ASSERT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("foobar"), StringVal("xbar"))); - ASSERT_EQ(IntVal(2), StringFunctions::instr(context, StringVal("123456234"), StringVal("234"))); - ASSERT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("123456"), StringVal("567"))); - ASSERT_EQ(IntVal(2), StringFunctions::instr(context, StringVal("1.234"), StringVal(".234"))); - ASSERT_EQ(IntVal(1), StringFunctions::instr(context, StringVal("1.234"), StringVal(""))); - ASSERT_EQ(IntVal(0), StringFunctions::instr(context, StringVal(""), StringVal("123"))); - ASSERT_EQ(IntVal(1), StringFunctions::instr(context, StringVal(""), StringVal(""))); - ASSERT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好世界"), StringVal("世界"))); - ASSERT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("你好世界"), StringVal("您好"))); - ASSERT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好abc"), StringVal("a"))); - ASSERT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好abc"), StringVal("abc"))); - ASSERT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal::null(), StringVal("2"))); - ASSERT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal(""), StringVal::null())); - ASSERT_EQ(IntVal::null(), + EXPECT_EQ(IntVal(4), StringFunctions::instr(context, StringVal("foobarbar"), StringVal("bar"))); + EXPECT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("foobar"), StringVal("xbar"))); + EXPECT_EQ(IntVal(2), StringFunctions::instr(context, StringVal("123456234"), StringVal("234"))); + EXPECT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("123456"), StringVal("567"))); + EXPECT_EQ(IntVal(2), StringFunctions::instr(context, StringVal("1.234"), StringVal(".234"))); + EXPECT_EQ(IntVal(1), StringFunctions::instr(context, StringVal("1.234"), StringVal(""))); + EXPECT_EQ(IntVal(0), StringFunctions::instr(context, StringVal(""), StringVal("123"))); + EXPECT_EQ(IntVal(1), StringFunctions::instr(context, StringVal(""), StringVal(""))); + EXPECT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好世界"), StringVal("世界"))); + EXPECT_EQ(IntVal(0), StringFunctions::instr(context, StringVal("你好世界"), StringVal("您好"))); + EXPECT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好abc"), StringVal("a"))); + EXPECT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好abc"), StringVal("abc"))); + EXPECT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal::null(), StringVal("2"))); + EXPECT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal(""), StringVal::null())); + EXPECT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal::null(), StringVal::null())); delete context; } TEST_F(StringFunctionsTest, locate) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(IntVal(4), + EXPECT_EQ(IntVal(4), StringFunctions::locate(context, StringVal("bar"), StringVal("foobarbar"))); - ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("xbar"), StringVal("foobar"))); - ASSERT_EQ(IntVal(2), + EXPECT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("xbar"), StringVal("foobar"))); + EXPECT_EQ(IntVal(2), StringFunctions::locate(context, StringVal("234"), StringVal("123456234"))); - ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("567"), StringVal("123456"))); - ASSERT_EQ(IntVal(2), StringFunctions::locate(context, StringVal(".234"), StringVal("1.234"))); - ASSERT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal("1.234"))); - ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("123"), StringVal(""))); - ASSERT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal(""))); - ASSERT_EQ(IntVal(3), + EXPECT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("567"), StringVal("123456"))); + EXPECT_EQ(IntVal(2), StringFunctions::locate(context, StringVal(".234"), StringVal("1.234"))); + EXPECT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal("1.234"))); + EXPECT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("123"), StringVal(""))); + EXPECT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal(""))); + EXPECT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("世界"), StringVal("你好世界"))); - ASSERT_EQ(IntVal(0), + EXPECT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("您好"), StringVal("你好世界"))); - ASSERT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("a"), StringVal("你好abc"))); - ASSERT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("abc"), StringVal("你好abc"))); - ASSERT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal::null(), StringVal("2"))); - ASSERT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal(""), StringVal::null())); - ASSERT_EQ(IntVal::null(), + EXPECT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("a"), StringVal("你好abc"))); + EXPECT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("abc"), StringVal("你好abc"))); + EXPECT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal::null(), StringVal("2"))); + EXPECT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal(""), StringVal::null())); + EXPECT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal::null(), StringVal::null())); delete context; } TEST_F(StringFunctionsTest, locate_pos) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("bar"), + EXPECT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("bar"), StringVal("foobarbar"), IntVal(5))); - ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("xbar"), + EXPECT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("xbar"), StringVal("foobar"), IntVal(1))); - ASSERT_EQ(IntVal(2), + EXPECT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal(""), StringVal("foobar"), IntVal(2))); - ASSERT_EQ(IntVal(0), + EXPECT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("foobar"), StringVal(""), IntVal(1))); - ASSERT_EQ(IntVal(0), + EXPECT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal(""), StringVal(""), IntVal(2))); - ASSERT_EQ(IntVal(0), + EXPECT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("AAAAAA"), IntVal(0))); - ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), + EXPECT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(0))); - ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), + EXPECT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(1))); - ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), + EXPECT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(2))); - ASSERT_EQ(IntVal(5), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), + EXPECT_EQ(IntVal(5), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(3))); - ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("BaR"), + EXPECT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("BaR"), StringVal("foobarBaR"), IntVal(5))); - ASSERT_EQ(IntVal::null(), + EXPECT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal("2"), IntVal(1))); - ASSERT_EQ(IntVal::null(), + EXPECT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal(""), StringVal::null(), IntVal(4))); - ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), + EXPECT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal::null(), IntVal(4))); - ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), + EXPECT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal::null(), IntVal(-1))); delete context; } TEST_F(StringFunctionsTest, lpad) { - ASSERT_EQ(StringVal("???hi"), + EXPECT_EQ(StringVal("???hi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("?"))); - ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), + EXPECT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), StringFunctions::lpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20), StringVal(""))); - ASSERT_EQ(StringVal("h"), + EXPECT_EQ(StringVal("h"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal("你"), + EXPECT_EQ(StringVal("你"), StringFunctions::lpad(ctx, StringVal("你好"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal("你"), + EXPECT_EQ(StringVal("你"), StringFunctions::lpad(ctx, StringVal("你"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal(""), + EXPECT_EQ(StringVal(""), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(0), StringVal("?"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?"))); - ASSERT_EQ(StringVal("h"), + EXPECT_EQ(StringVal("h"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal(""))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal(""))); - ASSERT_EQ(StringVal("abahi"), + EXPECT_EQ(StringVal("abahi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab"))); - ASSERT_EQ(StringVal("ababhi"), + EXPECT_EQ(StringVal("ababhi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab"))); - ASSERT_EQ(StringVal("呵呵呵hi"), + EXPECT_EQ(StringVal("呵呵呵hi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵"))); - ASSERT_EQ(StringVal("hih呵呵"), + EXPECT_EQ(StringVal("hih呵呵"), StringFunctions::lpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi"))); } TEST_F(StringFunctionsTest, rpad) { - ASSERT_EQ(StringVal("hi???"), + EXPECT_EQ(StringVal("hi???"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("?"))); - ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), + EXPECT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), StringFunctions::rpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20), StringVal(""))); - ASSERT_EQ(StringVal("h"), + EXPECT_EQ(StringVal("h"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal("你"), + EXPECT_EQ(StringVal("你"), StringFunctions::rpad(ctx, StringVal("你好"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal("你"), + EXPECT_EQ(StringVal("你"), StringFunctions::rpad(ctx, StringVal("你"), IntVal(1), StringVal("?"))); - ASSERT_EQ(StringVal(""), + EXPECT_EQ(StringVal(""), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(0), StringVal("?"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?"))); - ASSERT_EQ(StringVal("h"), + EXPECT_EQ(StringVal("h"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal(""))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal(""))); - ASSERT_EQ(StringVal("hiaba"), + EXPECT_EQ(StringVal("hiaba"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab"))); - ASSERT_EQ(StringVal("hiabab"), + EXPECT_EQ(StringVal("hiabab"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab"))); - ASSERT_EQ(StringVal("hi呵呵呵"), + EXPECT_EQ(StringVal("hi呵呵呵"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵"))); - ASSERT_EQ(StringVal("呵呵hih"), + EXPECT_EQ(StringVal("呵呵hih"), StringFunctions::rpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi"))); } TEST_F(StringFunctionsTest, replace) { //exist substring - ASSERT_EQ(StringVal("http://www.baidu.com:8080"), + EXPECT_EQ(StringVal("http://www.baidu.com:8080"), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal("9090"), StringVal("8080"))); //not exist substring - ASSERT_EQ(StringVal("http://www.baidu.com:9090"), + EXPECT_EQ(StringVal("http://www.baidu.com:9090"), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal("9070"), StringVal("8080"))); //old substring is empty - ASSERT_EQ(StringVal("http://www.baidu.com:9090"), + EXPECT_EQ(StringVal("http://www.baidu.com:9090"), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal(""), StringVal("8080"))); //new substring is empty - ASSERT_EQ(StringVal("http://www.baidu.com:"), + EXPECT_EQ(StringVal("http://www.baidu.com:"), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal("9090"), StringVal(""))); //origin string is null - ASSERT_EQ(StringVal::null(), StringFunctions::replace(ctx, StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::replace(ctx, StringVal::null(), StringVal("hello"), StringVal("8080"))); //old substring is null - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal::null(), StringVal("8080"))); //new substring is null - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal("hello"), StringVal::null())); //substring contains Chinese character - ASSERT_EQ(StringVal("http://华夏zhongguo:9090"), + EXPECT_EQ(StringVal("http://华夏zhongguo:9090"), StringFunctions::replace(ctx, StringVal("http://中国hello:9090"), StringVal("中国hello"), StringVal("华夏zhongguo"))); //old substring is at the beginning of string - ASSERT_EQ(StringVal("ftp://www.baidu.com:9090"), + EXPECT_EQ(StringVal("ftp://www.baidu.com:9090"), StringFunctions::replace(ctx, StringVal("http://www.baidu.com:9090"), StringVal("http"), StringVal("ftp"))); } TEST_F(StringFunctionsTest, parse_url) { - ASSERT_EQ(StringVal("facebook.com"), + EXPECT_EQ(StringVal("facebook.com"), StringFunctions::parse_url(ctx, StringVal("http://facebook.com/path/p1.php?query=1"), StringVal("AUTHORITY"))); - ASSERT_EQ(StringVal("facebook.com"), + EXPECT_EQ(StringVal("facebook.com"), StringFunctions::parse_url(ctx, StringVal("http://facebook.com/path/p1.php?query=1"), StringVal("authority"))); - ASSERT_EQ(StringVal("/a/b/c.php"), + EXPECT_EQ(StringVal("/a/b/c.php"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090/a/b/c.php"), StringVal("FILE"))); - ASSERT_EQ(StringVal("/a/b/c.php"), + EXPECT_EQ(StringVal("/a/b/c.php"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090/a/b/c.php"), StringVal("file"))); - ASSERT_EQ(StringVal("/a/b/c.php"), + EXPECT_EQ(StringVal("/a/b/c.php"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090/a/b/c.php"), StringVal("PATH"))); - ASSERT_EQ(StringVal("/a/b/c.php"), + EXPECT_EQ(StringVal("/a/b/c.php"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090/a/b/c.php"), StringVal("path"))); - ASSERT_EQ(StringVal("www.baidu.com"), + EXPECT_EQ(StringVal("www.baidu.com"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090"), StringVal("HOST"))); - ASSERT_EQ(StringVal("www.baidu.com"), + EXPECT_EQ(StringVal("www.baidu.com"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090"), StringVal("host"))); - ASSERT_EQ(StringVal("http"), + EXPECT_EQ(StringVal("http"), StringFunctions::parse_url(ctx, StringVal("http://facebook.com/path/p1.php?query=1"), StringVal("PROTOCOL"))); - ASSERT_EQ(StringVal("http"), + EXPECT_EQ(StringVal("http"), StringFunctions::parse_url(ctx, StringVal("http://facebook.com/path/p1.php?query=1"), StringVal("protocol"))); - ASSERT_EQ(StringVal("a=b"), + EXPECT_EQ(StringVal("a=b"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("QUERY"))); - ASSERT_EQ(StringVal("a=b"), + EXPECT_EQ(StringVal("a=b"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("query"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("REF"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("ref"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("USERINFO"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("userinfo"))); - ASSERT_EQ(StringVal("9090"), + EXPECT_EQ(StringVal("9090"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("PORT"))); - ASSERT_EQ(StringVal("9090"), + EXPECT_EQ(StringVal("9090"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090/a/b/c?a=b"), StringVal("PORT"))); - ASSERT_EQ(StringVal::null(), + EXPECT_EQ(StringVal::null(), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com?a=b"), StringVal("PORT"))); - ASSERT_EQ(StringVal("9090"), + EXPECT_EQ(StringVal("9090"), StringFunctions::parse_url(ctx, StringVal("http://www.baidu.com:9090?a=b"), StringVal("port"))); } @@ -649,124 +649,114 @@ TEST_F(StringFunctionsTest, parse_url) { TEST_F(StringFunctionsTest, bit_length) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(IntVal(40), StringFunctions::bit_length(context, StringVal("hello"))); + EXPECT_EQ(IntVal(40), StringFunctions::bit_length(context, StringVal("hello"))); - ASSERT_EQ(IntVal::null(), StringFunctions::bit_length(context, StringVal::null())); + EXPECT_EQ(IntVal::null(), StringFunctions::bit_length(context, StringVal::null())); - ASSERT_EQ(IntVal(0), StringFunctions::bit_length(context, StringVal(""))); + EXPECT_EQ(IntVal(0), StringFunctions::bit_length(context, StringVal(""))); - ASSERT_EQ(IntVal(88), StringFunctions::bit_length(context, StringVal("hello你好"))); + EXPECT_EQ(IntVal(88), StringFunctions::bit_length(context, StringVal("hello你好"))); delete context; } TEST_F(StringFunctionsTest, lower) { - ASSERT_EQ(StringVal("hello"), StringFunctions::lower(ctx, StringVal("hello"))); - ASSERT_EQ(StringVal("hello"), StringFunctions::lower(ctx, StringVal("HELLO"))); - ASSERT_EQ(StringVal("hello123"), StringFunctions::lower(ctx, StringVal("HELLO123"))); - ASSERT_EQ(StringVal("hello, 123"), StringFunctions::lower(ctx, StringVal("HELLO, 123"))); - ASSERT_EQ(StringVal::null(), StringFunctions::lower(ctx, StringVal::null())); - ASSERT_EQ(StringVal(""), StringFunctions::lower(ctx, StringVal(""))); + EXPECT_EQ(StringVal("hello"), StringFunctions::lower(ctx, StringVal("hello"))); + EXPECT_EQ(StringVal("hello"), StringFunctions::lower(ctx, StringVal("HELLO"))); + EXPECT_EQ(StringVal("hello123"), StringFunctions::lower(ctx, StringVal("HELLO123"))); + EXPECT_EQ(StringVal("hello, 123"), StringFunctions::lower(ctx, StringVal("HELLO, 123"))); + EXPECT_EQ(StringVal::null(), StringFunctions::lower(ctx, StringVal::null())); + EXPECT_EQ(StringVal(""), StringFunctions::lower(ctx, StringVal(""))); } TEST_F(StringFunctionsTest, upper) { // function test - ASSERT_EQ(StringVal("HELLO"), StringFunctions::upper(ctx, StringVal("HELLO"))); - ASSERT_EQ(StringVal("HELLO"), StringFunctions::upper(ctx, StringVal("hello"))); - ASSERT_EQ(StringVal("HELLO123"), StringFunctions::upper(ctx, StringVal("hello123"))); - ASSERT_EQ(StringVal("HELLO, 123"), StringFunctions::upper(ctx, StringVal("hello, 123"))); - ASSERT_EQ(StringVal::null(), StringFunctions::upper(ctx, StringVal::null())); - ASSERT_EQ(StringVal(""), StringFunctions::upper(ctx, StringVal(""))); + EXPECT_EQ(StringVal("HELLO"), StringFunctions::upper(ctx, StringVal("HELLO"))); + EXPECT_EQ(StringVal("HELLO"), StringFunctions::upper(ctx, StringVal("hello"))); + EXPECT_EQ(StringVal("HELLO123"), StringFunctions::upper(ctx, StringVal("hello123"))); + EXPECT_EQ(StringVal("HELLO, 123"), StringFunctions::upper(ctx, StringVal("hello, 123"))); + EXPECT_EQ(StringVal::null(), StringFunctions::upper(ctx, StringVal::null())); + EXPECT_EQ(StringVal(""), StringFunctions::upper(ctx, StringVal(""))); } TEST_F(StringFunctionsTest, ltrim) { // no blank StringVal src("hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); StringVal res = simd::VStringFunctions::ltrim(src); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // empty string StringVal src1(""); res = simd::VStringFunctions::ltrim(src1); - ASSERT_EQ(src1, res); + EXPECT_EQ(src1, res); // null string StringVal src2(StringVal::null()); res = simd::VStringFunctions::ltrim(src2); - ASSERT_EQ(src2, res); + EXPECT_EQ(src2, res); // less than 16 blanks StringVal src3(" hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); res = simd::VStringFunctions::ltrim(src3); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // more than 16 blanks StringVal src4(" hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); res = simd::VStringFunctions::ltrim(src4); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // all are blanks, less than 16 blanks StringVal src5(" "); res = simd::VStringFunctions::ltrim(src5); - ASSERT_EQ(StringVal(""), res); + EXPECT_EQ(StringVal(""), res); // all are blanks, more than 16 blanks StringVal src6(" "); res = simd::VStringFunctions::ltrim(src6); - ASSERT_EQ(StringVal(""), res); + EXPECT_EQ(StringVal(""), res); // src less than 16 length StringVal src7(" 12345678910"); res = simd::VStringFunctions::ltrim(src7); - ASSERT_EQ(StringVal("12345678910"), res); + EXPECT_EQ(StringVal("12345678910"), res); } TEST_F(StringFunctionsTest, rtrim) { // no blank StringVal src("hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); StringVal res = simd::VStringFunctions::rtrim(src); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // empty string StringVal src1(""); res = simd::VStringFunctions::rtrim(src1); - ASSERT_EQ(src1, res); + EXPECT_EQ(src1, res); // null string StringVal src2(StringVal::null()); res = simd::VStringFunctions::rtrim(src2); - ASSERT_EQ(src2, res); + EXPECT_EQ(src2, res); // less than 16 blanks StringVal src3("hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "); res = simd::VStringFunctions::rtrim(src3); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // more than 16 blanks StringVal src4("hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "); res = simd::VStringFunctions::rtrim(src4); - ASSERT_EQ(src, res); + EXPECT_EQ(src, res); // all are blanks, less than 16 blanks StringVal src5(" "); res = simd::VStringFunctions::rtrim(src5); - ASSERT_EQ(StringVal(""), res); + EXPECT_EQ(StringVal(""), res); // all are blanks, more than 16 blanks StringVal src6(" "); res = simd::VStringFunctions::rtrim(src6); - ASSERT_EQ(StringVal(""), res); + EXPECT_EQ(StringVal(""), res); // src less than 16 length StringVal src7("12345678910 "); res = simd::VStringFunctions::rtrim(src7); - ASSERT_EQ(StringVal("12345678910"), res); + EXPECT_EQ(StringVal("12345678910"), res); } TEST_F(StringFunctionsTest, is_ascii) { - ASSERT_EQ(true, simd::VStringFunctions::is_ascii(StringVal("hello123"))); - ASSERT_EQ(true, simd::VStringFunctions::is_ascii( + EXPECT_EQ(true, simd::VStringFunctions::is_ascii(StringVal("hello123"))); + EXPECT_EQ(true, simd::VStringFunctions::is_ascii( StringVal("hello123fwrewerwerwerwrsfqrwerwefwfwrwfsfwe"))); - ASSERT_EQ(false, simd::VStringFunctions::is_ascii(StringVal("运维组123"))); - ASSERT_EQ(false, simd::VStringFunctions::is_ascii( + EXPECT_EQ(false, simd::VStringFunctions::is_ascii(StringVal("运维组123"))); + EXPECT_EQ(false, simd::VStringFunctions::is_ascii( StringVal("hello123运维组fwrewerwerwerwrsfqrwerwefwfwrwfsfwe"))); - ASSERT_EQ(true, simd::VStringFunctions::is_ascii(StringVal::null())); - ASSERT_EQ(true, simd::VStringFunctions::is_ascii(StringVal(""))); + EXPECT_EQ(true, simd::VStringFunctions::is_ascii(StringVal::null())); + EXPECT_EQ(true, simd::VStringFunctions::is_ascii(StringVal(""))); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/timestamp_functions_test.cpp b/be/test/exprs/timestamp_functions_test.cpp index 4662727e6c..b338830a68 100644 --- a/be/test/exprs/timestamp_functions_test.cpp +++ b/be/test/exprs/timestamp_functions_test.cpp @@ -69,21 +69,21 @@ TEST_F(TimestampFunctionsTest, day_of_week_test) { tv.packed_time = 1830650338932162560L; tv.type = TIME_DATETIME; - ASSERT_EQ(7, TimestampFunctions::day_of_week(context, tv).val); + EXPECT_EQ(7, TimestampFunctions::day_of_week(context, tv).val); // 2020-00-01 00:00:00 DateTimeValue dtv2(20200001000000); dtv2.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(true, TimestampFunctions::day_of_week(context, tv2).is_null); + EXPECT_EQ(true, TimestampFunctions::day_of_week(context, tv2).is_null); // 2020-01-00 00:00:00 DateTimeValue dtv3(20200100000000); dtv3.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(true, TimestampFunctions::day_of_week(context, tv3).is_null); + EXPECT_EQ(true, TimestampFunctions::day_of_week(context, tv3).is_null); delete context; } @@ -96,21 +96,21 @@ TEST_F(TimestampFunctionsTest, week_day_test) { tv.packed_time = 1830650338932162560L; tv.type = TIME_DATETIME; - ASSERT_EQ(5, TimestampFunctions::week_day(context, tv).val); + EXPECT_EQ(5, TimestampFunctions::week_day(context, tv).val); // 2020-00-01 00:00:00 DateTimeValue dtv2(20200001000000); dtv2.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(true, TimestampFunctions::week_day(context, tv2).is_null); + EXPECT_EQ(true, TimestampFunctions::week_day(context, tv2).is_null); // 2020-01-00 00:00:00 DateTimeValue dtv3(20200100000000); dtv3.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(true, TimestampFunctions::week_day(context, tv3).is_null); + EXPECT_EQ(true, TimestampFunctions::week_day(context, tv3).is_null); delete context; } @@ -123,24 +123,24 @@ TEST_F(TimestampFunctionsTest, day_of_month_test) { dtv1.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(false, TimestampFunctions::day_of_month(context, tv1).is_null); - ASSERT_EQ(1, TimestampFunctions::day_of_month(context, tv1).val); + EXPECT_EQ(false, TimestampFunctions::day_of_month(context, tv1).is_null); + EXPECT_EQ(1, TimestampFunctions::day_of_month(context, tv1).val); // 2020-01-00 00:00:00 DateTimeValue dtv2(20200100000000); dtv2.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(false, TimestampFunctions::day_of_month(context, tv2).is_null); - ASSERT_EQ(0, TimestampFunctions::day_of_month(context, tv2).val); + EXPECT_EQ(false, TimestampFunctions::day_of_month(context, tv2).is_null); + EXPECT_EQ(0, TimestampFunctions::day_of_month(context, tv2).val); // 2020-02-29 00:00:00 DateTimeValue dtv3(20200229000000); dtv3.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(false, TimestampFunctions::day_of_month(context, tv3).is_null); - ASSERT_EQ(29, TimestampFunctions::day_of_month(context, tv3).val); + EXPECT_EQ(false, TimestampFunctions::day_of_month(context, tv3).is_null); + EXPECT_EQ(29, TimestampFunctions::day_of_month(context, tv3).val); delete context; } @@ -153,22 +153,22 @@ TEST_F(TimestampFunctionsTest, day_of_year_test) { dtv1.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(true, TimestampFunctions::day_of_year(context, tv1).is_null); + EXPECT_EQ(true, TimestampFunctions::day_of_year(context, tv1).is_null); // 2020-01-00 00:00:00 DateTimeValue dtv2(20200100000000); dtv2.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(true, TimestampFunctions::day_of_year(context, tv2).is_null); + EXPECT_EQ(true, TimestampFunctions::day_of_year(context, tv2).is_null); // 2020-02-29 00:00:00 DateTimeValue dtv3(20200229000000); dtv3.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(false, TimestampFunctions::day_of_year(context, tv3).is_null); - ASSERT_EQ(60, TimestampFunctions::day_of_year(context, tv3).val); + EXPECT_EQ(false, TimestampFunctions::day_of_year(context, tv3).is_null); + EXPECT_EQ(60, TimestampFunctions::day_of_year(context, tv3).val); delete context; } @@ -181,22 +181,22 @@ TEST_F(TimestampFunctionsTest, week_of_year_test) { dtv1.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(true, TimestampFunctions::week_of_year(context, tv1).is_null); + EXPECT_EQ(true, TimestampFunctions::week_of_year(context, tv1).is_null); // 2020-01-00 00:00:00 DateTimeValue dtv2(20200100000000); dtv2.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(true, TimestampFunctions::week_of_year(context, tv2).is_null); + EXPECT_EQ(true, TimestampFunctions::week_of_year(context, tv2).is_null); // 2020-02-29 00:00:00 DateTimeValue dtv3(20200229000000); dtv3.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(false, TimestampFunctions::week_of_year(context, tv3).is_null); - ASSERT_EQ(9, TimestampFunctions::week_of_year(context, tv3).val); + EXPECT_EQ(false, TimestampFunctions::week_of_year(context, tv3).is_null); + EXPECT_EQ(9, TimestampFunctions::week_of_year(context, tv3).val); delete context; } @@ -208,31 +208,31 @@ TEST_F(TimestampFunctionsTest, year_week_test) { dtv1.set_type(TIME_DATE); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(202052, TimestampFunctions::year_week(context, tv1).val); + EXPECT_EQ(202052, TimestampFunctions::year_week(context, tv1).val); DateTimeValue dtv2(20210103000000); dtv2.set_type(TIME_DATE); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(202101, TimestampFunctions::year_week(context, tv2).val); + EXPECT_EQ(202101, TimestampFunctions::year_week(context, tv2).val); DateTimeValue dtv3(20210501000000); dtv3.set_type(TIME_DATE); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(202117, TimestampFunctions::year_week(context, tv3).val); + EXPECT_EQ(202117, TimestampFunctions::year_week(context, tv3).val); DateTimeValue dtv4(20241230000000); dtv4.set_type(TIME_DATE); doris_udf::DateTimeVal tv4; dtv4.to_datetime_val(&tv4); - ASSERT_EQ(202501, TimestampFunctions::year_week(context, tv4, 1).val); + EXPECT_EQ(202501, TimestampFunctions::year_week(context, tv4, 1).val); DateTimeValue dtv5(20261229121030); dtv5.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv5; dtv5.to_datetime_val(&tv5); - ASSERT_EQ(202653, TimestampFunctions::year_week(context, tv5, 3).val); + EXPECT_EQ(202653, TimestampFunctions::year_week(context, tv5, 3).val); delete context; } @@ -243,56 +243,56 @@ TEST_F(TimestampFunctionsTest, week_test) { dtv1.set_type(TIME_DATE); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(0, TimestampFunctions::week(context, tv1).val); + EXPECT_EQ(0, TimestampFunctions::week(context, tv1).val); DateTimeValue dtv2(20210103000000); dtv2.set_type(TIME_DATE); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(1, TimestampFunctions::week(context, tv2).val); + EXPECT_EQ(1, TimestampFunctions::week(context, tv2).val); DateTimeValue dtv3(20210501000000); dtv3.set_type(TIME_DATE); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(17, TimestampFunctions::week(context, tv3).val); + EXPECT_EQ(17, TimestampFunctions::week(context, tv3).val); DateTimeValue dtv4(20210101000000); dtv4.set_type(TIME_DATE); doris_udf::DateTimeVal tv4; dtv4.to_datetime_val(&tv4); - ASSERT_EQ(0, TimestampFunctions::week(context, tv4, {1}).val); + EXPECT_EQ(0, TimestampFunctions::week(context, tv4, {1}).val); DateTimeValue dtv5(20211201000000); dtv5.set_type(TIME_DATETIME); doris_udf::DateTimeVal tv5; dtv5.to_datetime_val(&tv5); - ASSERT_EQ(48, TimestampFunctions::week(context, tv5, 2).val); + EXPECT_EQ(48, TimestampFunctions::week(context, tv5, 2).val); delete context; } TEST_F(TimestampFunctionsTest, make_date_test) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); - ASSERT_EQ(true, TimestampFunctions::make_date(context, 2021, 0).is_null); + EXPECT_EQ(true, TimestampFunctions::make_date(context, 2021, 0).is_null); DateTimeValue dtv1(20210101000000); dtv1.set_type(TIME_DATE); doris_udf::DateTimeVal tv1; dtv1.to_datetime_val(&tv1); - ASSERT_EQ(tv1.packed_time, TimestampFunctions::make_date(context, 2021, 1).packed_time); + EXPECT_EQ(tv1.packed_time, TimestampFunctions::make_date(context, 2021, 1).packed_time); DateTimeValue dtv2(20211027000000); dtv2.set_type(TIME_DATE); doris_udf::DateTimeVal tv2; dtv2.to_datetime_val(&tv2); - ASSERT_EQ(tv2.packed_time, TimestampFunctions::make_date(context, 2021, 300).packed_time); + EXPECT_EQ(tv2.packed_time, TimestampFunctions::make_date(context, 2021, 300).packed_time); DateTimeValue dtv3(20220204000000); dtv3.set_type(TIME_DATE); doris_udf::DateTimeVal tv3; dtv3.to_datetime_val(&tv3); - ASSERT_EQ(tv3.packed_time, TimestampFunctions::make_date(context, 2021, 400).packed_time); + EXPECT_EQ(tv3.packed_time, TimestampFunctions::make_date(context, 2021, 400).packed_time); delete context; } @@ -307,7 +307,7 @@ TEST_F(TimestampFunctionsTest, time_diff_test) { doris_udf::DateTimeVal tv2; dt2.to_datetime_val(&tv2); - ASSERT_EQ(-3662, TimestampFunctions::time_diff(ctx, tv1, tv2).val); + EXPECT_EQ(-3662, TimestampFunctions::time_diff(ctx, tv1, tv2).val); // invalid DateTimeValue dt3(20190018120000); @@ -320,7 +320,7 @@ TEST_F(TimestampFunctionsTest, time_diff_test) { doris_udf::DateTimeVal tv4; dt4.to_datetime_val(&tv4); - ASSERT_EQ(true, TimestampFunctions::time_diff(ctx, tv3, tv4).is_null); + EXPECT_EQ(true, TimestampFunctions::time_diff(ctx, tv3, tv4).is_null); // invalid DateTimeValue dt5(20190718120000); @@ -333,47 +333,47 @@ TEST_F(TimestampFunctionsTest, time_diff_test) { doris_udf::DateTimeVal tv6; dt6.to_datetime_val(&tv6); - ASSERT_EQ(true, TimestampFunctions::time_diff(ctx, tv5, tv6).is_null); + EXPECT_EQ(true, TimestampFunctions::time_diff(ctx, tv5, tv6).is_null); } TEST_F(TimestampFunctionsTest, now) { DateTimeVal now = TimestampFunctions::now(ctx); DateTimeValue dt = DateTimeValue::from_datetime_val(now); - ASSERT_EQ(20190806013857, dt.to_int64()); + EXPECT_EQ(20190806013857, dt.to_int64()); } TEST_F(TimestampFunctionsTest, from_unix) { IntVal unixtimestamp(1565080737); StringVal sval = TimestampFunctions::from_unix(ctx, unixtimestamp); - ASSERT_EQ("2019-08-06 01:38:57", std::string((char*)sval.ptr, sval.len)); + EXPECT_EQ("2019-08-06 01:38:57", std::string((char*)sval.ptr, sval.len)); IntVal unixtimestamp2(-123); sval = TimestampFunctions::from_unix(ctx, unixtimestamp2); - ASSERT_TRUE(sval.is_null); + EXPECT_TRUE(sval.is_null); } TEST_F(TimestampFunctionsTest, to_unix) { DateTimeVal dt_val; dt_val.packed_time = 1847544683002068992; dt_val.type = TIME_DATETIME; - ASSERT_EQ(1565080737, TimestampFunctions::to_unix(ctx).val); - ASSERT_EQ(1565080737, TimestampFunctions::to_unix(ctx, dt_val).val); - ASSERT_EQ(1565080737, TimestampFunctions::to_unix(ctx, StringVal("2019-08-06 01:38:57"), + EXPECT_EQ(1565080737, TimestampFunctions::to_unix(ctx).val); + EXPECT_EQ(1565080737, TimestampFunctions::to_unix(ctx, dt_val).val); + EXPECT_EQ(1565080737, TimestampFunctions::to_unix(ctx, StringVal("2019-08-06 01:38:57"), "%Y-%m-%d %H:%i:%S") .val); DateTimeValue dt_value; dt_value.from_date_int64(99991230); dt_value.to_datetime_val(&dt_val); - ASSERT_EQ(0, TimestampFunctions::to_unix(ctx, dt_val).val); + EXPECT_EQ(0, TimestampFunctions::to_unix(ctx, dt_val).val); dt_value.from_date_int64(10000101); dt_value.to_datetime_val(&dt_val); - ASSERT_EQ(0, TimestampFunctions::to_unix(ctx, dt_val).val); + EXPECT_EQ(0, TimestampFunctions::to_unix(ctx, dt_val).val); } TEST_F(TimestampFunctionsTest, curtime) { - ASSERT_EQ(3600 + 38 * 60 + 57, TimestampFunctions::curtime(ctx).val); + EXPECT_EQ(3600 + 38 * 60 + 57, TimestampFunctions::curtime(ctx).val); } TEST_F(TimestampFunctionsTest, convert_tz_test) { @@ -385,20 +385,20 @@ TEST_F(TimestampFunctionsTest, convert_tz_test) { DateTimeVal t = TimestampFunctions::convert_tz(context, tv1, StringVal("Asia/Shanghai"), StringVal("America/Los_Angeles")); DateTimeValue dt2 = DateTimeValue::from_datetime_val(t); - ASSERT_EQ(20190806013857, dt2.to_int64()); + EXPECT_EQ(20190806013857, dt2.to_int64()); t = TimestampFunctions::convert_tz(context, tv1, StringVal("CST"), StringVal("America/Los_Angeles")); DateTimeValue dt3 = DateTimeValue::from_datetime_val(t); - ASSERT_EQ(20190806013857, dt3.to_int64()); + EXPECT_EQ(20190806013857, dt3.to_int64()); delete context; } -#define ASSERT_DIFF(unit, diff, tv1, tv2) \ - ASSERT_EQ( \ +#define EXPECT_DIFF(unit, diff, tv1, tv2) \ + EXPECT_EQ( \ diff, \ TimestampFunctions::unit##s_diff(context, datetime_val(tv1), datetime_val(tv2)).val); \ - ASSERT_EQ( \ + EXPECT_EQ( \ -(diff), \ TimestampFunctions::unit##s_diff(context, datetime_val(tv2), datetime_val(tv1)).val); TEST_F(TimestampFunctionsTest, timestampdiff_test) { @@ -407,36 +407,36 @@ TEST_F(TimestampFunctionsTest, timestampdiff_test) { int64_t tv2 = 20120830000000; //YEAR - ASSERT_DIFF(year, 0, tv2, tv1); - ASSERT_DIFF(year, 1, tv1, 20100930000000); + EXPECT_DIFF(year, 0, tv2, tv1); + EXPECT_DIFF(year, 1, tv1, 20100930000000); //MONTH - ASSERT_DIFF(month, 0, tv2, tv1); - ASSERT_DIFF(month, 0, tv2, tv1); - ASSERT_DIFF(month, 0, 20120924000000, tv1); - ASSERT_DIFF(month, 1, tv1, 20120630000000); + EXPECT_DIFF(month, 0, tv2, tv1); + EXPECT_DIFF(month, 0, tv2, tv1); + EXPECT_DIFF(month, 0, 20120924000000, tv1); + EXPECT_DIFF(month, 1, tv1, 20120630000000); //WEEK - ASSERT_DIFF(week, 0, tv2, tv1); + EXPECT_DIFF(week, 0, tv2, tv1); //DAY - ASSERT_DIFF(day, 5, tv2, tv1); - ASSERT_DIFF(day, 6, 20120830000001, tv1); - ASSERT_DIFF(day, 8, 20120901000001, tv1); - ASSERT_DIFF(day, 0, 20120823000005, tv1); - ASSERT_DIFF(day, 0, 20120824000001, tv1); + EXPECT_DIFF(day, 5, tv2, tv1); + EXPECT_DIFF(day, 6, 20120830000001, tv1); + EXPECT_DIFF(day, 8, 20120901000001, tv1); + EXPECT_DIFF(day, 0, 20120823000005, tv1); + EXPECT_DIFF(day, 0, 20120824000001, tv1); //HOUR - ASSERT_DIFF(hour, 143, tv2, tv1); + EXPECT_DIFF(hour, 143, tv2, tv1); //MINUTE - ASSERT_DIFF(minute, 8639, tv2, tv1); + EXPECT_DIFF(minute, 8639, tv2, tv1); //SECOND - ASSERT_DIFF(second, 518399, tv2, tv1); + EXPECT_DIFF(second, 518399, tv2, tv1); delete context; } -#define ASSERT_ROUND(unit, floor, ceil, ...) \ - ASSERT_EQ(datetime_val(floor).packed_time, \ +#define EXPECT_ROUND(unit, floor, ceil, ...) \ + EXPECT_EQ(datetime_val(floor).packed_time, \ TimestampFunctions::unit##_floor(context, __VA_ARGS__).packed_time); \ - ASSERT_EQ(datetime_val(ceil).packed_time, \ + EXPECT_EQ(datetime_val(ceil).packed_time, \ TimestampFunctions::unit##_ceil(context, __VA_ARGS__).packed_time); TEST_F(TimestampFunctionsTest, time_round_test) { doris_udf::FunctionContext* context = new doris_udf::FunctionContext(); @@ -445,49 +445,45 @@ TEST_F(TimestampFunctionsTest, time_round_test) { doris_udf::IntVal three(3); doris_udf::DateTimeVal wednesday = datetime_val(20200916000000); //YEAR - ASSERT_ROUND(year, 20120101000000, 20130101000000, tv); - ASSERT_ROUND(year, 20110916000000, 20120916000000, tv, wednesday); - ASSERT_ROUND(year, 20110916000000, 20140916000000, tv, three, wednesday); + EXPECT_ROUND(year, 20120101000000, 20130101000000, tv); + EXPECT_ROUND(year, 20110916000000, 20120916000000, tv, wednesday); + EXPECT_ROUND(year, 20110916000000, 20140916000000, tv, three, wednesday); //MONTH - ASSERT_ROUND(month, 20120801000000, 20120901000000, tv); - ASSERT_ROUND(month, 20120701000000, 20121001000000, tv, three); + EXPECT_ROUND(month, 20120801000000, 20120901000000, tv); + EXPECT_ROUND(month, 20120701000000, 20121001000000, tv, three); //WEEK - ASSERT_ROUND(week, 20120819000000, 20120826000000, tv); - ASSERT_ROUND(week, 20120822000000, 20120829000000, tv, wednesday); - ASSERT_ROUND(week, 20120808000000, 20120829000000, tv, three, wednesday); + EXPECT_ROUND(week, 20120819000000, 20120826000000, tv); + EXPECT_ROUND(week, 20120822000000, 20120829000000, tv, wednesday); + EXPECT_ROUND(week, 20120808000000, 20120829000000, tv, three, wednesday); doris_udf::DateTimeVal tv1 = datetime_val(20200202130920); doris_udf::DateTimeVal monday = datetime_val(20200106000000); - ASSERT_ROUND(week, 20200202000000, 20200209000000, tv1); - ASSERT_ROUND(week, 20200127000000, 20200203000000, tv1, monday); + EXPECT_ROUND(week, 20200202000000, 20200209000000, tv1); + EXPECT_ROUND(week, 20200127000000, 20200203000000, tv1, monday); //DAY doris_udf::DateTimeVal noon = datetime_val(19700101120000); - ASSERT_ROUND(day, 20120824000000, 20120825000000, tv); - ASSERT_ROUND(day, 20120824120000, 20120825120000, tv, noon); + EXPECT_ROUND(day, 20120824000000, 20120825000000, tv); + EXPECT_ROUND(day, 20120824120000, 20120825120000, tv, noon); //HOUR doris_udf::DateTimeVal random = datetime_val(29380329113953); - ASSERT_ROUND(hour, 20120824120000, 20120824150000, tv, three); - ASSERT_ROUND(hour, 20120824113953, 20120824143953, tv, three, random); + EXPECT_ROUND(hour, 20120824120000, 20120824150000, tv, three); + EXPECT_ROUND(hour, 20120824113953, 20120824143953, tv, three, random); //MINUTE doris_udf::IntVal val90(90); - ASSERT_ROUND(minute, 20120824132900, 20120824133000, tv); - ASSERT_ROUND(minute, 20120824120000, 20120824133000, tv, val90); - ASSERT_ROUND(minute, 20120824130953, 20120824143953, tv, val90, random); + EXPECT_ROUND(minute, 20120824132900, 20120824133000, tv); + EXPECT_ROUND(minute, 20120824120000, 20120824133000, tv, val90); + EXPECT_ROUND(minute, 20120824130953, 20120824143953, tv, val90, random); //SECOND - ASSERT_ROUND(second, 20120824132900, 20120824132903, tv, three); - ASSERT_ROUND(second, 20120824132830, 20120824133000, tv, val90); + EXPECT_ROUND(second, 20120824132900, 20120824132903, tv, three); + EXPECT_ROUND(second, 20120824132830, 20120824133000, tv, val90); delete context; } } // namespace doris -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/topn_function_test.cpp b/be/test/exprs/topn_function_test.cpp index 1ba2be4cdf..fd6e642d52 100644 --- a/be/test/exprs/topn_function_test.cpp +++ b/be/test/exprs/topn_function_test.cpp @@ -23,8 +23,8 @@ #include "exprs/anyval_util.h" #include "exprs/expr_context.h" -#include "test_util/test_util.h" #include "testutil/function_utils.h" +#include "testutil/test_util.h" #include "util/topn_counter.h" #include "zipf_distribution.h" @@ -192,7 +192,7 @@ TEST_F(TopNFunctionsTest, topn_update) { StringVal result = TopNFunctions::topn_finalize(ctx, dst); StringVal expected("{\"a\":10,\"b\":2}"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } TEST_F(TopNFunctionsTest, topn_merge) { @@ -224,12 +224,7 @@ TEST_F(TopNFunctionsTest, topn_merge) { TopNFunctions::topn_merge(ctx, val2, &dst); StringVal result = TopNFunctions::topn_finalize(ctx, dst); StringVal expected("{\"a\":20,\"b\":8}"); - ASSERT_EQ(expected, result); + EXPECT_EQ(expected, result); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/exprs/window_funnel_test.cpp b/be/test/exprs/window_funnel_test.cpp index f8f190ae9b..04449438dd 100644 --- a/be/test/exprs/window_funnel_test.cpp +++ b/be/test/exprs/window_funnel_test.cpp @@ -50,30 +50,30 @@ TEST_F(WindowFunnelTest, testMax4SortedNoMerge) { time_value.set_time(2020, 2, 28, 0, 0, 1, 0); time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 3, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {false, false, true, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 4, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, true}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, i < 0 ? 1 : (i < NUM_CONDS ? i + 1 : NUM_CONDS)); + EXPECT_EQ(v.val, i < 0 ? 1 : (i < NUM_CONDS ? i + 1 : NUM_CONDS)); } delete futil; } @@ -100,26 +100,26 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 3, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {false, false, true, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 4, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, true}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); StringVal s = AggregateFunctions::window_funnel_serialize(context, stringVal1); @@ -128,7 +128,7 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { AggregateFunctions::window_funnel_merge(context, s, &stringVal2); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal2); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, i < 0 ? 1 : (i < NUM_CONDS ? i + 1 : NUM_CONDS)); + EXPECT_EQ(v.val, i < 0 ? 1 : (i < NUM_CONDS ? i + 1 : NUM_CONDS)); } delete futil; } @@ -155,30 +155,30 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 1, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {false, false, true, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 0, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, true}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, 1); + EXPECT_EQ(v.val, 1); } delete futil; } @@ -205,26 +205,26 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 1, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {false, false, true, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 0, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, true}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); StringVal s = AggregateFunctions::window_funnel_serialize(context, stringVal1); @@ -233,7 +233,7 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { AggregateFunctions::window_funnel_merge(context, s, &stringVal2); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal2); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, 1); + EXPECT_EQ(v.val, 1); } delete futil; } @@ -260,30 +260,30 @@ TEST_F(WindowFunnelTest, testMax4DuplicateSortedNoMerge) { time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 1, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {true, false, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 3, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, i < 0 ? 1 : (i < 2 ? i + 1 : 2)); + EXPECT_EQ(v.val, i < 0 ? 1 : (i < 2 ? i + 1 : 2)); } delete futil; } @@ -310,26 +310,26 @@ TEST_F(WindowFunnelTest, testMax4DuplicateSortedMerge) { time_value.to_datetime_val(×tamp); BooleanVal conds[NUM_CONDS] = {true, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, conds, + &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 1, 0); time_value.to_datetime_val(×tamp); BooleanVal conds1[NUM_CONDS] = {false, true, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds1, &stringVal1); + conds1, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 2, 0); time_value.to_datetime_val(×tamp); BooleanVal conds2[NUM_CONDS] = {true, false, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds2, &stringVal1); + conds2, &stringVal1); time_value.set_time(2020, 2, 28, 0, 0, 3, 0); time_value.to_datetime_val(×tamp); BooleanVal conds3[NUM_CONDS] = {false, false, false, false}; AggregateFunctions::window_funnel_update(context, window, mode, timestamp, NUM_CONDS, - conds3, &stringVal1); + conds3, &stringVal1); StringVal s = AggregateFunctions::window_funnel_serialize(context, stringVal1); @@ -338,7 +338,7 @@ TEST_F(WindowFunnelTest, testMax4DuplicateSortedMerge) { AggregateFunctions::window_funnel_merge(context, s, &stringVal2); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal2); LOG(INFO) << "event num: " << NUM_CONDS << " window: " << window.val; - ASSERT_EQ(v.val, i < 0 ? 1 : (i < 2 ? i + 1 : 2)); + EXPECT_EQ(v.val, i < 0 ? 1 : (i < 2 ? i + 1 : 2)); } delete futil; } @@ -363,11 +363,11 @@ TEST_F(WindowFunnelTest, testNoMatchedEvent) { time_value.to_datetime_val(×tamp); BooleanVal conds[4] = {false, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, 4, - conds, &stringVal1); + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, 4, conds, + &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); - ASSERT_EQ(v.val, 0); + EXPECT_EQ(v.val, 0); delete futil; } @@ -386,13 +386,13 @@ TEST_F(WindowFunnelTest, testNoEvent) { AggregateFunctions::window_funnel_init(context, &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); - ASSERT_EQ(v.val, 0); + EXPECT_EQ(v.val, 0); StringVal stringVal2; AggregateFunctions::window_funnel_init(context, &stringVal2); v = AggregateFunctions::window_funnel_finalize(context, stringVal2); - ASSERT_EQ(v.val, 0); + EXPECT_EQ(v.val, 0); delete futil; } @@ -413,19 +413,13 @@ TEST_F(WindowFunnelTest, testInputNull) { DateTimeVal timestamp = DateTimeVal::null(); BooleanVal conds[4] = {false, false, false, false}; - AggregateFunctions::window_funnel_update(context, window, mode, timestamp, 4, - conds, &stringVal1); - + AggregateFunctions::window_funnel_update(context, window, mode, timestamp, 4, conds, + &stringVal1); IntVal v = AggregateFunctions::window_funnel_finalize(context, stringVal1); - ASSERT_EQ(v.val, 0); + EXPECT_EQ(v.val, 0); delete futil; } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/geo/CMakeLists.txt b/be/test/geo/CMakeLists.txt deleted file mode 100644 index bbe5dabfc9..0000000000 --- a/be/test/geo/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/geo") - -ADD_BE_TEST(wkt_parse_test) -ADD_BE_TEST(geo_functions_test) -ADD_BE_TEST(geo_types_test) diff --git a/be/test/geo/geo_functions_test.cpp b/be/test/geo/geo_functions_test.cpp index 9145a9a924..fcff73f392 100644 --- a/be/test/geo/geo_functions_test.cpp +++ b/be/test/geo/geo_functions_test.cpp @@ -48,7 +48,7 @@ TEST_F(GeoFunctionsTest, st_dist_sphere) { DoubleVal y_lat(0.0); auto dist = GeoFunctions::st_distance_sphere(ctx, x_lng, x_lat, y_lng, y_lat); - ASSERT_EQ(0, dist.val); + EXPECT_EQ(0, dist.val); } { DoubleVal x_lng(0.0); @@ -68,13 +68,13 @@ TEST_F(GeoFunctionsTest, st_point) { DoubleVal lat(64); auto str = GeoFunctions::st_point(ctx, lng, lat); - ASSERT_FALSE(str.is_null); + EXPECT_FALSE(str.is_null); GeoPoint point; auto res = point.decode_from(str.ptr, str.len); - ASSERT_TRUE(res); - ASSERT_EQ(113, point.x()); - ASSERT_EQ(64, point.y()); + EXPECT_TRUE(res); + EXPECT_EQ(113, point.x()); + EXPECT_EQ(64, point.y()); } TEST_F(GeoFunctionsTest, st_x_y) { @@ -89,8 +89,8 @@ TEST_F(GeoFunctionsTest, st_x_y) { auto x = GeoFunctions::st_x(ctx, StringVal((uint8_t*)buf.data(), buf.size())); auto y = GeoFunctions::st_y(ctx, StringVal((uint8_t*)buf.data(), buf.size())); - ASSERT_EQ(134, x.val); - ASSERT_EQ(63, y.val); + EXPECT_EQ(134, x.val); + EXPECT_EQ(63, y.val); } TEST_F(GeoFunctionsTest, as_wkt) { @@ -104,7 +104,7 @@ TEST_F(GeoFunctionsTest, as_wkt) { point.encode_to(&buf); auto wkt = GeoFunctions::st_as_wkt(ctx, StringVal((uint8_t*)buf.data(), buf.size())); - ASSERT_STREQ("POINT (134 63)", std::string((char*)wkt.ptr, wkt.len).c_str()); + EXPECT_STREQ("POINT (134 63)", std::string((char*)wkt.ptr, wkt.len).c_str()); } TEST_F(GeoFunctionsTest, st_from_wkt) { @@ -112,10 +112,10 @@ TEST_F(GeoFunctionsTest, st_from_wkt) { FunctionContext* ctx = utils.get_fn_ctx(); GeoFunctions::st_from_wkt_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); std::string wkt = "POINT (10.1 20.2)"; auto str = GeoFunctions::st_from_wkt(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str.is_null); + EXPECT_FALSE(str.is_null); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); // second time @@ -128,18 +128,18 @@ TEST_F(GeoFunctionsTest, st_from_wkt) { // prepare GeoFunctions::st_from_wkt_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); // convert auto str2 = GeoFunctions::st_from_wkt(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str2.is_null); + EXPECT_FALSE(str2.is_null); // close GeoPoint point; auto res = point.decode_from(str2.ptr, str2.len); - ASSERT_TRUE(res); - ASSERT_DOUBLE_EQ(10.1, point.x()); - ASSERT_DOUBLE_EQ(20.2, point.y()); + EXPECT_TRUE(res); + EXPECT_DOUBLE_EQ(10.1, point.x()); + EXPECT_DOUBLE_EQ(20.2, point.y()); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } @@ -152,11 +152,11 @@ TEST_F(GeoFunctionsTest, st_line) { std::string wkt = "LINESTRING (10.1 20.2, 21.1 30.1)"; auto str = GeoFunctions::st_from_wkt(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str.is_null); + EXPECT_FALSE(str.is_null); GeoLine line; auto res = line.decode_from(str.ptr, str.len); - ASSERT_TRUE(res); + EXPECT_TRUE(res); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); // second time @@ -169,16 +169,16 @@ TEST_F(GeoFunctionsTest, st_line) { // prepare GeoFunctions::st_line_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); // convert auto str2 = GeoFunctions::st_line(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str2.is_null); + EXPECT_FALSE(str2.is_null); // close GeoLine line; auto res = line.decode_from(str2.ptr, str2.len); - ASSERT_TRUE(res); + EXPECT_TRUE(res); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } @@ -191,7 +191,7 @@ TEST_F(GeoFunctionsTest, st_polygon) { std::string wkt = "POLYGON ((10 10, 50 10, 50 50, 10 50, 10 10))"; auto str = GeoFunctions::st_from_wkt(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str.is_null); + EXPECT_FALSE(str.is_null); // second time { @@ -203,16 +203,16 @@ TEST_F(GeoFunctionsTest, st_polygon) { // prepare GeoFunctions::st_polygon_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); // convert auto str2 = GeoFunctions::st_polygon(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_FALSE(str2.is_null); + EXPECT_FALSE(str2.is_null); // close GeoPolygon polygon; auto res = polygon.decode_from(str2.ptr, str2.len); - ASSERT_TRUE(res); + EXPECT_TRUE(res); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } @@ -227,7 +227,7 @@ TEST_F(GeoFunctionsTest, st_circle) { DoubleVal lat(64); DoubleVal radius_meter(10 * 100); auto str = GeoFunctions::st_circle(ctx, lng, lat, radius_meter); - ASSERT_FALSE(str.is_null); + EXPECT_FALSE(str.is_null); // second time { @@ -240,16 +240,16 @@ TEST_F(GeoFunctionsTest, st_circle) { // prepare GeoFunctions::st_circle_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); // convert auto str2 = GeoFunctions::st_circle(ctx, lng, lat, radius_meter); - ASSERT_FALSE(str2.is_null); + EXPECT_FALSE(str2.is_null); // close GeoCircle circle; auto res = circle.decode_from(str2.ptr, str2.len); - ASSERT_TRUE(res); + EXPECT_TRUE(res); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } @@ -263,7 +263,7 @@ TEST_F(GeoFunctionsTest, st_poly_line_fail) { std::string wkt = "POINT (10.1 20.2)"; auto str = GeoFunctions::st_polygon(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_TRUE(str.is_null); + EXPECT_TRUE(str.is_null); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } { @@ -271,7 +271,7 @@ TEST_F(GeoFunctionsTest, st_poly_line_fail) { std::string wkt = "POINT (10.1 20.2)"; auto str = GeoFunctions::st_line(ctx, StringVal((uint8_t*)wkt.data(), wkt.size())); - ASSERT_TRUE(str.is_null); + EXPECT_TRUE(str.is_null); GeoFunctions::st_from_wkt_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } @@ -280,22 +280,22 @@ TEST_F(GeoFunctionsTest, st_contains) { FunctionUtils utils; FunctionContext* ctx = utils.get_fn_ctx(); - ASSERT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); std::string polygon_wkt = "POLYGON ((10 10, 50 10, 50 50, 10 50, 10 10))"; auto polygon = GeoFunctions::st_from_wkt( ctx, StringVal((uint8_t*)polygon_wkt.data(), polygon_wkt.size())); - ASSERT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); std::string point_wkt = "POINT (25 25)"; auto point = GeoFunctions::st_from_wkt(ctx, StringVal((uint8_t*)point_wkt.data(), point_wkt.size())); - ASSERT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); GeoFunctions::st_contains_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_EQ(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); auto res = GeoFunctions::st_contains(ctx, polygon, point); - ASSERT_TRUE(res.val); + EXPECT_TRUE(res.val); GeoFunctions::st_contains_close(ctx, FunctionContext::FRAGMENT_LOCAL); } @@ -320,16 +320,10 @@ TEST_F(GeoFunctionsTest, st_contains_cached) { // prepare GeoFunctions::st_contains_prepare(ctx, FunctionContext::FRAGMENT_LOCAL); - ASSERT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); + EXPECT_NE(nullptr, ctx->get_function_state(FunctionContext::FRAGMENT_LOCAL)); auto res = GeoFunctions::st_contains(ctx, polygon, point); - ASSERT_TRUE(res.val); + EXPECT_TRUE(res.val); GeoFunctions::st_contains_close(ctx, FunctionContext::FRAGMENT_LOCAL); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - FLAGS_s2debug = false; - return RUN_ALL_TESTS(); -} diff --git a/be/test/geo/geo_types_test.cpp b/be/test/geo/geo_types_test.cpp index 8f28500eee..cd29163ec9 100644 --- a/be/test/geo/geo_types_test.cpp +++ b/be/test/geo/geo_types_test.cpp @@ -37,20 +37,20 @@ TEST_F(GeoTypesTest, point_normal) { { GeoPoint point; auto status = point.from_coord(116.123, 63.546); - ASSERT_EQ(GEO_PARSE_OK, status); - ASSERT_STREQ("POINT (116.123 63.546)", point.as_wkt().c_str()); + EXPECT_EQ(GEO_PARSE_OK, status); + EXPECT_STREQ("POINT (116.123 63.546)", point.as_wkt().c_str()); std::string buf; point.encode_to(&buf); { std::unique_ptr point2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_STREQ("POINT (116.123 63.546)", point2->as_wkt().c_str()); + EXPECT_STREQ("POINT (116.123 63.546)", point2->as_wkt().c_str()); } { buf.resize(buf.size() - 1); std::unique_ptr point2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_EQ(nullptr, point2); + EXPECT_EQ(nullptr, point2); } } { @@ -59,8 +59,8 @@ TEST_F(GeoTypesTest, point_normal) { coord.x = 116.123; coord.y = 63.546; auto status = point.from_coord(coord); - ASSERT_EQ(GEO_PARSE_OK, status); - ASSERT_STREQ("POINT (116.123 63.546)", point.as_wkt().c_str()); + EXPECT_EQ(GEO_PARSE_OK, status); + EXPECT_STREQ("POINT (116.123 63.546)", point.as_wkt().c_str()); } } @@ -68,29 +68,29 @@ TEST_F(GeoTypesTest, point_invalid) { GeoPoint point; auto status = point.from_coord(200, 88); - ASSERT_NE(GEO_PARSE_OK, status); + EXPECT_NE(GEO_PARSE_OK, status); } TEST_F(GeoTypesTest, linestring) { const char* wkt = "LINESTRING (30 10, 10 30, 40 40)"; GeoParseStatus status; std::unique_ptr line(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_NE(nullptr, line.get()); - ASSERT_EQ(GEO_SHAPE_LINE_STRING, line->type()); + EXPECT_NE(nullptr, line.get()); + EXPECT_EQ(GEO_SHAPE_LINE_STRING, line->type()); - ASSERT_STREQ(wkt, line->as_wkt().c_str()); + EXPECT_STREQ(wkt, line->as_wkt().c_str()); std::string buf; line->encode_to(&buf); { std::unique_ptr line2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_STREQ(wkt, line2->as_wkt().c_str()); + EXPECT_STREQ(wkt, line2->as_wkt().c_str()); } { buf.resize(buf.size() - 1); std::unique_ptr line2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_EQ(nullptr, line2); + EXPECT_EQ(nullptr, line2); } } @@ -98,19 +98,19 @@ TEST_F(GeoTypesTest, polygon_contains) { const char* wkt = "POLYGON ((10 10, 50 10, 50 10, 50 50, 50 50, 10 50, 10 10))"; GeoParseStatus status; std::unique_ptr polygon(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_NE(nullptr, polygon.get()); + EXPECT_NE(nullptr, polygon.get()); { GeoPoint point; point.from_coord(20, 20); auto res = polygon->contains(&point); - ASSERT_TRUE(res); + EXPECT_TRUE(res); } { GeoPoint point; point.from_coord(5, 5); auto res = polygon->contains(&point); - ASSERT_FALSE(res); + EXPECT_FALSE(res); } std::string buf; @@ -118,14 +118,14 @@ TEST_F(GeoTypesTest, polygon_contains) { { std::unique_ptr shape(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_EQ(GEO_SHAPE_POLYGON, shape->type()); + EXPECT_EQ(GEO_SHAPE_POLYGON, shape->type()); LOG(INFO) << "polygon=" << shape->as_wkt(); } { buf.resize(buf.size() - 1); std::unique_ptr shape(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_EQ(nullptr, shape); + EXPECT_EQ(nullptr, shape); } } @@ -134,22 +134,22 @@ TEST_F(GeoTypesTest, polygon_parse_fail) { const char* wkt = "POLYGON ((10 10, 50 10, 50 50, 10 50), (10 10 01))"; GeoParseStatus status; std::unique_ptr polygon(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_EQ(GEO_PARSE_WKT_SYNTAX_ERROR, status); - ASSERT_EQ(nullptr, polygon.get()); + EXPECT_EQ(GEO_PARSE_WKT_SYNTAX_ERROR, status); + EXPECT_EQ(nullptr, polygon.get()); } { const char* wkt = "POLYGON ((10 10, 50 10, 50 50, 10 50))"; GeoParseStatus status; std::unique_ptr polygon(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_EQ(GEO_PARSE_LOOP_NOT_CLOSED, status); - ASSERT_EQ(nullptr, polygon.get()); + EXPECT_EQ(GEO_PARSE_LOOP_NOT_CLOSED, status); + EXPECT_EQ(nullptr, polygon.get()); } { const char* wkt = "POLYGON ((10 10, 50 10, 10 10))"; GeoParseStatus status; std::unique_ptr polygon(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_EQ(GEO_PARSE_LOOP_LACK_VERTICES, status); - ASSERT_EQ(nullptr, polygon.get()); + EXPECT_EQ(GEO_PARSE_LOOP_LACK_VERTICES, status); + EXPECT_EQ(nullptr, polygon.get()); } } @@ -158,53 +158,47 @@ TEST_F(GeoTypesTest, polygon_hole_contains) { "POLYGON ((10 10, 50 10, 50 50, 10 50, 10 10), (20 20, 40 20, 40 40, 20 40, 20 20))"; GeoParseStatus status; std::unique_ptr polygon(GeoShape::from_wkt(wkt, strlen(wkt), &status)); - ASSERT_EQ(GEO_PARSE_OK, status); - ASSERT_NE(nullptr, polygon); + EXPECT_EQ(GEO_PARSE_OK, status); + EXPECT_NE(nullptr, polygon); { GeoPoint point; point.from_coord(15, 15); auto res = polygon->contains(&point); - ASSERT_TRUE(res); + EXPECT_TRUE(res); } { GeoPoint point; point.from_coord(25, 25); auto res = polygon->contains(&point); - ASSERT_FALSE(res); + EXPECT_FALSE(res); } { GeoPoint point; point.from_coord(20, 20); auto res = polygon->contains(&point); - ASSERT_TRUE(res); + EXPECT_TRUE(res); } } TEST_F(GeoTypesTest, circle) { GeoCircle circle; auto res = circle.init(110.123, 64, 1000); - ASSERT_EQ(GEO_PARSE_OK, res); + EXPECT_EQ(GEO_PARSE_OK, res); std::string buf; circle.encode_to(&buf); { std::unique_ptr circle2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_STREQ("CIRCLE ((110.123 64), 1000)", circle2->as_wkt().c_str()); + EXPECT_STREQ("CIRCLE ((110.123 64), 1000)", circle2->as_wkt().c_str()); } { buf.resize(buf.size() - 1); std::unique_ptr circle2(GeoShape::from_encoded(buf.data(), buf.size())); - ASSERT_EQ(nullptr, circle2); + EXPECT_EQ(nullptr, circle2); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - FLAGS_s2debug = false; - return RUN_ALL_TESTS(); -} diff --git a/be/test/geo/wkt_parse_test.cpp b/be/test/geo/wkt_parse_test.cpp index 09b6c39f52..20d472a7ac 100644 --- a/be/test/geo/wkt_parse_test.cpp +++ b/be/test/geo/wkt_parse_test.cpp @@ -36,8 +36,8 @@ TEST_F(WktParseTest, normal) { GeoShape* shape = nullptr; auto status = WktParse::parse_wkt(wkt, strlen(wkt), &shape); - ASSERT_EQ(GEO_PARSE_OK, status); - ASSERT_NE(nullptr, shape); + EXPECT_EQ(GEO_PARSE_OK, status); + EXPECT_NE(nullptr, shape); LOG(INFO) << "parse result: " << shape->to_string(); delete shape; } @@ -47,13 +47,8 @@ TEST_F(WktParseTest, invalid_wkt) { GeoShape* shape = nullptr; auto status = WktParse::parse_wkt(wkt, strlen(wkt), &shape); - ASSERT_NE(GEO_PARSE_OK, status); - ASSERT_EQ(nullptr, shape); + EXPECT_NE(GEO_PARSE_OK, status); + EXPECT_EQ(nullptr, shape); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/gutil/CMakeLists.txt b/be/test/gutil/CMakeLists.txt deleted file mode 100644 index be5c861b65..0000000000 --- a/be/test/gutil/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/gutil") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/gutil") - -ADD_BE_TEST(strings/numbers_test) \ No newline at end of file diff --git a/be/test/gutil/strings/numbers_test.cpp b/be/test/gutil/strings/numbers_test.cpp index ceb0033dba..a6494641d6 100644 --- a/be/test/gutil/strings/numbers_test.cpp +++ b/be/test/gutil/strings/numbers_test.cpp @@ -132,8 +132,3 @@ TEST_F(NumbersTest, test_double_to_buffer) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/http/CMakeLists.txt b/be/test/http/CMakeLists.txt deleted file mode 100644 index f81ab025d3..0000000000 --- a/be/test/http/CMakeLists.txt +++ /dev/null @@ -1,25 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/http") - -ADD_BE_TEST(metrics_action_test) -ADD_BE_TEST(message_body_sink_test) -ADD_BE_TEST(http_utils_test) -ADD_BE_TEST(stream_load_test) -ADD_BE_TEST(http_client_test) diff --git a/be/test/http/http_client_test.cpp b/be/test/http/http_client_test.cpp index fa5850c872..e7346158fc 100644 --- a/be/test/http/http_client_test.cpp +++ b/be/test/http/http_client_test.cpp @@ -86,7 +86,7 @@ public: s_server->register_handler(POST, "/simple_post", &s_simple_post_handler); s_server->start(); real_port = s_server->get_real_port(); - ASSERT_NE(0, real_port); + EXPECT_NE(0, real_port); hostname = "http://127.0.0.1:" + std::to_string(real_port); } @@ -96,85 +96,80 @@ public: TEST_F(HttpClientTest, get_normal) { HttpClient client; auto st = client.init(hostname + "/simple_get"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_method(GET); client.set_basic_auth("test1", ""); std::string response; st = client.execute(&response); - ASSERT_TRUE(st.ok()); - ASSERT_STREQ("test1", response.c_str()); + EXPECT_TRUE(st.ok()); + EXPECT_STREQ("test1", response.c_str()); // for head st = client.init(hostname + "/simple_get"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_method(HEAD); client.set_basic_auth("test1", ""); st = client.execute(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); uint64_t len = 0; st = client.get_content_length(&len); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, len); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, len); } TEST_F(HttpClientTest, download) { HttpClient client; auto st = client.init(hostname + "/simple_get"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_basic_auth("test1", ""); std::string local_file = ".http_client_test.dat"; st = client.download(local_file); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); char buf[50]; auto fp = fopen(local_file.c_str(), "r"); auto size = fread(buf, 1, 50, fp); buf[size] = 0; - ASSERT_STREQ("test1", buf); + EXPECT_STREQ("test1", buf); unlink(local_file.c_str()); } TEST_F(HttpClientTest, get_failed) { HttpClient client; auto st = client.init(hostname + "/simple_get"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_method(GET); client.set_basic_auth("test1", ""); std::string response; st = client.execute(&response); - ASSERT_FALSE(!st.ok()); + EXPECT_FALSE(!st.ok()); } TEST_F(HttpClientTest, post_normal) { HttpClient client; auto st = client.init(hostname + "/simple_post"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_method(POST); client.set_basic_auth("test1", ""); std::string response; std::string request_body = "simple post body query"; st = client.execute_post_request(request_body, &response); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(response.length(), request_body.length()); - ASSERT_STREQ(response.c_str(), request_body.c_str()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(response.length(), request_body.length()); + EXPECT_STREQ(response.c_str(), request_body.c_str()); } TEST_F(HttpClientTest, post_failed) { HttpClient client; auto st = client.init(hostname + "/simple_pos"); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); client.set_method(POST); client.set_basic_auth("test1", ""); std::string response; std::string request_body = "simple post body query"; st = client.execute_post_request(request_body, &response); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); std::string not_found = "404"; - ASSERT_TRUE(boost::algorithm::contains(st.get_error_msg(), not_found)); + EXPECT_TRUE(boost::algorithm::contains(st.get_error_msg(), not_found)); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/http/http_utils_test.cpp b/be/test/http/http_utils_test.cpp index 9407b9fc72..451cdf1115 100644 --- a/be/test/http/http_utils_test.cpp +++ b/be/test/http/http_utils_test.cpp @@ -48,9 +48,9 @@ TEST_F(HttpUtilsTest, parse_basic_auth) { std::string user; std::string passwd; auto res = parse_basic_auth(req, &user, &passwd); - ASSERT_TRUE(res); - ASSERT_STREQ("doris", user.data()); - ASSERT_STREQ("passwd", passwd.data()); + EXPECT_TRUE(res); + EXPECT_STREQ("doris", user.data()); + EXPECT_STREQ("passwd", passwd.data()); } { HttpRequest req(_evhttp_req); @@ -61,7 +61,7 @@ TEST_F(HttpUtilsTest, parse_basic_auth) { std::string user; std::string passwd; auto res = parse_basic_auth(req, &user, &passwd); - ASSERT_FALSE(res); + EXPECT_FALSE(res); } { HttpRequest req(_evhttp_req); @@ -73,7 +73,7 @@ TEST_F(HttpUtilsTest, parse_basic_auth) { std::string user; std::string passwd; auto res = parse_basic_auth(req, &user, &passwd); - ASSERT_FALSE(res); + EXPECT_FALSE(res); } { HttpRequest req(_evhttp_req); @@ -85,13 +85,8 @@ TEST_F(HttpUtilsTest, parse_basic_auth) { std::string user; std::string passwd; auto res = parse_basic_auth(req, &user, &passwd); - ASSERT_FALSE(res); + EXPECT_FALSE(res); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/http/message_body_sink_test.cpp b/be/test/http/message_body_sink_test.cpp index 421308dfbc..99ec61a0e4 100644 --- a/be/test/http/message_body_sink_test.cpp +++ b/be/test/http/message_body_sink_test.cpp @@ -39,25 +39,20 @@ TEST_F(MessageBodySinkTest, file_sink) { char data[] = "hello world"; MessageBodyFileSink sink("./body_sink_test_file_sink"); - ASSERT_TRUE(sink.open().ok()); - ASSERT_TRUE(sink.append(data, sizeof(data)).ok()); - ASSERT_TRUE(sink.finish().ok()); + EXPECT_TRUE(sink.open().ok()); + EXPECT_TRUE(sink.append(data, sizeof(data)).ok()); + EXPECT_TRUE(sink.finish().ok()); { char buf[256]; memset(buf, 0, 256); int fd = open("././body_sink_test_file_sink", O_RDONLY); auto readed_size = read(fd, buf, 256); - ASSERT_NE(readed_size, -1); + EXPECT_NE(readed_size, -1); close(fd); - ASSERT_STREQ("hello world", buf); + EXPECT_STREQ("hello world", buf); unlink("././body_sink_test_file_sink"); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/http/metrics_action_test.cpp b/be/test/http/metrics_action_test.cpp index d91e8dd91c..ec8f2c1d84 100644 --- a/be/test/http/metrics_action_test.cpp +++ b/be/test/http/metrics_action_test.cpp @@ -30,7 +30,7 @@ namespace doris { const char* s_expect_response = nullptr; void HttpChannel::send_reply(HttpRequest* request, HttpStatus status, const std::string& content) { - ASSERT_STREQ(s_expect_response, content.c_str()); + EXPECT_STREQ(s_expect_response, content.c_str()); } class MetricsActionTest : public testing::Test { @@ -95,8 +95,3 @@ TEST_F(MetricsActionTest, prometheus_no_prefix) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/http/stream_load_test.cpp b/be/test/http/stream_load_test.cpp index 369af31834..587bbfbd20 100644 --- a/be/test/http/stream_load_test.cpp +++ b/be/test/http/stream_load_test.cpp @@ -114,40 +114,9 @@ TEST_F(StreamLoadActionTest, no_auth) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } -#if 0 -TEST_F(StreamLoadActionTest, no_content_length) { - StreamLoadAction action(&__env); - - HttpRequest request(_evhttp_req); - request._headers.emplace(HttpHeaders::AUTHORIZATION, "Basic cm9vdDo="); - request.set_handler(&action); - action.on_header(&request); - action.handle(&request); - - rapidjson::Document doc; - doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); -} - -TEST_F(StreamLoadActionTest, unknown_encoding) { - StreamLoadAction action(&_env); - - HttpRequest request(_evhttp_req); - request._headers.emplace(HttpHeaders::AUTHORIZATION, "Basic cm9vdDo="); - request._headers.emplace(HttpHeaders::TRANSFER_ENCODING, "chunked111"); - request.set_handler(&action); - action.on_header(&request); - action.handle(&request); - - rapidjson::Document doc; - doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); -} -#endif - TEST_F(StreamLoadActionTest, normal) { StreamLoadAction action(&_env); @@ -165,7 +134,7 @@ TEST_F(StreamLoadActionTest, normal) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Success", doc["Status"].GetString()); + EXPECT_STREQ("Success", doc["Status"].GetString()); } TEST_F(StreamLoadActionTest, put_fail) { @@ -187,7 +156,7 @@ TEST_F(StreamLoadActionTest, put_fail) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } TEST_F(StreamLoadActionTest, commit_fail) { @@ -207,7 +176,7 @@ TEST_F(StreamLoadActionTest, commit_fail) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } TEST_F(StreamLoadActionTest, begin_fail) { @@ -227,7 +196,7 @@ TEST_F(StreamLoadActionTest, begin_fail) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } #if 0 @@ -243,7 +212,7 @@ TEST_F(StreamLoadActionTest, receive_failed) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } #endif @@ -263,13 +232,7 @@ TEST_F(StreamLoadActionTest, plan_fail) { rapidjson::Document doc; doc.Parse(k_response_str.c_str()); - ASSERT_STREQ("Fail", doc["Status"].GetString()); + EXPECT_STREQ("Fail", doc["Status"].GetString()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/CMakeLists.txt b/be/test/olap/CMakeLists.txt deleted file mode 100644 index d461c69c63..0000000000 --- a/be/test/olap/CMakeLists.txt +++ /dev/null @@ -1,93 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/olap") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/olap") - -ADD_BE_TEST(timestamped_version_tracker_test) -ADD_BE_TEST(row_block_test) -ADD_BE_TEST(row_block_v2_test) -ADD_BE_TEST(bit_field_test) -ADD_BE_TEST(byte_buffer_test) -ADD_BE_TEST(engine_storage_migration_task_test) -ADD_BE_TEST(run_length_byte_test) -ADD_BE_TEST(run_length_integer_test) -ADD_BE_TEST(stream_index_test) -ADD_BE_TEST(lru_cache_test) -ADD_BE_TEST(bloom_filter_test) -ADD_BE_TEST(bloom_filter_column_predicate_test) -ADD_BE_TEST(bloom_filter_index_test) -ADD_BE_TEST(comparison_predicate_test) -ADD_BE_TEST(in_list_predicate_test) -ADD_BE_TEST(null_predicate_test) -ADD_BE_TEST(file_helper_test) -ADD_BE_TEST(file_utils_test) -ADD_BE_TEST(delete_handler_test) -ADD_BE_TEST(column_reader_test) -ADD_BE_TEST(cumulative_compaction_policy_test) -ADD_BE_TEST(schema_change_test) -ADD_BE_TEST(row_cursor_test) -ADD_BE_TEST(skiplist_test) -ADD_BE_TEST(delta_writer_test) -ADD_BE_TEST(serialize_test) -ADD_BE_TEST(olap_meta_test) -ADD_BE_TEST(decimal12_test) -ADD_BE_TEST(column_vector_test) -ADD_BE_TEST(storage_types_test) -ADD_BE_TEST(aggregate_func_test) -ADD_BE_TEST(rowset/segment_v2/bitshuffle_page_test) -ADD_BE_TEST(rowset/segment_v2/plain_page_test) -ADD_BE_TEST(rowset/segment_v2/binary_plain_page_test) -ADD_BE_TEST(rowset/segment_v2/binary_prefix_page_test) -ADD_BE_TEST(rowset/segment_v2/bitmap_index_test) -ADD_BE_TEST(rowset/segment_v2/column_reader_writer_test) -ADD_BE_TEST(rowset/segment_v2/encoding_info_test) -ADD_BE_TEST(rowset/segment_v2/ordinal_page_index_test) -ADD_BE_TEST(rowset/segment_v2/rle_page_test) -ADD_BE_TEST(rowset/segment_v2/binary_dict_page_test) -ADD_BE_TEST(rowset/segment_v2/segment_test) -ADD_BE_TEST(rowset/segment_v2/row_ranges_test) -ADD_BE_TEST(rowset/segment_v2/frame_of_reference_page_test) -ADD_BE_TEST(rowset/segment_v2/block_bloom_filter_test) -ADD_BE_TEST(rowset/segment_v2/bloom_filter_index_reader_writer_test) -ADD_BE_TEST(rowset/segment_v2/zone_map_index_test) -ADD_BE_TEST(tablet_meta_test) -ADD_BE_TEST(tablet_meta_manager_test) -ADD_BE_TEST(tablet_mgr_test) -ADD_BE_TEST(tablet_test) -ADD_BE_TEST(rowset/rowset_meta_manager_test) -ADD_BE_TEST(rowset/rowset_meta_test) -ADD_BE_TEST(rowset/alpha_rowset_test) -ADD_BE_TEST(rowset/beta_rowset_test) -ADD_BE_TEST(rowset/unique_rowset_id_generator_test) -ADD_BE_TEST(rowset/rowset_converter_test) -ADD_BE_TEST(txn_manager_test) -ADD_BE_TEST(generic_iterators_test) -ADD_BE_TEST(key_coder_test) -ADD_BE_TEST(short_key_index_test) -ADD_BE_TEST(page_cache_test) -ADD_BE_TEST(hll_test) -# ADD_BE_TEST(memtable_flush_executor_test) -ADD_BE_TEST(selection_vector_test) -ADD_BE_TEST(block_column_predicate_test) -ADD_BE_TEST(options_test) -ADD_BE_TEST(fs/file_block_manager_test) -#ADD_BE_TEST(push_handler_test) -ADD_BE_TEST(common_test) diff --git a/be/test/olap/aggregate_func_test.cpp b/be/test/olap/aggregate_func_test.cpp index 0d784cd359..42a80eee8f 100644 --- a/be/test/olap/aggregate_func_test.cpp +++ b/be/test/olap/aggregate_func_test.cpp @@ -50,7 +50,7 @@ void test_min() { char val_buf[kValSize]; *(bool*)val_buf = true; agg->init(&dst, val_buf, true, mem_pool.get(), &agg_object_pool); - ASSERT_TRUE(*(bool*)(buf)); + EXPECT_TRUE(*(bool*)(buf)); } // 100 { @@ -59,9 +59,9 @@ void test_min() { CppType val = 100; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(100, val); + EXPECT_EQ(100, val); } // 200 { @@ -70,9 +70,9 @@ void test_min() { CppType val = 200; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(100, val); + EXPECT_EQ(100, val); } // 50 { @@ -81,26 +81,26 @@ void test_min() { CppType val = 50; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(50, val); + EXPECT_EQ(50, val); } // null { char val_buf[kValSize]; *(bool*)val_buf = true; agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(val_buf + 1, &val, sizeof(CppType)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(50, val); + EXPECT_EQ(50, val); } agg->finalize(&dst, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(50, val); + EXPECT_EQ(50, val); } TEST_F(AggregateFuncTest, min) { @@ -126,7 +126,7 @@ void test_max() { char val_buf[kValSize]; *(bool*)val_buf = true; agg->init(&dst, val_buf, true, mem_pool.get(), &agg_object_pool); - ASSERT_TRUE(*(bool*)(buf)); + EXPECT_TRUE(*(bool*)(buf)); } // 100 { @@ -135,9 +135,9 @@ void test_max() { CppType val = 100; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(100, val); + EXPECT_EQ(100, val); } // 200 { @@ -146,9 +146,9 @@ void test_max() { CppType val = 200; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(200, val); + EXPECT_EQ(200, val); } // 50 { @@ -157,25 +157,25 @@ void test_max() { CppType val = 50; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(200, val); + EXPECT_EQ(200, val); } // null { char val_buf[kValSize]; *(bool*)val_buf = true; agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(200, val); + EXPECT_EQ(200, val); } agg->finalize(&dst, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(200, val); + EXPECT_EQ(200, val); } TEST_F(AggregateFuncTest, max) { @@ -201,7 +201,7 @@ void test_sum() { char val_buf[kValSize]; *(bool*)val_buf = true; agg->init(&dst, val_buf, true, mem_pool.get(), &agg_object_pool); - ASSERT_TRUE(*(bool*)(buf)); + EXPECT_TRUE(*(bool*)(buf)); } // 100 { @@ -210,9 +210,9 @@ void test_sum() { CppType val = 100; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(100, val); + EXPECT_EQ(100, val); } // 200 { @@ -221,9 +221,9 @@ void test_sum() { CppType val = 200; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(300, val); + EXPECT_EQ(300, val); } // 50 { @@ -232,25 +232,25 @@ void test_sum() { CppType val = 50; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(350, val); + EXPECT_EQ(350, val); } // null { char val_buf[kValSize]; *(bool*)val_buf = true; agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(350, val); + EXPECT_EQ(350, val); } agg->finalize(&dst, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(350, val); + EXPECT_EQ(350, val); } TEST_F(AggregateFuncTest, sum) { @@ -276,7 +276,7 @@ void test_replace() { char val_buf[kValSize]; *(bool*)val_buf = true; agg->init(&dst, val_buf, true, mem_pool.get(), &agg_object_pool); - ASSERT_TRUE(*(bool*)(buf)); + EXPECT_TRUE(*(bool*)(buf)); } // 100 { @@ -285,16 +285,16 @@ void test_replace() { CppType val = 100; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(100, val); + EXPECT_EQ(100, val); } // null { char val_buf[kValSize]; *(bool*)val_buf = true; agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_TRUE(*(bool*)(buf)); + EXPECT_TRUE(*(bool*)(buf)); } // 50 { @@ -303,15 +303,15 @@ void test_replace() { CppType val = 50; memcpy(val_buf + 1, &val, sizeof(CppType)); agg->update(&dst, val_buf, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(50, val); + EXPECT_EQ(50, val); } agg->finalize(&dst, mem_pool.get()); - ASSERT_FALSE(*(bool*)(buf)); + EXPECT_FALSE(*(bool*)(buf)); CppType val; memcpy(&val, buf + 1, sizeof(CppType)); - ASSERT_EQ(50, val); + EXPECT_EQ(50, val); } template @@ -337,7 +337,7 @@ void test_replace_string() { { src_cell.set_null(); agg->init(&dst_cell, (const char*)src_slice, true, mem_pool.get(), &agg_object_pool); - ASSERT_TRUE(dst_cell.is_null()); + EXPECT_TRUE(dst_cell.is_null()); } // "12345" { @@ -345,9 +345,9 @@ void test_replace_string() { src_slice->data = (char*)"1234567890"; src_slice->size = 10; agg->update(&dst_cell, src_cell, mem_pool.get()); - ASSERT_FALSE(dst_cell.is_null()); - ASSERT_EQ(10, dst_slice->size); - ASSERT_STREQ("1234567890", dst_slice->to_string().c_str()); + EXPECT_FALSE(dst_cell.is_null()); + EXPECT_EQ(10, dst_slice->size); + EXPECT_STREQ("1234567890", dst_slice->to_string().c_str()); } // abc { @@ -355,15 +355,15 @@ void test_replace_string() { src_slice->data = (char*)"abc"; src_slice->size = 3; agg->update(&dst_cell, src_cell, mem_pool.get()); - ASSERT_FALSE(dst_cell.is_null()); - ASSERT_EQ(3, dst_slice->size); - ASSERT_STREQ("abc", dst_slice->to_string().c_str()); + EXPECT_FALSE(dst_cell.is_null()); + EXPECT_EQ(3, dst_slice->size); + EXPECT_STREQ("abc", dst_slice->to_string().c_str()); } // null { src_cell.set_null(); agg->update(&dst_cell, src_cell, mem_pool.get()); - ASSERT_TRUE(dst_cell.is_null()); + EXPECT_TRUE(dst_cell.is_null()); } // "12345" { @@ -371,15 +371,15 @@ void test_replace_string() { src_slice->data = (char*)"12345"; src_slice->size = 5; agg->update(&dst_cell, src_cell, mem_pool.get()); - ASSERT_FALSE(dst_cell.is_null()); - ASSERT_EQ(5, dst_slice->size); - ASSERT_STREQ("12345", dst_slice->to_string().c_str()); + EXPECT_FALSE(dst_cell.is_null()); + EXPECT_EQ(5, dst_slice->size); + EXPECT_STREQ("12345", dst_slice->to_string().c_str()); } agg->finalize(&dst_cell, mem_pool.get()); - ASSERT_FALSE(dst_cell.is_null()); - ASSERT_EQ(5, dst_slice->size); - ASSERT_STREQ("12345", dst_slice->to_string().c_str()); + EXPECT_FALSE(dst_cell.is_null()); + EXPECT_EQ(5, dst_slice->size); + EXPECT_STREQ("12345", dst_slice->to_string().c_str()); } TEST_F(AggregateFuncTest, replace) { @@ -390,8 +390,3 @@ TEST_F(AggregateFuncTest, replace) { } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/bit_field_test.cpp b/be/test/olap/bit_field_test.cpp index a45a6125a0..1b019db2c5 100644 --- a/be/test/olap/bit_field_test.cpp +++ b/be/test/olap/bit_field_test.cpp @@ -33,12 +33,12 @@ public: virtual ~TestBitField() {} void SetUp() { - ASSERT_EQ(system("mkdir -p ./ut_dir/"), 0); - ASSERT_EQ(system("rm ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir/"), 0); + EXPECT_EQ(system("rm ./ut_dir/tmp_file"), 0); _out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(_out_stream != nullptr); + EXPECT_TRUE(_out_stream != nullptr); _writer = new (std::nothrow) BitFieldWriter(_out_stream); - ASSERT_TRUE(_writer != nullptr); + EXPECT_TRUE(_writer != nullptr); _writer->init(); } @@ -51,26 +51,26 @@ public: } void CreateReader() { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, _helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&_helper, 0); _helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, _helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); _stream = new (std::nothrow) ReadOnlyFileStream(&_helper, &_shared_buffer, 0, _helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - ASSERT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(OLAP_SUCCESS, _stream->init()); _reader = new (std::nothrow) BitFieldReader(_stream); - ASSERT_TRUE(_reader != nullptr); + EXPECT_TRUE(_reader != nullptr); _reader->init(); } @@ -87,38 +87,38 @@ public: TEST_F(TestBitField, ReadWriteOneBit) { // write data - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); char value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 1); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 1); } TEST_F(TestBitField, ReadWriteMultiBits) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); } else { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); } } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); char value = 0; for (int32_t i = 0; i < 100; i++) { - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); if (0 == i % 2) { - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); } else { - ASSERT_EQ(value, 0); + EXPECT_EQ(value, 0); } } } @@ -127,17 +127,17 @@ TEST_F(TestBitField, Seek) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); } else { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); } } PositionEntryWriter index_entry; _writer->get_position(&index_entry); - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); @@ -150,45 +150,31 @@ TEST_F(TestBitField, Seek) { PositionProvider position(&entry); _reader->seek(&position); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 1); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 1); } TEST_F(TestBitField, Skip) { // write data for (int32_t i = 0; i < 100; i++) { if (0 == i % 2) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); } else { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(false)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(false)); } } - ASSERT_EQ(OLAP_SUCCESS, _writer->write(true)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(true)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); char value = 0; _reader->skip(100); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 1); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 1); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/block_column_predicate_test.cpp b/be/test/olap/block_column_predicate_test.cpp index 0e3e17dfaa..d4ec71834d 100644 --- a/be/test/olap/block_column_predicate_test.cpp +++ b/be/test/olap/block_column_predicate_test.cpp @@ -20,8 +20,8 @@ #include #include -#include "olap/comparison_predicate.h" #include "olap/column_predicate.h" +#include "olap/comparison_predicate.h" #include "olap/field.h" #include "olap/row_block2.h" #include "olap/wrapper_field.h" @@ -42,12 +42,12 @@ public: ~BlockColumnPredicateTest() = default; - void SetTabletSchema(std::string name, const std::string &type, - const std::string &aggregation, uint32_t length, bool is_allow_null, - bool is_key, TabletSchema *tablet_schema) { + void SetTabletSchema(std::string name, const std::string& type, const std::string& aggregation, + uint32_t length, bool is_allow_null, bool is_key, + TabletSchema* tablet_schema) { TabletSchemaPB tablet_schema_pb; static int id = 0; - ColumnPB *column = tablet_schema_pb.add_column(); + ColumnPB* column = tablet_schema_pb.add_column(); column->set_unique_id(++id); column->set_name(name); column->set_type(type); @@ -61,7 +61,7 @@ public: tablet_schema->init_from_pb(tablet_schema_pb); } - void init_row_block(const TabletSchema *tablet_schema, int size) { + void init_row_block(const TabletSchema* tablet_schema, int size) { Schema schema(*tablet_schema); _row_block.reset(new RowBlockV2(schema, size)); } @@ -90,11 +90,11 @@ TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN) { ColumnBlockView col_block_view(&col_block); for (int i = 0; i < size; ++i, col_block_view.advance(1)) { col_block_view.set_null_bits(1, false); - *reinterpret_cast(col_block_view.data()) = i; + *reinterpret_cast(col_block_view.data()) = i; } single_column_block_pred.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_FLOAT_EQ(*(float *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); + EXPECT_EQ(select_size, 1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); } TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN_VEC) { @@ -106,7 +106,7 @@ TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN_VEC) { int col_idx = 0; std::unique_ptr pred(new EqualPredicate(col_idx, value)); SingleColumnBlockPredicate single_column_block_pred(pred.get()); - + uint16_t sel_idx[rows]; uint16_t selected_size = rows; block[col_idx]->reserve(rows); @@ -117,12 +117,11 @@ TEST_F(BlockColumnPredicateTest, SINGLE_COLUMN_VEC) { } single_column_block_pred.evaluate(block, sel_idx, &selected_size); - ASSERT_EQ(selected_size, 1); + EXPECT_EQ(selected_size, 1); auto* pred_col = reinterpret_cast*>(block[col_idx].get()); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], value); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], value); } - TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN) { TabletSchema tablet_schema; SetTabletSchema(std::string("DOUBLE_COLUMN"), "DOUBLE", "REPLACE", 1, true, true, @@ -149,11 +148,11 @@ TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN) { ColumnBlockView col_block_view(&col_block); for (int i = 0; i < size; ++i, col_block_view.advance(1)) { col_block_view.set_null_bits(1, false); - *reinterpret_cast(col_block_view.data()) = i; + *reinterpret_cast(col_block_view.data()) = i; } and_block_column_pred.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); } TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN_VEC) { @@ -172,7 +171,7 @@ TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN_VEC) { AndBlockColumnPredicate and_block_column_pred; and_block_column_pred.add_column_predicate(single_less_pred); and_block_column_pred.add_column_predicate(single_great_pred); - + uint16_t sel_idx[rows]; uint16_t selected_size = rows; block[col_idx]->reserve(rows); @@ -183,9 +182,9 @@ TEST_F(BlockColumnPredicateTest, AND_MUTI_COLUMN_VEC) { } and_block_column_pred.evaluate(block, sel_idx, &selected_size); - ASSERT_EQ(selected_size, 1); + EXPECT_EQ(selected_size, 1); auto* pred_col = reinterpret_cast*>(block[col_idx].get()); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 4); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 4); } TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN) { @@ -204,7 +203,6 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN) { auto single_less_pred = new SingleColumnBlockPredicate(less_pred.get()); auto single_great_pred = new SingleColumnBlockPredicate(great_pred.get()); - OrBlockColumnPredicate or_block_column_pred; or_block_column_pred.add_column_predicate(single_less_pred); or_block_column_pred.add_column_predicate(single_great_pred); @@ -215,11 +213,11 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN) { ColumnBlockView col_block_view(&col_block); for (int i = 0; i < size; ++i, col_block_view.advance(1)) { col_block_view.set_null_bits(1, false); - *reinterpret_cast(col_block_view.data()) = i; + *reinterpret_cast(col_block_view.data()) = i; } or_block_column_pred.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 10); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); + EXPECT_EQ(select_size, 10); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); } TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN_VEC) { @@ -238,7 +236,7 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN_VEC) { OrBlockColumnPredicate or_block_column_pred; or_block_column_pred.add_column_predicate(single_less_pred); or_block_column_pred.add_column_predicate(single_great_pred); - + uint16_t sel_idx[rows]; uint16_t selected_size = rows; block[col_idx]->reserve(rows); @@ -249,9 +247,9 @@ TEST_F(BlockColumnPredicateTest, OR_MUTI_COLUMN_VEC) { } or_block_column_pred.evaluate(block, sel_idx, &selected_size); - ASSERT_EQ(selected_size, 10); + EXPECT_EQ(selected_size, 10); auto* pred_col = reinterpret_cast*>(block[col_idx].get()); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 0); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 0); } TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN) { @@ -275,7 +273,7 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN) { ColumnBlockView col_block_view(&col_block); for (int i = 0; i < size; ++i, col_block_view.advance(1)) { col_block_view.set_null_bits(1, false); - *reinterpret_cast(col_block_view.data()) = i; + *reinterpret_cast(col_block_view.data()) = i; } // Test for and or single @@ -289,11 +287,11 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN) { or_block_column_pred.add_column_predicate(new SingleColumnBlockPredicate(less_pred1.get())); or_block_column_pred.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 4); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 1.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 2.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[3]).cell_ptr(), 4.0); + EXPECT_EQ(select_size, 4); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 1.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 2.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[3]).cell_ptr(), 4.0); _row_block->clear(); select_size = _row_block->selected_size(); @@ -308,11 +306,11 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN) { or_block_column_pred1.add_column_predicate(and_block_column_pred1); or_block_column_pred1.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 4); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 1.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 2.0); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[3]).cell_ptr(), 4.0); + EXPECT_EQ(select_size, 4); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 0.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 1.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 2.0); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[3]).cell_ptr(), 4.0); } TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) { @@ -336,7 +334,7 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) { OrBlockColumnPredicate or_block_column_pred; or_block_column_pred.add_column_predicate(and_block_column_pred); or_block_column_pred.add_column_predicate(new SingleColumnBlockPredicate(less_pred1.get())); - + uint16_t sel_idx[rows]; uint16_t selected_size = rows; block[col_idx]->reserve(rows); @@ -347,12 +345,12 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) { } or_block_column_pred.evaluate(block, sel_idx, &selected_size); - ASSERT_EQ(selected_size, 4); + EXPECT_EQ(selected_size, 4); auto* pred_col = reinterpret_cast*>(block[col_idx].get()); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 0); - ASSERT_EQ(pred_col->get_data()[sel_idx[1]], 1); - ASSERT_EQ(pred_col->get_data()[sel_idx[2]], 2); - ASSERT_EQ(pred_col->get_data()[sel_idx[3]], 4); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 0); + EXPECT_EQ(pred_col->get_data()[sel_idx[1]], 1); + EXPECT_EQ(pred_col->get_data()[sel_idx[2]], 2); + EXPECT_EQ(pred_col->get_data()[sel_idx[3]], 4); // Test for single or and // column < 3 or (column < 5 and column > 3) @@ -365,11 +363,11 @@ TEST_F(BlockColumnPredicateTest, OR_AND_MUTI_COLUMN_VEC) { or_block_column_pred1.add_column_predicate(and_block_column_pred1); or_block_column_pred1.evaluate(block, sel_idx, &selected_size); - ASSERT_EQ(selected_size, 4); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 0); - ASSERT_EQ(pred_col->get_data()[sel_idx[1]], 1); - ASSERT_EQ(pred_col->get_data()[sel_idx[2]], 2); - ASSERT_EQ(pred_col->get_data()[sel_idx[3]], 4); + EXPECT_EQ(selected_size, 4); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 0); + EXPECT_EQ(pred_col->get_data()[sel_idx[1]], 1); + EXPECT_EQ(pred_col->get_data()[sel_idx[2]], 2); + EXPECT_EQ(pred_col->get_data()[sel_idx[3]], 4); } TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN) { @@ -393,7 +391,7 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN) { ColumnBlockView col_block_view(&col_block); for (int i = 0; i < size; ++i, col_block_view.advance(1)) { col_block_view.set_null_bits(1, false); - *reinterpret_cast(col_block_view.data()) = i; + *reinterpret_cast(col_block_view.data()) = i; } // Test for and or single @@ -407,8 +405,8 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN) { and_block_column_pred.add_column_predicate(new SingleColumnBlockPredicate(great_pred.get())); and_block_column_pred.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); _row_block->clear(); select_size = _row_block->selected_size(); @@ -423,8 +421,8 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN) { and_block_column_pred1.add_column_predicate(or_block_column_pred1); and_block_column_pred1.evaluate(_row_block.get(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double *) col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.0); } TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) { @@ -448,7 +446,7 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) { AndBlockColumnPredicate and_block_column_pred; and_block_column_pred.add_column_predicate(or_block_column_pred); and_block_column_pred.add_column_predicate(new SingleColumnBlockPredicate(great_pred.get())); - + uint16_t sel_idx[rows]; uint16_t selected_size = rows; block[col_idx]->reserve(rows); @@ -461,8 +459,8 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) { and_block_column_pred.evaluate(block, sel_idx, &selected_size); auto* pred_col = reinterpret_cast*>(block[col_idx].get()); - ASSERT_EQ(selected_size, 1); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 4); + EXPECT_EQ(selected_size, 1); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 4); // Test for single or and // column > 3 and (column < 5 or column < 3) @@ -474,17 +472,8 @@ TEST_F(BlockColumnPredicateTest, AND_OR_MUTI_COLUMN_VEC) { and_block_column_pred1.add_column_predicate(new SingleColumnBlockPredicate(great_pred.get())); and_block_column_pred1.add_column_predicate(or_block_column_pred1); - ASSERT_EQ(selected_size, 1); - ASSERT_EQ(pred_col->get_data()[sel_idx[0]], 4); + EXPECT_EQ(selected_size, 1); + EXPECT_EQ(pred_col->get_data()[sel_idx[0]], 4); } -} - -int main(int argc, char** argv) { - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} +} // namespace doris diff --git a/be/test/olap/bloom_filter_column_predicate_test.cpp b/be/test/olap/bloom_filter_column_predicate_test.cpp index dcf637eefe..1043e58c44 100644 --- a/be/test/olap/bloom_filter_column_predicate_test.cpp +++ b/be/test/olap/bloom_filter_column_predicate_test.cpp @@ -95,7 +95,8 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { return_columns.push_back(i); } - std::shared_ptr bloom_filter(create_bloom_filter(PrimitiveType::TYPE_FLOAT)); + std::shared_ptr bloom_filter( + create_bloom_filter(PrimitiveType::TYPE_FLOAT)); bloom_filter->init(4096, 0.05); float value = 4.1; @@ -117,11 +118,11 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { *(col_data + i) = i + 0.1f; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 10); + EXPECT_EQ(_vectorized_batch->size(), 10); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 0.1); - ASSERT_FLOAT_EQ(*(col_data + sel[1]), 1.1); - ASSERT_FLOAT_EQ(*(col_data + sel[2]), 2.1); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 0.1); + EXPECT_FLOAT_EQ(*(col_data + sel[1]), 1.1); + EXPECT_FLOAT_EQ(*(col_data + sel[2]), 2.1); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -133,10 +134,10 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { *reinterpret_cast(col_block_view.data()) = i + 0.1f; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); + EXPECT_EQ(select_size, 3); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -153,11 +154,11 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 10); + EXPECT_EQ(_vectorized_batch->size(), 10); sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 0.1); - ASSERT_FLOAT_EQ(*(col_data + sel[1]), 1.1); - ASSERT_FLOAT_EQ(*(col_data + sel[2]), 2.1); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 0.1); + EXPECT_FLOAT_EQ(*(col_data + sel[1]), 1.1); + EXPECT_FLOAT_EQ(*(col_data + sel[2]), 2.1); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -172,8 +173,8 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); + EXPECT_EQ(select_size, 1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); // for vectorized::Block no null auto pred_col = PredicateColumnType::create(); @@ -185,10 +186,10 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(*pred_col, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[0]], 4.1); - ASSERT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[1]], 5.1); - ASSERT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[2]], 6.1); + EXPECT_EQ(select_size, 3); + EXPECT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[0]], 4.1); + EXPECT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[1]], 5.1); + EXPECT_FLOAT_EQ((float)pred_col->get_data()[_row_block->selection_vector()[2]], 6.1); // for vectorized::Block has nulls auto null_map = ColumnUInt8::create(size, 0); @@ -201,27 +202,12 @@ TEST_F(TestBloomFilterColumnPredicate, FLOAT_COLUMN) { auto nullable_col = vectorized::ColumnNullable::create(std::move(pred_col), std::move(null_map)); pred->evaluate(*nullable_col, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); + EXPECT_EQ(select_size, 1); auto nested_col = check_and_get_column>( nullable_col->get_nested_column()); - ASSERT_FLOAT_EQ((float)nested_col->get_data()[_row_block->selection_vector()[0]], 5.1); + EXPECT_FLOAT_EQ((float)nested_col->get_data()[_row_block->selection_vector()[0]], 5.1); delete pred; } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/bloom_filter_index_test.cpp b/be/test/olap/bloom_filter_index_test.cpp index 93d1b63b94..02a9e32f0b 100644 --- a/be/test/olap/bloom_filter_index_test.cpp +++ b/be/test/olap/bloom_filter_index_test.cpp @@ -55,34 +55,34 @@ TEST_F(TestBloomFilterIndex, normal_read_and_write) { writer.add_bloom_filter(bf_1); uint64_t expect_size = sizeof(BloomFilterIndexHeader) + bf_0->bit_num() * 2 / 8; - ASSERT_EQ(expect_size, writer.estimate_buffered_memory()); + EXPECT_EQ(expect_size, writer.estimate_buffered_memory()); char buffer[expect_size]; memset(buffer, 0, expect_size); - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, expect_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, expect_size)); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, expect_size, true, bf_0->hash_function_num(), bf_0->bit_num())); - ASSERT_EQ(2, reader.entry_count()); + EXPECT_EQ(2, reader.entry_count()); bytes = "hello"; const BloomFilter& bf__0 = reader.entry(0); - ASSERT_TRUE(bf__0.test_bytes(nullptr, 0)); - ASSERT_TRUE(bf__0.test_bytes(bytes.c_str(), bytes.size())); + EXPECT_TRUE(bf__0.test_bytes(nullptr, 0)); + EXPECT_TRUE(bf__0.test_bytes(bytes.c_str(), bytes.size())); bytes = "doris"; const BloomFilter& bf__1 = reader.entry(1); - ASSERT_TRUE(bf__1.test_bytes(bytes.c_str(), bytes.size())); + EXPECT_TRUE(bf__1.test_bytes(bytes.c_str(), bytes.size())); } // Test abnormal write case TEST_F(TestBloomFilterIndex, abnormal_write) { char buffer[24]; BloomFilterIndexWriter writer; - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr)); - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr, 0)); - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(buffer, 0)); - ASSERT_EQ(sizeof(BloomFilterIndexHeader), writer.estimate_buffered_memory()); + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr)); + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(nullptr, 0)); + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, writer.write_to_buffer(buffer, 0)); + EXPECT_EQ(sizeof(BloomFilterIndexHeader), writer.estimate_buffered_memory()); } // Test abnormal read case @@ -95,16 +95,11 @@ TEST_F(TestBloomFilterIndex, abnormal_read) { BloomFilterIndexReader reader; header->block_count = 1; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); header->block_count = 3; - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, reader.init(buffer, buffer_size, true, hash_function_num, bit_num)); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/bloom_filter_test.cpp b/be/test/olap/bloom_filter_test.cpp index 2275503206..8d25b9eabf 100644 --- a/be/test/olap/bloom_filter_test.cpp +++ b/be/test/olap/bloom_filter_test.cpp @@ -42,22 +42,22 @@ TEST_F(TestBloomFilter, init_bloom_filter) { { BloomFilter bf; bf.init(1024); - ASSERT_EQ(6400, bf.bit_num()); - ASSERT_EQ(4, bf.hash_function_num()); + EXPECT_EQ(6400, bf.bit_num()); + EXPECT_EQ(4, bf.hash_function_num()); } { BloomFilter bf; bf.init(1024, 0.01); - ASSERT_EQ(9856, bf.bit_num()); - ASSERT_EQ(7, bf.hash_function_num()); + EXPECT_EQ(9856, bf.bit_num()); + EXPECT_EQ(7, bf.hash_function_num()); } { BloomFilter bf; bf.init(10240, 0.1); - ASSERT_EQ(49088, bf.bit_num()); - ASSERT_EQ(3, bf.hash_function_num()); + EXPECT_EQ(49088, bf.bit_num()); + EXPECT_EQ(3, bf.hash_function_num()); } { @@ -67,14 +67,14 @@ TEST_F(TestBloomFilter, init_bloom_filter) { uint64_t* data = new uint64_t[data_len]; bf.init(data, data_len, hash_function_num); - ASSERT_EQ(6400, bf.bit_num()); - ASSERT_EQ(4, bf.hash_function_num()); - ASSERT_EQ(data, bf.bit_set_data()); + EXPECT_EQ(6400, bf.bit_num()); + EXPECT_EQ(4, bf.hash_function_num()); + EXPECT_EQ(data, bf.bit_set_data()); bf.reset(); - ASSERT_EQ(0, bf.bit_num()); - ASSERT_EQ(0, bf.hash_function_num()); - ASSERT_EQ(nullptr, bf.bit_set_data()); + EXPECT_EQ(0, bf.bit_num()); + EXPECT_EQ(0, bf.hash_function_num()); + EXPECT_EQ(nullptr, bf.bit_set_data()); delete[] data; } } @@ -86,23 +86,23 @@ TEST_F(TestBloomFilter, add_and_test_bytes) { bf.init(1024); bf.add_bytes(nullptr, 0); - ASSERT_TRUE(bf.test_bytes(nullptr, 0)); + EXPECT_TRUE(bf.test_bytes(nullptr, 0)); bytes = "hello"; bf.add_bytes(bytes.c_str(), bytes.size()); - ASSERT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); + EXPECT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); bytes = "doris"; bf.add_bytes(bytes.c_str(), bytes.size()); - ASSERT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); + EXPECT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); BloomFilter new_bf; new_bf.init(1024); bytes = "world"; new_bf.add_bytes(bytes.c_str(), bytes.size()); - ASSERT_TRUE(bf.merge(new_bf)); - ASSERT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); + EXPECT_TRUE(bf.merge(new_bf)); + EXPECT_TRUE(bf.test_bytes(bytes.c_str(), bytes.size())); } // Print bloom filter buffer and points of specified string @@ -117,11 +117,11 @@ TEST_F(TestBloomFilter, bloom_filter_info) { "bit_num:64 hash_function_num:6 " "bit_set:0000100000000000100000010000000000010000001000000000000000000100"; string buffer = bf.to_string(); - ASSERT_TRUE(buffer_expect == buffer); + EXPECT_TRUE(buffer_expect == buffer); string points_expect = "4-23-42-61-16-35"; string points = bf.get_bytes_points_string(bytes.c_str(), bytes.size()); - ASSERT_TRUE(points_expect == points); + EXPECT_TRUE(points_expect == points); bytes = "a"; points = bf.get_bytes_points_string(bytes.c_str(), bytes.size()); @@ -157,8 +157,3 @@ TEST_F(TestBloomFilter, bloom_filter_info) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/byte_buffer_test.cpp b/be/test/olap/byte_buffer_test.cpp index 340e7ddea9..eb6cf680d1 100644 --- a/be/test/olap/byte_buffer_test.cpp +++ b/be/test/olap/byte_buffer_test.cpp @@ -34,7 +34,7 @@ public: virtual void SetUp() {} virtual void TearDown() { if (std::filesystem::exists(".test_byte_buffer")) { - ASSERT_TRUE(std::filesystem::remove_all(".test_byte_buffer")); + EXPECT_TRUE(std::filesystem::remove_all(".test_byte_buffer")); } } }; @@ -44,27 +44,27 @@ TEST_F(TestByteBuffer, TestReadWrite) { StorageByteBuffer* buf1 = nullptr; buf1 = StorageByteBuffer::create(100); - ASSERT_TRUE(buf1 != nullptr); + EXPECT_TRUE(buf1 != nullptr); char in[10] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}; for (int i = 0; i < 5; i++) { - ASSERT_EQ(OLAP_SUCCESS, buf1->put(in, sizeof(in))); - ASSERT_EQ(100u - (i + 1) * sizeof(in), buf1->remaining()); - ASSERT_EQ((i + 1) * sizeof(in), buf1->position()); + EXPECT_EQ(OLAP_SUCCESS, buf1->put(in, sizeof(in))); + EXPECT_EQ(100u - (i + 1) * sizeof(in), buf1->remaining()); + EXPECT_EQ((i + 1) * sizeof(in), buf1->position()); } // 参数错误的指定写 - ASSERT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->put(in, sizeof(in), 5, 10)); + EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->put(in, sizeof(in), 5, 10)); for (int i = 0; i < 50; i++) { - ASSERT_EQ(OLAP_SUCCESS, buf1->put(i)); - ASSERT_EQ(50u - (i + 1), buf1->remaining()); - ASSERT_EQ(50u + i + 1, buf1->position()); + EXPECT_EQ(OLAP_SUCCESS, buf1->put(i)); + EXPECT_EQ(50u - (i + 1), buf1->remaining()); + EXPECT_EQ(50u + i + 1, buf1->position()); } // 再写就失败了 - ASSERT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(0)); - ASSERT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(in, sizeof(in))); + EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(0)); + EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->put(in, sizeof(in))); // 转为读模式 buf1->flip(); @@ -72,38 +72,38 @@ TEST_F(TestByteBuffer, TestReadWrite) { for (int i = 0; i < 5; i++) { for (int j = 0; j < 10; j++) { char byte; - ASSERT_EQ(OLAP_SUCCESS, buf1->get(&byte)); - ASSERT_EQ(100u - (i * 10 + j + 1), buf1->remaining()); - ASSERT_EQ(i * 10 + j + 1, buf1->position()); - ASSERT_EQ('a' + j, byte); + EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ(100u - (i * 10 + j + 1), buf1->remaining()); + EXPECT_EQ(i * 10 + j + 1, buf1->position()); + EXPECT_EQ('a' + j, byte); } } char buf[50]; - ASSERT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(buf, 100)); - ASSERT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->get(buf, 10, 50)); - ASSERT_EQ(OLAP_SUCCESS, buf1->get(buf, sizeof(buf))); - ASSERT_EQ(0u, buf1->remaining()); - ASSERT_EQ(100u, buf1->position()); + EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(buf, 100)); + EXPECT_EQ(OLAP_ERR_BUFFER_OVERFLOW, buf1->get(buf, 10, 50)); + EXPECT_EQ(OLAP_SUCCESS, buf1->get(buf, sizeof(buf))); + EXPECT_EQ(0u, buf1->remaining()); + EXPECT_EQ(100u, buf1->position()); for (int i = 0; i < 50; i++) { - ASSERT_EQ(i, buf[i]); + EXPECT_EQ(i, buf[i]); } char byte; - ASSERT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte)); - ASSERT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte, 1)); + EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte)); + EXPECT_EQ(OLAP_ERR_OUT_OF_BOUND, buf1->get(&byte, 1)); - ASSERT_EQ(OLAP_SUCCESS, buf1->put(10, 'x')); - ASSERT_EQ(OLAP_SUCCESS, buf1->get(10, &byte)); - ASSERT_EQ('x', byte); + EXPECT_EQ(OLAP_SUCCESS, buf1->put(10, 'x')); + EXPECT_EQ(OLAP_SUCCESS, buf1->get(10, &byte)); + EXPECT_EQ('x', byte); - ASSERT_EQ(OLAP_SUCCESS, buf1->set_limit(11)); - ASSERT_EQ(11u, buf1->limit()); - ASSERT_EQ(11u, buf1->position()); - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_limit(101)); - ASSERT_EQ(OLAP_SUCCESS, buf1->set_position(10)); - ASSERT_EQ(OLAP_SUCCESS, buf1->get(&byte)); - ASSERT_EQ('x', byte); - ASSERT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_position(12)); + EXPECT_EQ(OLAP_SUCCESS, buf1->set_limit(11)); + EXPECT_EQ(11u, buf1->limit()); + EXPECT_EQ(11u, buf1->position()); + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_limit(101)); + EXPECT_EQ(OLAP_SUCCESS, buf1->set_position(10)); + EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ('x', byte); + EXPECT_EQ(OLAP_ERR_INPUT_PARAMETER_ERROR, buf1->set_position(12)); SAFE_DELETE(buf1); } @@ -114,88 +114,77 @@ TEST_F(TestByteBuffer, TestRef) { StorageByteBuffer* buf1 = nullptr; buf1 = StorageByteBuffer::create(1000); - ASSERT_TRUE(buf1 != nullptr); + EXPECT_TRUE(buf1 != nullptr); for (int i = 0; i < 256; i++) { - ASSERT_EQ(OLAP_SUCCESS, buf1->put(i)); + EXPECT_EQ(OLAP_SUCCESS, buf1->put(i)); } StorageByteBuffer buf2 = *buf1; - ASSERT_EQ(buf2.array(), buf1->array()); + EXPECT_EQ(buf2.array(), buf1->array()); StorageByteBuffer buf4(*buf1); - ASSERT_EQ(buf2.array(), buf1->array()); + EXPECT_EQ(buf2.array(), buf1->array()); StorageByteBuffer* buf3 = nullptr; buf3 = StorageByteBuffer::reference_buffer(buf1, 10, 90); - ASSERT_EQ(90u, buf3->capacity()); - ASSERT_EQ(90u, buf3->limit()); - ASSERT_EQ(0u, buf3->position()); + EXPECT_EQ(90u, buf3->capacity()); + EXPECT_EQ(90u, buf3->limit()); + EXPECT_EQ(0u, buf3->position()); for (int i = 0; i < 90; i++) { char byte; - ASSERT_EQ(OLAP_SUCCESS, buf3->get(&byte)); - ASSERT_EQ(i + 10, byte); + EXPECT_EQ(OLAP_SUCCESS, buf3->get(&byte)); + EXPECT_EQ(i + 10, byte); } - ASSERT_EQ(4u, buf1->_buf.use_count()); + EXPECT_EQ(4u, buf1->_buf.use_count()); SAFE_DELETE(buf1); SAFE_DELETE(buf3); - ASSERT_EQ(2u, buf2._buf.use_count()); + EXPECT_EQ(2u, buf2._buf.use_count()); } TEST_F(TestByteBuffer, TestMmap) { FileHandler file_handle; std::string file_name = ".test_byte_buffer"; OLAPStatus res = file_handle.open_with_mode(file_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); char buf[100]; for (int i = 0; i < 100; i++) { buf[i] = i; } - ASSERT_EQ(OLAP_SUCCESS, file_handle.write(buf, 100)); + EXPECT_EQ(OLAP_SUCCESS, file_handle.write(buf, 100)); file_handle.close(); res = file_handle.open(file_name, O_RDWR); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); StorageByteBuffer* buf1 = StorageByteBuffer::mmap(nullptr, 80, PROT_READ | PROT_WRITE, MAP_SHARED, file_handle.fd(), 0); // mmap完成后就可以关闭原fd file_handle.close(); - ASSERT_TRUE(buf1 != nullptr); + EXPECT_TRUE(buf1 != nullptr); for (int i = 0; i < 80; i++) { char byte; - ASSERT_EQ(OLAP_SUCCESS, buf1->get(&byte)); - ASSERT_EQ(i, byte); + EXPECT_EQ(OLAP_SUCCESS, buf1->get(&byte)); + EXPECT_EQ(i, byte); } // 测试通过mmap写入数据 buf1->set_position(0); for (int i = 0; i < 10; i++) { - ASSERT_EQ(OLAP_SUCCESS, buf1->put('x')); + EXPECT_EQ(OLAP_SUCCESS, buf1->put('x')); } SAFE_DELETE(buf1); res = file_handle.open(file_name, O_RDONLY); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(OLAP_SUCCESS, file_handle.pread(buf, 10, SEEK_SET)); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, file_handle.pread(buf, 10, SEEK_SET)); for (int i = 0; i < 10; i++) { - ASSERT_EQ('x', buf[i]); + EXPECT_EQ('x', buf[i]); } } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/column_reader_test.cpp b/be/test/olap/column_reader_test.cpp index 6647a6a8cd..0df74f26e2 100644 --- a/be/test/olap/column_reader_test.cpp +++ b/be/test/olap/column_reader_test.cpp @@ -55,7 +55,7 @@ public: _stream_factory = new (std::nothrow) OutStreamFactory(COMPRESS_LZ4, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); - ASSERT_TRUE(_stream_factory != nullptr); + EXPECT_TRUE(_stream_factory != nullptr); config::column_dictionary_key_ratio_threshold = 30; config::column_dictionary_key_size_threshold = 1000; } @@ -82,8 +82,8 @@ public: _column_writer = ColumnWriter::create(0, tablet_schema, _stream_factory, 1024, BLOOM_FILTER_DEFAULT_FPP); - ASSERT_TRUE(_column_writer != nullptr); - ASSERT_EQ(_column_writer->init(), OLAP_SUCCESS); + EXPECT_TRUE(_column_writer != nullptr); + EXPECT_EQ(_column_writer->init(), OLAP_SUCCESS); } void create_column_reader(const TabletSchema& tablet_schema) { @@ -103,12 +103,12 @@ public: _column_reader = ColumnReader::create(0, tablet_schema, included, segment_included, encodings); - ASSERT_TRUE(_column_reader != nullptr); + EXPECT_TRUE(_column_reader != nullptr); - ASSERT_EQ(system("mkdir -p ./ut_dir"), 0); - ASSERT_EQ(system("rm ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); + EXPECT_EQ(system("rm ./ut_dir/tmp_file"), 0); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode("./ut_dir/tmp_file", O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); std::vector off; @@ -139,10 +139,10 @@ public: } else if (stream_name.kind() == StreamInfoMessage::LENGTH) { buffers = &_length_buffers; } else { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } - ASSERT_TRUE(buffers != nullptr); + EXPECT_TRUE(buffers != nullptr); off.push_back(helper.tell()); out_stream->write_to_file(&helper, 0); length.push_back(out_stream->get_stream_length()); @@ -151,23 +151,23 @@ public: } helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode("./ut_dir/tmp_file", O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); for (int i = 0; i < off.size(); ++i) { ReadOnlyFileStream* in_stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, off[i], length[i], lz4_decompress, buffer_size[i], &_stats); - ASSERT_EQ(OLAP_SUCCESS, in_stream->init()); + EXPECT_EQ(OLAP_SUCCESS, in_stream->init()); _map_in_streams[name[i]] = in_stream; } - ASSERT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), + EXPECT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), OLAP_SUCCESS); } @@ -192,7 +192,7 @@ public: } void create_and_save_last_position() { - ASSERT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); } ColumnWriter* _column_writer; @@ -240,10 +240,10 @@ TEST_F(TestColumn, VectorizedTinyColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -252,15 +252,15 @@ TEST_F(TestColumn, VectorizedTinyColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); data++; value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { @@ -288,7 +288,7 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -297,12 +297,12 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -323,22 +323,22 @@ TEST_F(TestColumn, SeekTinyColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); data++; value = *reinterpret_cast(data); - ASSERT_EQ(value, 2); + EXPECT_EQ(value, 2); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SkipTinyColumnWithoutPresent) { @@ -370,10 +370,10 @@ TEST_F(TestColumn, SkipTinyColumnWithoutPresent) { block.set_row(2, write_row); block.finalize(3); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -381,12 +381,12 @@ TEST_F(TestColumn, SkipTinyColumnWithoutPresent) { RowCursor read_row; read_row.init(tablet_schema); - ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedTinyColumnWithPresent) { @@ -413,10 +413,10 @@ TEST_F(TestColumn, VectorizedTinyColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -425,12 +425,12 @@ TEST_F(TestColumn, VectorizedTinyColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); value = *reinterpret_cast(data + 1); } @@ -458,10 +458,10 @@ TEST_F(TestColumn, TinyColumnIndex) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -470,13 +470,13 @@ TEST_F(TestColumn, TinyColumnIndex) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + 1); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SeekTinyColumnWithPresent) { @@ -503,7 +503,7 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -512,12 +512,12 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -538,21 +538,21 @@ TEST_F(TestColumn, SeekTinyColumnWithPresent) { PositionProvider position1(&entry1); PositionProvider position2(&entry2); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + 1); - ASSERT_EQ(value, 2); + EXPECT_EQ(value, 2); - ASSERT_EQ(_column_reader->seek(&position2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position2), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SkipTinyColumnWithPresent) { @@ -583,10 +583,10 @@ TEST_F(TestColumn, SkipTinyColumnWithPresent) { block.set_row(2, write_row); block.finalize(3); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -594,12 +594,12 @@ TEST_F(TestColumn, SkipTinyColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedShortColumnWithoutPresent) { @@ -626,10 +626,10 @@ TEST_F(TestColumn, VectorizedShortColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -638,13 +638,13 @@ TEST_F(TestColumn, VectorizedShortColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + sizeof(int16_t)); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SeekShortColumnWithoutPresent) { @@ -670,7 +670,7 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -678,12 +678,12 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -704,22 +704,22 @@ TEST_F(TestColumn, SeekShortColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + sizeof(int16_t)); - ASSERT_EQ(value, 2); + EXPECT_EQ(value, 2); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SkipShortColumnWithoutPresent) { @@ -750,10 +750,10 @@ TEST_F(TestColumn, SkipShortColumnWithoutPresent) { block.set_row(2, write_row); block.finalize(3); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -761,12 +761,12 @@ TEST_F(TestColumn, SkipShortColumnWithoutPresent) { RowCursor read_row; read_row.init(tablet_schema); - ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SeekShortColumnWithPresent) { @@ -792,7 +792,7 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -800,12 +800,12 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -827,19 +827,19 @@ TEST_F(TestColumn, SeekShortColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedShortColumnWithPresent) { @@ -867,10 +867,10 @@ TEST_F(TestColumn, VectorizedShortColumnWithPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -879,15 +879,15 @@ TEST_F(TestColumn, VectorizedShortColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); value = *reinterpret_cast(data + sizeof(int16_t)); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, SkipShortColumnWithPresent) { @@ -918,10 +918,10 @@ TEST_F(TestColumn, SkipShortColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(2, write_row); block.finalize(3); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -930,12 +930,12 @@ TEST_F(TestColumn, SkipShortColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(2), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedIntColumnWithoutPresent) { @@ -963,10 +963,10 @@ TEST_F(TestColumn, VectorizedIntColumnWithoutPresent) { block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -976,13 +976,13 @@ TEST_F(TestColumn, VectorizedIntColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + sizeof(int)); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedIntColumnMassWithoutPresent) { @@ -1006,10 +1006,10 @@ TEST_F(TestColumn, VectorizedIntColumnMassWithoutPresent) { block.set_row(i, write_row); } block.finalize(10000); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1023,14 +1023,14 @@ TEST_F(TestColumn, VectorizedIntColumnMassWithoutPresent) { char* data = nullptr; for (int32_t i = 0; i < 10000; ++i) { if (i % 1000 == 0) { - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1000, _mem_pool.get()), + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1000, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); } int32_t value = 0; value = *reinterpret_cast(data); - ASSERT_EQ(value, i); + EXPECT_EQ(value, i); data += sizeof(int32_t); } } @@ -1054,15 +1054,15 @@ TEST_F(TestColumn, VectorizedIntColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1073,15 +1073,15 @@ TEST_F(TestColumn, VectorizedIntColumnWithPresent) { _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[0], false); + EXPECT_EQ(is_null[0], false); value = *reinterpret_cast(data); - ASSERT_EQ(value, -1); + EXPECT_EQ(value, -1); - ASSERT_EQ(is_null[1], true); + EXPECT_EQ(is_null[1], true); } TEST_F(TestColumn, VectorizedLongColumnWithoutPresent) { @@ -1104,16 +1104,16 @@ TEST_F(TestColumn, VectorizedLongColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); value = 3; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1123,13 +1123,13 @@ TEST_F(TestColumn, VectorizedLongColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_EQ(value, 1); + EXPECT_EQ(value, 1); value = *reinterpret_cast(data + sizeof(int64_t)); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedLongColumnWithPresent) { @@ -1151,17 +1151,17 @@ TEST_F(TestColumn, VectorizedLongColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); int64_t value = 3; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1171,15 +1171,15 @@ TEST_F(TestColumn, VectorizedLongColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); value = *reinterpret_cast(data + sizeof(int64_t)); - ASSERT_EQ(value, 3); + EXPECT_EQ(value, 3); } TEST_F(TestColumn, VectorizedFloatColumnWithoutPresent) { @@ -1202,16 +1202,16 @@ TEST_F(TestColumn, VectorizedFloatColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1221,14 +1221,14 @@ TEST_F(TestColumn, VectorizedFloatColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_FLOAT_EQ(value, 1.234); + EXPECT_FLOAT_EQ(value, 1.234); data += sizeof(float); value = *reinterpret_cast(data); - ASSERT_FLOAT_EQ(value, 3.234); + EXPECT_FLOAT_EQ(value, 3.234); } TEST_F(TestColumn, VectorizedFloatColumnWithPresent) { @@ -1250,17 +1250,17 @@ TEST_F(TestColumn, VectorizedFloatColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); float value = 3.234; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1270,15 +1270,15 @@ TEST_F(TestColumn, VectorizedFloatColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); char* data = reinterpret_cast(_col_vector->col_data()) + sizeof(float); value = *reinterpret_cast(data); - ASSERT_FLOAT_EQ(value, 3.234); + EXPECT_FLOAT_EQ(value, 3.234); } TEST_F(TestColumn, SeekFloatColumnWithPresent) { @@ -1301,7 +1301,7 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -1309,12 +1309,12 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1336,15 +1336,15 @@ TEST_F(TestColumn, SeekFloatColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_FLOAT_EQ(value, 1.234); + EXPECT_FLOAT_EQ(value, 1.234); value = *reinterpret_cast(data + sizeof(float)); - ASSERT_FLOAT_EQ(value, 3.234); + EXPECT_FLOAT_EQ(value, 3.234); } TEST_F(TestColumn, SkipFloatColumnWithPresent) { @@ -1367,16 +1367,16 @@ TEST_F(TestColumn, SkipFloatColumnWithPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1385,12 +1385,12 @@ TEST_F(TestColumn, SkipFloatColumnWithPresent) { RowCursor read_row; read_row.init(tablet_schema); - ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_FLOAT_EQ(value, 3.234); + EXPECT_FLOAT_EQ(value, 3.234); } TEST_F(TestColumn, VectorizedDoubleColumnWithoutPresent) { @@ -1413,16 +1413,16 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithoutPresent) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); value = 3.23456789; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1432,14 +1432,14 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); value = *reinterpret_cast(data); - ASSERT_DOUBLE_EQ(value, 1.23456789); + EXPECT_DOUBLE_EQ(value, 1.23456789); data += sizeof(double); value = *reinterpret_cast(data); - ASSERT_DOUBLE_EQ(value, 3.23456789); + EXPECT_DOUBLE_EQ(value, 3.23456789); } TEST_F(TestColumn, VectorizedDoubleColumnWithPresent) { @@ -1461,17 +1461,17 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); double value = 3.23456789; write_row.set_not_null(0); write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1481,16 +1481,16 @@ TEST_F(TestColumn, VectorizedDoubleColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); data += sizeof(double); value = *reinterpret_cast(data); - ASSERT_DOUBLE_EQ(value, 3.23456789); + EXPECT_DOUBLE_EQ(value, 3.23456789); } TEST_F(TestColumn, VectorizedDatetimeColumnWithoutPresent) { @@ -1515,10 +1515,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithoutPresent) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1528,10 +1528,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", strlen("0&2000-10-10 10:10:10")) == 0); } @@ -1554,7 +1554,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); std::vector val_string_array; val_string_array.push_back("2000-10-10 10:10:10"); @@ -1563,10 +1563,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1576,19 +1576,19 @@ TEST_F(TestColumn, VectorizedDatetimeColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); data += sizeof(uint64_t); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", strlen("0&2000-10-10 10:10:10")) == 0); - ASSERT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); } TEST_F(TestColumn, VectorizedDatetimeColumnZero) { // write data @@ -1609,7 +1609,7 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); std::vector val_string_array; val_string_array.push_back("1000-01-01 00:00:00"); @@ -1618,10 +1618,10 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1631,20 +1631,19 @@ TEST_F(TestColumn, VectorizedDatetimeColumnZero) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); data += sizeof(uint64_t); read_row.set_field_content(0, data, _mem_pool.get()); - std::cout << read_row.to_string() << std::endl; - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1000-01-01 00:00:00", + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1000-01-01 00:00:00", strlen("0&1000-01-01 00:00:00")) == 0); - ASSERT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); } TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { @@ -1669,10 +1668,10 @@ TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1682,10 +1681,10 @@ TEST_F(TestColumn, VectorizedDateColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0); } TEST_F(TestColumn, VectorizedDateColumnWithPresent) { @@ -1707,7 +1706,7 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); std::vector val_string_array; val_string_array.push_back("2000-10-10"); @@ -1717,11 +1716,11 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1731,16 +1730,16 @@ TEST_F(TestColumn, VectorizedDateColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 101, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 101, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); for (uint32_t i = 0; i < 100; ++i) { data += sizeof(uint24_t); - ASSERT_EQ(is_null[i + 1], false); + EXPECT_EQ(is_null[i + 1], false); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0); } } @@ -1767,7 +1766,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("5678.1234"); @@ -1775,10 +1774,10 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1788,14 +1787,14 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); data += sizeof(decimal12_t); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); } TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { @@ -1818,7 +1817,7 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("5678.1234"); @@ -1827,10 +1826,10 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1840,15 +1839,15 @@ TEST_F(TestColumn, VectorizedDecimalColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); + EXPECT_EQ(is_null[0], true); char* data = reinterpret_cast(_col_vector->col_data()); data += sizeof(decimal12_t); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[1], false); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); } TEST_F(TestColumn, SkipDecimalColumnWithPresent) { @@ -1872,17 +1871,17 @@ TEST_F(TestColumn, SkipDecimalColumnWithPresent) { write_row.from_tuple(val_string_array); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("5678.1234"); write_row.from_tuple(val_string_array); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1893,12 +1892,12 @@ TEST_F(TestColumn, SkipDecimalColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); } TEST_F(TestColumn, SeekDecimalColumnWithPresent) { @@ -1923,7 +1922,7 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); @@ -1933,12 +1932,12 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); create_and_save_last_position(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -1961,20 +1960,20 @@ TEST_F(TestColumn, SeekDecimalColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0); memset(read_value, 0, 20); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0); } TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { @@ -2005,7 +2004,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back(value2); @@ -2013,10 +2012,10 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -2026,15 +2025,15 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithoutPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); value1 = "0&" + value1; value2 = "0&" + value2; - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0); read_row.set_field_content(0, data + sizeof(int128_t), _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); } TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { @@ -2063,7 +2062,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); std::vector val_string_array; val_string_array.push_back(value1); @@ -2072,7 +2071,7 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back(value2); @@ -2081,10 +2080,10 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data @@ -2094,11 +2093,11 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { read_row.init(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); - ASSERT_EQ(is_null[1], false); - ASSERT_EQ(is_null[2], false); + EXPECT_EQ(is_null[0], true); + EXPECT_EQ(is_null[1], false); + EXPECT_EQ(is_null[2], false); char* data = reinterpret_cast(_col_vector->col_data()); value1 = "0&" + value1; @@ -2106,11 +2105,11 @@ TEST_F(TestColumn, VectorizedLargeIntColumnWithPresent) { data += sizeof(int128_t); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0); data += sizeof(int128_t); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); } TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { @@ -2141,7 +2140,7 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back(value2); @@ -2149,10 +2148,10 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2160,12 +2159,12 @@ TEST_F(TestColumn, SkipLargeIntColumnWithPresent) { read_row.init(tablet_schema); value2 = "0&" + value2; - ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); - ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); + EXPECT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0); } TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { @@ -2192,11 +2191,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } val_string_array.clear(); val_string_array.push_back("ZWRjYmE="); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2205,11 +2204,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2220,18 +2219,18 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithoutPresent) { _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); } for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "ZWRjYmE=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "ZWRjYmE=", value->size) == 0); } - ASSERT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); } TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { @@ -2253,7 +2252,7 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { write_row.set_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); std::vector val_string_array; val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU=" @@ -2262,10 +2261,10 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { write_row.set_not_null(0); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2275,14 +2274,14 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[0], true); + EXPECT_EQ(is_null[1], false); Slice* value = reinterpret_cast(_col_vector->col_data()); value++; - ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); } TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { @@ -2308,7 +2307,7 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("YWFhYWE="); //"aaaaa" base_64_encode is "YWJjZGU=" @@ -2316,10 +2315,10 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2330,11 +2329,11 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) { char read_value[20]; memset(read_value, 0, 20); - ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->skip(1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { @@ -2360,7 +2359,7 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); _column_writer->create_row_index_entry(); @@ -2370,12 +2369,12 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); _column_writer->create_row_index_entry(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2397,17 +2396,17 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { @@ -2433,7 +2432,7 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); _column_writer->create_row_index_entry(); @@ -2443,12 +2442,12 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); _column_writer->create_row_index_entry(); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2470,17 +2469,17 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) { PositionProvider position0(&entry1); PositionProvider position1(&entry2); - ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0); - ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0); } TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { @@ -2505,11 +2504,11 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2518,11 +2517,11 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2532,19 +2531,19 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); } for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "edcba", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "edcba", value->size) == 0); } - ASSERT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); } TEST_F(TestColumn, VectorizedCharColumnWithPresent) { @@ -2573,10 +2572,10 @@ TEST_F(TestColumn, VectorizedCharColumnWithPresent) { write_row.set_not_null(0); block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2586,14 +2585,14 @@ TEST_F(TestColumn, VectorizedCharColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[0], true); + EXPECT_EQ(is_null[1], false); Slice* value = reinterpret_cast(_col_vector->col_data()); value++; - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); } TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { @@ -2618,7 +2617,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("aaaaa"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2626,7 +2625,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("bbbbb"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2634,7 +2633,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple3); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("ccccc"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2642,7 +2641,7 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple4); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("ddddd"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2650,10 +2649,10 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { write_row.from_tuple(tuple5); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2663,22 +2662,22 @@ TEST_F(TestColumn, VectorizedCharColumnWithoutoutPresent2) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "aaaaa", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "aaaaa", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "bbbbb", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "bbbbb", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "ccccc", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "ccccc", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "ddddd", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "ddddd", value->size) == 0); } TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { @@ -2703,11 +2702,11 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2716,11 +2715,11 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2730,19 +2729,19 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); } for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "edcba", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "edcba", value->size) == 0); } - ASSERT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_NE(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); } TEST_F(TestColumn, VectorizedStringColumnWithPresent) { @@ -2771,10 +2770,10 @@ TEST_F(TestColumn, VectorizedStringColumnWithPresent) { write_row.set_not_null(0); block.set_row(1, write_row); block.finalize(2); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2784,14 +2783,14 @@ TEST_F(TestColumn, VectorizedStringColumnWithPresent) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); bool* is_null = _col_vector->is_null(); - ASSERT_EQ(is_null[0], true); - ASSERT_EQ(is_null[1], false); + EXPECT_EQ(is_null[0], true); + EXPECT_EQ(is_null[1], false); Slice* value = reinterpret_cast(_col_vector->col_data()); value++; - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); } TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { @@ -2816,7 +2815,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple1); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("aaaaa"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2824,7 +2823,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple2); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("bbbbb"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2832,7 +2831,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple3); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("ccccc"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2840,7 +2839,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple4); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("ddddd"); //"abcde" base_64_encode is "YWJjZGU=" @@ -2848,10 +2847,10 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { write_row.from_tuple(tuple5); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2861,22 +2860,22 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutoutPresent2) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); - ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "abcde", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "aaaaa", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "aaaaa", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "bbbbb", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "bbbbb", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "ccccc", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "ccccc", value->size) == 0); value++; - ASSERT_TRUE(strncmp(value->data, "ddddd", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "ddddd", value->size) == 0); } TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { @@ -2898,10 +2897,10 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { std::vector val_string_array; val_string_array.push_back(std::string(65533, 'a')); OlapTuple tuple1(val_string_array); - ASSERT_EQ(OLAP_SUCCESS, write_row.from_tuple(tuple1)); + EXPECT_EQ(OLAP_SUCCESS, write_row.from_tuple(tuple1)); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); val_string_array.clear(); val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE=" @@ -2910,11 +2909,11 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { for (uint32_t i = 0; i < 2; i++) { block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); } ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data create_column_reader(tablet_schema); @@ -2924,30 +2923,17 @@ TEST_F(TestColumn, VectorizedDirectVarcharColumnWith65533) { read_row.allocate_memory_for_string_type(tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS); Slice* value = reinterpret_cast(_col_vector->col_data()); for (uint32_t i = 0; i < 65533; i++) { - ASSERT_TRUE(strncmp(value->data + i, "a", 1) == 0); + EXPECT_TRUE(strncmp(value->data + i, "a", 1) == 0); } for (uint32_t i = 0; i < 2; i++) { value++; - ASSERT_TRUE(strncmp(value->data, "edcba", value->size) == 0); + EXPECT_TRUE(strncmp(value->data, "edcba", value->size) == 0); } } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::MemInfo::init(); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/olap/column_vector_test.cpp b/be/test/olap/column_vector_test.cpp index 5e65365f4c..5faffb041d 100644 --- a/be/test/olap/column_vector_test.cpp +++ b/be/test/olap/column_vector_test.cpp @@ -50,10 +50,10 @@ void test_read_write_scalar_column_vector(const TypeInfo* type_info, const uint8 size_t init_size = data_size / 2; std::unique_ptr cvb; - ASSERT_TRUE(ColumnVectorBatch::create(init_size, true, type_info, nullptr, &cvb).ok()); + EXPECT_TRUE(ColumnVectorBatch::create(init_size, true, type_info, nullptr, &cvb).ok()); memcpy(cvb->mutable_cell_ptr(0), src, init_size * TYPE_SIZE); cvb->set_null_bits(0, init_size, false); - ASSERT_TRUE(cvb->resize(data_size).ok()); + EXPECT_TRUE(cvb->resize(data_size).ok()); size_t second_write_size = data_size - init_size; memcpy(cvb->mutable_cell_ptr(init_size), src + init_size, second_write_size * TYPE_SIZE); cvb->set_null_bits(init_size, second_write_size, false); @@ -62,11 +62,11 @@ void test_read_write_scalar_column_vector(const TypeInfo* type_info, const uint8 type_info->type() == OLAP_FIELD_TYPE_CHAR) { Slice* src_slice = (Slice*)src_data; - ASSERT_EQ(src_slice[idx].to_string(), + EXPECT_EQ(src_slice[idx].to_string(), reinterpret_cast(cvb->cell_ptr(idx))->to_string()) << "idx:" << idx; } else { - ASSERT_EQ(src[idx], *reinterpret_cast(cvb->cell_ptr(idx))); + EXPECT_EQ(src[idx], *reinterpret_cast(cvb->cell_ptr(idx))); } } } @@ -86,7 +86,7 @@ void test_read_write_array_column_vector(const TypeInfo* array_type_info, size_t size_t array_init_size = array_size / 2; std::unique_ptr cvb; - ASSERT_TRUE( + EXPECT_TRUE( ColumnVectorBatch::create(array_init_size, true, array_type_info, field, &cvb).ok()); auto* array_cvb = reinterpret_cast(cvb.get()); @@ -102,7 +102,7 @@ void test_read_write_array_column_vector(const TypeInfo* array_type_info, size_t array_cvb->get_offset_by_length(0, array_init_size); size_t first_write_item = array_cvb->item_offset(array_init_size) - array_cvb->item_offset(0); - ASSERT_TRUE(item_cvb->resize(first_write_item).ok()); + EXPECT_TRUE(item_cvb->resize(first_write_item).ok()); for (size_t i = 0; i < array_init_size; ++i) { memcpy(item_cvb->mutable_cell_ptr(array_cvb->item_offset(i)), result[i].data(), result[i].length() * ITEM_TYPE_SIZE); @@ -112,7 +112,7 @@ void test_read_write_array_column_vector(const TypeInfo* array_type_info, size_t array_cvb->prepare_for_read(0, array_init_size, false); // second write - ASSERT_TRUE(array_cvb->resize(array_size).ok()); + EXPECT_TRUE(array_cvb->resize(array_size).ok()); for (int i = array_init_size; i < array_size; ++i) { uint32_t len = result[i].length(); memcpy(offset_cvb->mutable_cell_ptr(i + 1), &len, sizeof(uint32_t)); @@ -121,7 +121,7 @@ void test_read_write_array_column_vector(const TypeInfo* array_type_info, size_t array_cvb->get_offset_by_length(array_init_size, array_size - array_init_size); size_t total_item_size = array_cvb->item_offset(array_size); - ASSERT_TRUE(item_cvb->resize(total_item_size).ok()); + EXPECT_TRUE(item_cvb->resize(total_item_size).ok()); for (size_t i = array_init_size; i < array_size; ++i) { memcpy(item_cvb->mutable_cell_ptr(array_cvb->item_offset(i)), result[i].data(), @@ -132,7 +132,7 @@ void test_read_write_array_column_vector(const TypeInfo* array_type_info, size_t array_cvb->prepare_for_read(0, array_size, false); for (size_t idx = 0; idx < array_size; ++idx) { - ASSERT_TRUE(array_type_info->equal(&result[idx], array_cvb->cell_ptr(idx))) + EXPECT_TRUE(array_type_info->equal(&result[idx], array_cvb->cell_ptr(idx))) << "idx:" << idx; } delete field; @@ -191,8 +191,3 @@ TEST_F(ColumnVectorTest, array_column_vector_test) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/common_test.cpp b/be/test/olap/common_test.cpp index e3750e1330..1519828c99 100644 --- a/be/test/olap/common_test.cpp +++ b/be/test/olap/common_test.cpp @@ -36,15 +36,10 @@ TEST(DataDirInfo, DataDirInfoLessAvailability) { data_dir_infos.push_back(a); data_dir_infos.push_back(b); std::sort(data_dir_infos.begin(), data_dir_infos.end(), DataDirInfoLessAvailability()); - ASSERT_EQ(data_dir_infos[0].available, 100); - ASSERT_EQ(data_dir_infos[1].available, 200); - ASSERT_EQ(data_dir_infos[2].available, 300); - ASSERT_EQ(data_dir_infos[3].available, 400); + EXPECT_EQ(data_dir_infos[0].available, 100); + EXPECT_EQ(data_dir_infos[1].available, 200); + EXPECT_EQ(data_dir_infos[2].available, 300); + EXPECT_EQ(data_dir_infos[3].available, 400); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/comparison_predicate_test.cpp b/be/test/olap/comparison_predicate_test.cpp index 5aee788744..63fcde12ed 100644 --- a/be/test/olap/comparison_predicate_test.cpp +++ b/be/test/olap/comparison_predicate_test.cpp @@ -158,9 +158,9 @@ TEST_PREDICATE_DEFINITION(TestLessPredicate) TYPE value = 5; \ ColumnPredicate* pred = new EqualPredicate(0, value); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 1); \ + EXPECT_EQ(_vectorized_batch->size(), 1); \ uint16_t* sel = _vectorized_batch->selected(); \ - ASSERT_EQ(*(col_data + sel[0]), 5); \ + EXPECT_EQ(*(col_data + sel[0]), 5); \ \ /* for has nulls */ \ col_vector->set_no_nulls(false); \ @@ -177,9 +177,9 @@ TEST_PREDICATE_DEFINITION(TestLessPredicate) _vectorized_batch->set_size(size); \ _vectorized_batch->set_selected_in_use(false); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 1); \ + EXPECT_EQ(_vectorized_batch->size(), 1); \ sel = _vectorized_batch->selected(); \ - ASSERT_EQ(*(col_data + sel[0]), 5); \ + EXPECT_EQ(*(col_data + sel[0]), 5); \ delete pred; \ } @@ -210,9 +210,9 @@ TEST_F(TestEqualPredicate, FLOAT_COLUMN) { *(col_data + i) = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 5.0); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 5.0); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -224,8 +224,8 @@ TEST_F(TestEqualPredicate, FLOAT_COLUMN) { *reinterpret_cast(col_block_view.data()) = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); + EXPECT_EQ(select_size, 1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -242,9 +242,9 @@ TEST_F(TestEqualPredicate, FLOAT_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 5.0); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 5.0); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -259,8 +259,8 @@ TEST_F(TestEqualPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); + EXPECT_EQ(select_size, 1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); delete pred; } @@ -287,9 +287,9 @@ TEST_F(TestEqualPredicate, DOUBLE_COLUMN) { *(col_data + i) = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_DOUBLE_EQ(*(col_data + sel[0]), 5.0); + EXPECT_DOUBLE_EQ(*(col_data + sel[0]), 5.0); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -301,8 +301,8 @@ TEST_F(TestEqualPredicate, DOUBLE_COLUMN) { *reinterpret_cast(col_block_view.data()) = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -319,9 +319,9 @@ TEST_F(TestEqualPredicate, DOUBLE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_DOUBLE_EQ(*(col_data + sel[0]), 5.0); + EXPECT_DOUBLE_EQ(*(col_data + sel[0]), 5.0); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -336,8 +336,8 @@ TEST_F(TestEqualPredicate, DOUBLE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.0); delete pred; } @@ -366,9 +366,9 @@ TEST_F(TestEqualPredicate, DECIMAL_COLUMN) { (*(col_data + i)).fraction = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(*(col_data + sel[0]), value); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -381,8 +381,8 @@ TEST_F(TestEqualPredicate, DECIMAL_COLUMN) { reinterpret_cast(col_block_view.data())->fraction = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -400,9 +400,9 @@ TEST_F(TestEqualPredicate, DECIMAL_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(*(col_data + sel[0]), value); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -418,8 +418,8 @@ TEST_F(TestEqualPredicate, DECIMAL_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); delete pred; } @@ -430,14 +430,14 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { &char_tablet_schema); // test WrapperField.from_string() for char type WrapperField* field = WrapperField::create(char_tablet_schema.column(0)); - ASSERT_EQ(OLAP_SUCCESS, field->from_string("true")); + EXPECT_EQ(OLAP_SUCCESS, field->from_string("true")); const std::string tmp = field->to_string(); - ASSERT_EQ(5, tmp.size()); - ASSERT_EQ('t', tmp[0]); - ASSERT_EQ('r', tmp[1]); - ASSERT_EQ('u', tmp[2]); - ASSERT_EQ('e', tmp[3]); - ASSERT_EQ(0, tmp[4]); + EXPECT_EQ(5, tmp.size()); + EXPECT_EQ('t', tmp[0]); + EXPECT_EQ('r', tmp[1]); + EXPECT_EQ('u', tmp[2]); + EXPECT_EQ('e', tmp[3]); + EXPECT_EQ(0, tmp[4]); TabletSchema tablet_schema; SetTabletSchema(std::string("STRING_COLUMN"), "VARCHAR", "REPLACE", 1, true, true, @@ -472,10 +472,10 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { string_buffer += i + 1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(sel[0], 3); - ASSERT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(sel[0], 3); + EXPECT_EQ(*(col_data + sel[0]), value); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -494,8 +494,8 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { string_buffer += i + 1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -518,9 +518,9 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(*(col_data + sel[0]), value); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -541,8 +541,8 @@ TEST_F(TestEqualPredicate, STRING_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value); delete field; delete pred; @@ -578,11 +578,11 @@ TEST_F(TestEqualPredicate, DATE_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(sel[0], 3); - ASSERT_EQ(*(col_data + sel[0]), value); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); + EXPECT_EQ(sel[0], 3); + EXPECT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -595,8 +595,8 @@ TEST_F(TestEqualPredicate, DATE_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10"); @@ -616,10 +616,10 @@ TEST_F(TestEqualPredicate, DATE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); + EXPECT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -635,8 +635,8 @@ TEST_F(TestEqualPredicate, DATE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10"); @@ -674,11 +674,11 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(sel[0], 3); - ASSERT_EQ(*(col_data + sel[0]), value); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); + EXPECT_EQ(sel[0], 3); + EXPECT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -691,8 +691,8 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10 01:00:00"); @@ -712,10 +712,10 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); + EXPECT_EQ(*(col_data + sel[0]), value); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -731,8 +731,8 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10 01:00:00"); @@ -762,13 +762,13 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { TYPE value = 5; \ ColumnPredicate* pred = new LessPredicate(0, value); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 5); \ + EXPECT_EQ(_vectorized_batch->size(), 5); \ uint16_t* sel = _vectorized_batch->selected(); \ TYPE sum = 0; \ for (int i = 0; i < _vectorized_batch->size(); ++i) { \ sum += *(col_data + sel[i]); \ } \ - ASSERT_EQ(sum, 10); \ + EXPECT_EQ(sum, 10); \ \ /* for has nulls */ \ col_vector->set_no_nulls(false); \ @@ -785,13 +785,13 @@ TEST_F(TestEqualPredicate, DATETIME_COLUMN) { _vectorized_batch->set_size(size); \ _vectorized_batch->set_selected_in_use(false); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 2); \ + EXPECT_EQ(_vectorized_batch->size(), 2); \ sel = _vectorized_batch->selected(); \ sum = 0; \ for (int i = 0; i < _vectorized_batch->size(); ++i) { \ sum += *(col_data + sel[i]); \ } \ - ASSERT_EQ(sum, 4); \ + EXPECT_EQ(sum, 4); \ delete pred; \ } @@ -822,13 +822,13 @@ TEST_F(TestLessPredicate, FLOAT_COLUMN) { *(col_data + i) = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 5); + EXPECT_EQ(_vectorized_batch->size(), 5); uint16_t* sel = _vectorized_batch->selected(); float sum = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_FLOAT_EQ(sum, 10.0); + EXPECT_FLOAT_EQ(sum, 10.0); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -840,12 +840,12 @@ TEST_F(TestLessPredicate, FLOAT_COLUMN) { *reinterpret_cast(col_block_view.data()) = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); sum = 0; for (int i = 0; i < 5; ++i) { sum += *(float*)col_block.cell(_row_block->selection_vector()[i]).cell_ptr(); } - ASSERT_FLOAT_EQ(sum, 10.0); + EXPECT_FLOAT_EQ(sum, 10.0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -862,13 +862,13 @@ TEST_F(TestLessPredicate, FLOAT_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 2); + EXPECT_EQ(_vectorized_batch->size(), 2); sel = _vectorized_batch->selected(); sum = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_FLOAT_EQ(sum, 4.0); + EXPECT_FLOAT_EQ(sum, 4.0); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -883,12 +883,12 @@ TEST_F(TestLessPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); sum = 0; for (int i = 0; i < 2; ++i) { sum += *(float*)col_block.cell(_row_block->selection_vector()[i]).cell_ptr(); } - ASSERT_FLOAT_EQ(sum, 4.0); + EXPECT_FLOAT_EQ(sum, 4.0); delete pred; } @@ -915,13 +915,13 @@ TEST_F(TestLessPredicate, DOUBLE_COLUMN) { *(col_data + i) = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 5); + EXPECT_EQ(_vectorized_batch->size(), 5); uint16_t* sel = _vectorized_batch->selected(); double sum = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_DOUBLE_EQ(sum, 10.0); + EXPECT_DOUBLE_EQ(sum, 10.0); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -933,12 +933,12 @@ TEST_F(TestLessPredicate, DOUBLE_COLUMN) { *reinterpret_cast(col_block_view.data()) = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); sum = 0; for (int i = 0; i < 5; ++i) { sum += *(double*)col_block.cell(_row_block->selection_vector()[i]).cell_ptr(); } - ASSERT_DOUBLE_EQ(sum, 10.0); + EXPECT_DOUBLE_EQ(sum, 10.0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -955,13 +955,13 @@ TEST_F(TestLessPredicate, DOUBLE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 2); + EXPECT_EQ(_vectorized_batch->size(), 2); sel = _vectorized_batch->selected(); sum = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_DOUBLE_EQ(sum, 4.0); + EXPECT_DOUBLE_EQ(sum, 4.0); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -976,12 +976,12 @@ TEST_F(TestLessPredicate, DOUBLE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); sum = 0; for (int i = 0; i < 2; ++i) { sum += *(double*)col_block.cell(_row_block->selection_vector()[i]).cell_ptr(); } - ASSERT_DOUBLE_EQ(sum, 4.0); + EXPECT_DOUBLE_EQ(sum, 4.0); delete pred; } @@ -1010,14 +1010,14 @@ TEST_F(TestLessPredicate, DECIMAL_COLUMN) { (*(col_data + i)).fraction = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 5); + EXPECT_EQ(_vectorized_batch->size(), 5); uint16_t* sel = _vectorized_batch->selected(); decimal12_t sum = {0, 0}; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_EQ(sum.integer, 10); - ASSERT_EQ(sum.fraction, 10); + EXPECT_EQ(sum.integer, 10); + EXPECT_EQ(sum.fraction, 10); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -1030,14 +1030,14 @@ TEST_F(TestLessPredicate, DECIMAL_COLUMN) { reinterpret_cast(col_block_view.data())->fraction = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); sum.integer = 0; sum.fraction = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_EQ(sum.integer, 10); - ASSERT_EQ(sum.fraction, 10); + EXPECT_EQ(sum.integer, 10); + EXPECT_EQ(sum.fraction, 10); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -1055,14 +1055,14 @@ TEST_F(TestLessPredicate, DECIMAL_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 2); + EXPECT_EQ(_vectorized_batch->size(), 2); sum.integer = 0; sum.fraction = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_EQ(sum.integer, 4); - ASSERT_EQ(sum.fraction, 4); + EXPECT_EQ(sum.integer, 4); + EXPECT_EQ(sum.fraction, 4); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -1078,14 +1078,14 @@ TEST_F(TestLessPredicate, DECIMAL_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); sum.integer = 0; sum.fraction = 0; for (int i = 0; i < _vectorized_batch->size(); ++i) { sum += *(col_data + sel[i]); } - ASSERT_EQ(sum.integer, 4); - ASSERT_EQ(sum.fraction, 4); + EXPECT_EQ(sum.integer, 4); + EXPECT_EQ(sum.fraction, 4); delete pred; } @@ -1123,9 +1123,9 @@ TEST_F(TestLessPredicate, STRING_COLUMN) { string_buffer += i + 1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_TRUE(strncmp((*(col_data + sel[0])).ptr, "a", 1) == 0); + EXPECT_TRUE(strncmp((*(col_data + sel[0])).ptr, "a", 1) == 0); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -1144,8 +1144,8 @@ TEST_F(TestLessPredicate, STRING_COLUMN) { string_buffer += i + 1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_TRUE( + EXPECT_EQ(select_size, 3); + EXPECT_TRUE( strncmp((*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()) .ptr, "a", 1) == 0); @@ -1171,9 +1171,9 @@ TEST_F(TestLessPredicate, STRING_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_TRUE(strncmp((*(col_data + sel[0])).ptr, "bb", 2) == 0); + EXPECT_TRUE(strncmp((*(col_data + sel[0])).ptr, "bb", 2) == 0); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -1194,8 +1194,8 @@ TEST_F(TestLessPredicate, STRING_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_TRUE( + EXPECT_EQ(select_size, 1); + EXPECT_TRUE( strncmp((*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()) .ptr, "bb", 2) == 0); @@ -1233,9 +1233,9 @@ TEST_F(TestLessPredicate, DATE_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-07"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-07"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -1248,8 +1248,8 @@ TEST_F(TestLessPredicate, DATE_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 3); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-07"); @@ -1269,9 +1269,9 @@ TEST_F(TestLessPredicate, DATE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-08"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-08"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -1287,8 +1287,8 @@ TEST_F(TestLessPredicate, DATE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-08"); @@ -1328,9 +1328,9 @@ TEST_F(TestLessPredicate, DATETIME_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-07 00:00:00"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-07 00:00:00"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -1343,8 +1343,8 @@ TEST_F(TestLessPredicate, DATETIME_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 3); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-07 00:00:00"); @@ -1364,9 +1364,9 @@ TEST_F(TestLessPredicate, DATETIME_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-08 00:01:00"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-08 00:01:00"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -1382,8 +1382,8 @@ TEST_F(TestLessPredicate, DATETIME_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-08 00:01:00"); @@ -1391,12 +1391,3 @@ TEST_F(TestLessPredicate, DATETIME_COLUMN) { } } // namespace doris - -int main(int argc, char** argv) { - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/cumulative_compaction_policy_test.cpp b/be/test/olap/cumulative_compaction_policy_test.cpp index 2e8d071e54..21c3d15f9c 100644 --- a/be/test/olap/cumulative_compaction_policy_test.cpp +++ b/be/test/olap/cumulative_compaction_policy_test.cpp @@ -209,16 +209,17 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score) StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); _tablet->init(); std::shared_ptr cumulative_compaction_policy = - CumulativeCompactionPolicyFactory::create_cumulative_compaction_policy( + CumulativeCompactionPolicyFactory::create_cumulative_compaction_policy( CUMULATIVE_NUM_BASED_POLICY); const uint32_t score = _tablet->calc_compaction_score(CompactionType::CUMULATIVE_COMPACTION, cumulative_compaction_policy); - ASSERT_EQ(15, score); + EXPECT_EQ(15, score); } TEST_F(TestNumBasedCumulativeCompactionPolicy, calculate_cumulative_point) { @@ -231,11 +232,12 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, calculate_cumulative_point) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); - ASSERT_EQ(4, _tablet->cumulative_layer_point()); + EXPECT_EQ(4, _tablet->cumulative_layer_point()); } TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_candidate_rowsets) { @@ -248,14 +250,15 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_candidate_rowsets) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); std::vector candidate_rowsets; _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); - ASSERT_EQ(2, candidate_rowsets.size()); + EXPECT_EQ(2, candidate_rowsets.size()); } TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { @@ -268,7 +271,8 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -278,15 +282,15 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; policy.pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(2, input_rowsets.size()); - ASSERT_EQ(6, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(2, input_rowsets.size()); + EXPECT_EQ(6, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { @@ -299,7 +303,8 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_NUM_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -309,16 +314,16 @@ TEST_F(TestNumBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; policy.pick_input_rowsets(_tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(1, input_rowsets.size()); - ASSERT_EQ(3, compaction_score); - ASSERT_EQ(5, last_delete_version.first); - ASSERT_EQ(5, last_delete_version.second); + EXPECT_EQ(1, input_rowsets.size()); + EXPECT_EQ(3, compaction_score); + EXPECT_EQ(5, last_delete_version.first); + EXPECT_EQ(5, last_delete_version.second); } class TestSizeBasedCumulativeCompactionPolicy : public testing::Test { @@ -675,7 +680,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -685,7 +691,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score const uint32_t score = _tablet->calc_compaction_score(CompactionType::CUMULATIVE_COMPACTION, cumulative_compaction_policy); - ASSERT_EQ(15, score); + EXPECT_EQ(15, score); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score_big_base) { @@ -698,7 +704,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); std::shared_ptr cumulative_compaction_policy = @@ -707,7 +714,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calc_cumulative_compaction_score const uint32_t score = _tablet->calc_compaction_score(CompactionType::CUMULATIVE_COMPACTION, cumulative_compaction_policy); - ASSERT_EQ(7, score); + EXPECT_EQ(7, score); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, calculate_cumulative_point_big_base) { @@ -720,11 +727,12 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calculate_cumulative_point_big_b StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); - ASSERT_EQ(4, _tablet->cumulative_layer_point()); + EXPECT_EQ(4, _tablet->cumulative_layer_point()); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, calculate_cumulative_point_overlap) { @@ -737,11 +745,12 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, calculate_cumulative_point_overl StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); - ASSERT_EQ(2, _tablet->cumulative_layer_point()); + EXPECT_EQ(2, _tablet->cumulative_layer_point()); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_candidate_rowsets) { @@ -754,14 +763,15 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_candidate_rowsets) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); std::vector candidate_rowsets; _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); - ASSERT_EQ(3, candidate_rowsets.size()); + EXPECT_EQ(3, candidate_rowsets.size()); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_candidate_rowsets_big_base) { @@ -774,14 +784,15 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_candidate_rowsets_big_base) StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); std::vector candidate_rowsets; _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); - ASSERT_EQ(3, candidate_rowsets.size()); + EXPECT_EQ(3, candidate_rowsets.size()); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { @@ -794,7 +805,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -803,16 +815,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_normal) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(4, input_rowsets.size()); - ASSERT_EQ(12, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(4, input_rowsets.size()); + EXPECT_EQ(12, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_big_base) { @@ -825,7 +837,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_big_base) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -834,16 +847,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_big_base) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(3, input_rowsets.size()); - ASSERT_EQ(7, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(3, input_rowsets.size()); + EXPECT_EQ(7, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_promotion) { @@ -856,7 +869,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_promotion) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -865,16 +879,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_promotion) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(2, input_rowsets.size()); - ASSERT_EQ(4, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(2, input_rowsets.size()); + EXPECT_EQ(4, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_same_level) { @@ -887,7 +901,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_same_leve StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -896,16 +911,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_same_leve _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(4, input_rowsets.size()); - ASSERT_EQ(10, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(4, input_rowsets.size()); + EXPECT_EQ(10, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_empty) { @@ -918,7 +933,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_empty) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -927,16 +943,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_empty) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(0, input_rowsets.size()); - ASSERT_EQ(0, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(0, input_rowsets.size()); + EXPECT_EQ(0, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_reach_min_limit) { @@ -949,7 +965,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_reach_min StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -958,16 +975,16 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_not_reach_min _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(0, input_rowsets.size()); - ASSERT_EQ(0, compaction_score); - ASSERT_EQ(-1, last_delete_version.first); - ASSERT_EQ(-1, last_delete_version.second); + EXPECT_EQ(0, input_rowsets.size()); + EXPECT_EQ(0, compaction_score); + EXPECT_EQ(-1, last_delete_version.first); + EXPECT_EQ(-1, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { @@ -980,7 +997,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -989,17 +1007,17 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, pick_input_rowsets_delete) { _tablet->pick_candidate_rowsets_to_cumulative_compaction(1000, &candidate_rowsets); std::vector input_rowsets; - Version last_delete_version{-1, -1}; + Version last_delete_version {-1, -1}; size_t compaction_score = 0; _tablet->_cumulative_compaction_policy->pick_input_rowsets( _tablet.get(), candidate_rowsets, 10, 5, &input_rowsets, &last_delete_version, &compaction_score); - ASSERT_EQ(2, input_rowsets.size()); - ASSERT_EQ(4, compaction_score); - ASSERT_EQ(5, last_delete_version.first); - ASSERT_EQ(5, last_delete_version.second); + EXPECT_EQ(2, input_rowsets.size()); + EXPECT_EQ(4, compaction_score); + EXPECT_EQ(5, last_delete_version.first); + EXPECT_EQ(5, last_delete_version.second); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, _calc_promotion_size_big) { @@ -1012,7 +1030,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _calc_promotion_size_big) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); @@ -1020,7 +1039,7 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _calc_promotion_size_big) { dynamic_cast( _tablet->_cumulative_compaction_policy.get()); - ASSERT_EQ(1073741824, policy->_tablet_size_based_promotion_size); + EXPECT_EQ(1073741824, policy->_tablet_size_based_promotion_size); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, _calc_promotion_size_small) { @@ -1033,14 +1052,15 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _calc_promotion_size_small) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); _tablet->calculate_cumulative_point(); SizeBasedCumulativeCompactionPolicy* policy = dynamic_cast( _tablet->_cumulative_compaction_policy.get()); - ASSERT_EQ(67108864, policy->_tablet_size_based_promotion_size); + EXPECT_EQ(67108864, policy->_tablet_size_based_promotion_size); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, _level_size) { @@ -1053,18 +1073,19 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _level_size) { StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); SizeBasedCumulativeCompactionPolicy* policy = dynamic_cast( _tablet->_cumulative_compaction_policy.get()); - ASSERT_EQ(4, policy->_levels.size()); - ASSERT_EQ(536870912, policy->_levels[0]); - ASSERT_EQ(268435456, policy->_levels[1]); - ASSERT_EQ(134217728, policy->_levels[2]); - ASSERT_EQ(67108864, policy->_levels[3]); + EXPECT_EQ(4, policy->_levels.size()); + EXPECT_EQ(536870912, policy->_levels[0]); + EXPECT_EQ(268435456, policy->_levels[1]); + EXPECT_EQ(134217728, policy->_levels[2]); + EXPECT_EQ(67108864, policy->_levels[3]); } TEST_F(TestSizeBasedCumulativeCompactionPolicy, _pick_missing_version_cumulative_compaction) { @@ -1077,7 +1098,8 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _pick_missing_version_cumulative StorageParamPB storage_param; storage_param.set_storage_medium(StorageMediumPB::HDD); - TabletSharedPtr _tablet(new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); + TabletSharedPtr _tablet( + new Tablet(_tablet_meta, storage_param, nullptr, CUMULATIVE_SIZE_BASED_POLICY)); _tablet->init(); // has miss version @@ -1088,25 +1110,21 @@ TEST_F(TestSizeBasedCumulativeCompactionPolicy, _pick_missing_version_cumulative rowsets.push_back(_tablet->get_rowset_by_version({4, 4})); CumulativeCompaction compaction(_tablet); compaction.find_longest_consecutive_version(&rowsets, nullptr); - ASSERT_EQ(3, rowsets.size()); - ASSERT_EQ(2, rowsets[2]->end_version()); + EXPECT_EQ(3, rowsets.size()); + EXPECT_EQ(2, rowsets[2]->end_version()); // no miss version std::vector rowsets2; rowsets2.push_back(_tablet->get_rowset_by_version({0, 0})); compaction.find_longest_consecutive_version(&rowsets2, nullptr); - ASSERT_EQ(1, rowsets2.size()); - ASSERT_EQ(0, rowsets[0]->end_version()); + EXPECT_EQ(1, rowsets2.size()); + EXPECT_EQ(0, rowsets[0]->end_version()); // no version std::vector rowsets3; compaction.find_longest_consecutive_version(&rowsets3, nullptr); - ASSERT_EQ(0, rowsets3.size()); + EXPECT_EQ(0, rowsets3.size()); } } // namespace doris // @brief Test Stub -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/decimal12_test.cpp b/be/test/olap/decimal12_test.cpp index ca7c40578c..35e250d958 100644 --- a/be/test/olap/decimal12_test.cpp +++ b/be/test/olap/decimal12_test.cpp @@ -27,52 +27,47 @@ TEST(FieldInfoTest, Add) { decimal12_t a = {a_integer, a_fraction}; decimal12_t b = {1, 0}; a += b; - ASSERT_EQ(a_integer + 1, a.integer); - ASSERT_EQ(a_fraction, a.fraction); + EXPECT_EQ(a_integer + 1, a.integer); + EXPECT_EQ(a_fraction, a.fraction); a.integer = -9223372036854775807L; a.fraction = -1; b.integer = 0; a += b; - ASSERT_EQ(-9223372036854775807L, a.integer); - ASSERT_EQ(-1, a.fraction); + EXPECT_EQ(-9223372036854775807L, a.integer); + EXPECT_EQ(-1, a.fraction); a.integer = -1; a.fraction = 0; b.integer = -7; b.fraction = 0; a += b; - ASSERT_EQ(-8, a.integer); - ASSERT_EQ(0, a.fraction); + EXPECT_EQ(-8, a.integer); + EXPECT_EQ(0, a.fraction); a.integer = 0; a.fraction = -1; b.integer = 0; b.fraction = -2; a += b; - ASSERT_EQ(0, a.integer); - ASSERT_EQ(-3, a.fraction); + EXPECT_EQ(0, a.integer); + EXPECT_EQ(-3, a.fraction); a.integer = 0; a.fraction = -999999999; b.integer = 0; b.fraction = -1; a += b; - ASSERT_EQ(-1, a.integer); - ASSERT_EQ(0, a.fraction); + EXPECT_EQ(-1, a.integer); + EXPECT_EQ(0, a.fraction); a.integer = -8; a.fraction = 0; b.integer = 2; b.fraction = 0; a += b; - ASSERT_EQ(-6, a.integer); - ASSERT_EQ(0, a.fraction); + EXPECT_EQ(-6, a.integer); + EXPECT_EQ(0, a.fraction); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/delete_handler_test.cpp b/be/test/olap/delete_handler_test.cpp index ee63658328..039ff828db 100644 --- a/be/test/olap/delete_handler_test.cpp +++ b/be/test/olap/delete_handler_test.cpp @@ -45,9 +45,9 @@ namespace doris { static const uint32_t MAX_PATH_LEN = 1024; static StorageEngine* k_engine = nullptr; -void set_up() { +static void set_up() { char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = string(buffer) + "/data_test"; FileUtils::remove_all(config::storage_root_path); FileUtils::remove_all(string(getenv("DORIS_HOME")) + UNUSED_PREFIX); @@ -62,18 +62,23 @@ void set_up() { doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); } -void tear_down() { +static void tear_down() { char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = string(buffer) + "/data_test"; FileUtils::remove_all(config::storage_root_path); FileUtils::remove_all(string(getenv("DORIS_HOME")) + UNUSED_PREFIX); + if (k_engine != nullptr) { + k_engine->stop(); + delete k_engine; + k_engine = nullptr; + } } -void set_default_create_tablet_request(TCreateTabletReq* request) { +static void set_default_create_tablet_request(TCreateTabletReq* request) { request->tablet_id = 10003; request->__set_version(1); request->tablet_schema.schema_hash = 270068375; @@ -153,7 +158,7 @@ void set_default_create_tablet_request(TCreateTabletReq* request) { request->tablet_schema.columns.push_back(v); } -void set_create_duplicate_tablet_request(TCreateTabletReq* request) { +static void set_create_duplicate_tablet_request(TCreateTabletReq* request) { request->tablet_id = 10009; request->__set_version(1); request->tablet_schema.schema_hash = 270068376; @@ -232,40 +237,41 @@ void set_create_duplicate_tablet_request(TCreateTabletReq* request) { request->tablet_schema.columns.push_back(v); } -void set_default_push_request(TPushReq* request) { - request->tablet_id = 10003; - request->schema_hash = 270068375; - request->timeout = 86400; - request->push_type = TPushType::LOAD; -} - class TestDeleteConditionHandler : public testing::Test { +public: + static void SetUpTestSuite() { + config::min_file_descriptor_number = 100; + set_up(); + } + + static void TearDownTestSuite() { tear_down(); } + protected: void SetUp() { // Create local data dir for StorageEngine. char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = string(buffer) + "/data_delete_condition"; FileUtils::remove_all(config::storage_root_path); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); // 1. Prepare for query split key. // create base tablet OLAPStatus res = OLAP_SUCCESS; set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_NE(tablet.get(), nullptr); + EXPECT_NE(tablet.get(), nullptr); _tablet_path = tablet->tablet_path_desc().filepath; set_create_duplicate_tablet_request(&_create_dup_tablet); res = k_engine->create_tablet(_create_dup_tablet); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); dup_tablet = k_engine->tablet_manager()->get_tablet( _create_dup_tablet.tablet_id, _create_dup_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(dup_tablet.get() != NULL); + EXPECT_TRUE(dup_tablet.get() != NULL); _dup_tablet_path = tablet->tablet_path_desc().filepath; } @@ -275,7 +281,7 @@ protected: dup_tablet.reset(); StorageEngine::instance()->tablet_manager()->drop_tablet( _create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); } std::string _tablet_path; @@ -338,10 +344,10 @@ TEST_F(TestDeleteConditionHandler, StoreCondSucceed) { DeletePredicatePB del_pred; success_res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, success_res); + EXPECT_EQ(OLAP_SUCCESS, success_res); // 验证存储在header中的过滤条件正确 - ASSERT_EQ(size_t(6), del_pred.sub_predicates_size()); + EXPECT_EQ(size_t(6), del_pred.sub_predicates_size()); EXPECT_STREQ("k1=1", del_pred.sub_predicates(0).c_str()); EXPECT_STREQ("k2>>3", del_pred.sub_predicates(1).c_str()); EXPECT_STREQ("k3<=5", del_pred.sub_predicates(2).c_str()); @@ -349,10 +355,10 @@ TEST_F(TestDeleteConditionHandler, StoreCondSucceed) { EXPECT_STREQ("k5=7", del_pred.sub_predicates(4).c_str()); EXPECT_STREQ("k12!=9", del_pred.sub_predicates(5).c_str()); - ASSERT_EQ(size_t(1), del_pred.in_predicates_size()); - ASSERT_FALSE(del_pred.in_predicates(0).is_not_in()); + EXPECT_EQ(size_t(1), del_pred.in_predicates_size()); + EXPECT_FALSE(del_pred.in_predicates(0).is_not_in()); EXPECT_STREQ("k13", del_pred.in_predicates(0).column_name().c_str()); - ASSERT_EQ(std::size_t(2), del_pred.in_predicates(0).values().size()); + EXPECT_EQ(std::size_t(2), del_pred.in_predicates(0).values().size()); } // 检测参数不正确的情况，包括：空的过滤条件字符串 @@ -363,7 +369,7 @@ TEST_F(TestDeleteConditionHandler, StoreCondInvalidParameters) { OLAPStatus failed_res = _delete_condition_handler.generate_delete_predicate( tablet->tablet_schema(), conditions, &del_pred); ; - ASSERT_EQ(OLAP_ERR_DELETE_INVALID_PARAMETERS, failed_res); + EXPECT_EQ(OLAP_ERR_DELETE_INVALID_PARAMETERS, failed_res); } // 检测过滤条件中指定的列不存在,或者列不符合要求 @@ -380,7 +386,7 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { OLAPStatus failed_res = _delete_condition_handler.generate_delete_predicate( tablet->tablet_schema(), conditions, &del_pred); ; - ASSERT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); + EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); // 'v'是value列 conditions.clear(); @@ -393,7 +399,7 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { failed_res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); ; - ASSERT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); + EXPECT_EQ(OLAP_ERR_DELETE_INVALID_CONDITION, failed_res); // value column in duplicate model can be deleted; conditions.clear(); @@ -406,38 +412,44 @@ TEST_F(TestDeleteConditionHandler, StoreCondNonexistentColumn) { OLAPStatus success_res = _delete_condition_handler.generate_delete_predicate( dup_tablet->tablet_schema(), conditions, &del_pred); ; - ASSERT_EQ(OLAP_SUCCESS, success_res); + EXPECT_EQ(OLAP_SUCCESS, success_res); } // 测试删除条件值不符合类型要求 class TestDeleteConditionHandler2 : public testing::Test { protected: + static void SetUpTestSuite() { + config::min_file_descriptor_number = 100; + set_up(); + } + + static void TearDownTestSuite() { tear_down(); } void SetUp() { // Create local data dir for StorageEngine. char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = string(buffer) + "/data_delete_condition"; FileUtils::remove_all(config::storage_root_path); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); // 1. Prepare for query split key. // create base tablet OLAPStatus res = OLAP_SUCCESS; set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(tablet.get() != nullptr); + EXPECT_TRUE(tablet.get() != nullptr); _tablet_path = tablet->tablet_path_desc().filepath; } void TearDown() { // Remove all dir. tablet.reset(); - StorageEngine::instance()->tablet_manager()->drop_tablet( - _create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); + k_engine->tablet_manager()->drop_tablet(_create_tablet.tablet_id, + _create_tablet.tablet_schema.schema_hash); + EXPECT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); } std::string _tablet_path; @@ -479,7 +491,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // k5类型为int128 conditions.clear(); @@ -492,7 +504,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // k9类型为decimal, precision=6, frac=3 conditions.clear(); @@ -505,28 +517,28 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("2"); DeletePredicatePB del_pred_4; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("-2"); DeletePredicatePB del_pred_5; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_5); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); conditions[0].condition_values.clear(); conditions[0].condition_values.push_back("-2.3"); DeletePredicatePB del_pred_6; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_6); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // k10,k11类型分别为date, datetime conditions.clear(); @@ -545,7 +557,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_7; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_7); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // k12,k13类型分别为string(64), varchar(64) conditions.clear(); @@ -564,7 +576,7 @@ TEST_F(TestDeleteConditionHandler2, ValidConditionValue) { DeletePredicatePB del_pred_8; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_8); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { @@ -777,25 +789,33 @@ TEST_F(TestDeleteConditionHandler2, InvalidConditionValue) { } class TestDeleteHandler : public testing::Test { +public: + static void SetUpTestSuite() { + config::min_file_descriptor_number = 100; + set_up(); + } + + static void TearDownTestSuite() { tear_down(); } + protected: void SetUp() { CpuInfo::init(); // Create local data dir for StorageEngine. char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = string(buffer) + "/data_delete_condition"; FileUtils::remove_all(config::storage_root_path); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); // 1. Prepare for query split key. // create base tablet OLAPStatus res = OLAP_SUCCESS; set_default_create_tablet_request(&_create_tablet); res = k_engine->create_tablet(_create_tablet); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet = k_engine->tablet_manager()->get_tablet(_create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); _tablet_path = tablet->tablet_path_desc().filepath; _data_row_cursor.init(tablet->tablet_schema()); @@ -808,7 +828,7 @@ protected: _delete_handler.finalize(); StorageEngine::instance()->tablet_manager()->drop_tablet( _create_tablet.tablet_id, _create_tablet.tablet_schema.schema_hash); - ASSERT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); } std::string _tablet_path; @@ -846,7 +866,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred, 1); conditions.clear(); @@ -859,7 +879,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_2, 2); conditions.clear(); @@ -872,7 +892,7 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_3, 3); conditions.clear(); @@ -885,13 +905,13 @@ TEST_F(TestDeleteHandler, InitSuccess) { DeletePredicatePB del_pred_4; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_4); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_4, 4); // 从header文件中取出版本号小于等于7的过滤条件 res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(4, _delete_handler.conditions_num()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(4, _delete_handler.conditions_num()); std::vector conds_version = _delete_handler.get_conds_version(); EXPECT_EQ(4, conds_version.size()); sort(conds_version.begin(), conds_version.end()); @@ -927,13 +947,13 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred, 1); // 指定版本号为10以载入Header中的所有过滤条件(在这个case中，只有过滤条件1) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(1, _delete_handler.conditions_num()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(1, _delete_handler.conditions_num()); // 构造一行测试数据 std::vector data_str; @@ -950,16 +970,16 @@ TEST_F(TestDeleteHandler, FilterDataSubconditions) { data_str.push_back("1"); OlapTuple tuple1(data_str); res = _data_row_cursor.from_tuple(tuple1); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_TRUE(_delete_handler.is_filter_data(1, _data_row_cursor)); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_TRUE(_delete_handler.is_filter_data(1, _data_row_cursor)); // 构造一行测试数据 data_str[1] = "4"; OlapTuple tuple2(data_str); res = _data_row_cursor.from_tuple(tuple2); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // 不满足子条件：k2!=4 - ASSERT_FALSE(_delete_handler.is_filter_data(1, _data_row_cursor)); + EXPECT_FALSE(_delete_handler.is_filter_data(1, _data_row_cursor)); _delete_handler.finalize(); } @@ -988,7 +1008,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred, 1); // 过滤条件2 @@ -1002,7 +1022,7 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_2, 2); // 过滤条件3 @@ -1016,13 +1036,13 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { DeletePredicatePB del_pred_3; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_3); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_3, 3); // 指定版本号为4以载入meta中的所有过滤条件(在这个case中，只有过滤条件1) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(3, _delete_handler.conditions_num()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(3, _delete_handler.conditions_num()); std::vector data_str; data_str.push_back("4"); @@ -1038,9 +1058,9 @@ TEST_F(TestDeleteHandler, FilterDataConditions) { data_str.push_back("1"); OlapTuple tuple(data_str); res = _data_row_cursor.from_tuple(tuple); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // 这行数据会因为过滤条件3而被过滤 - ASSERT_TRUE(_delete_handler.is_filter_data(3, _data_row_cursor)); + EXPECT_TRUE(_delete_handler.is_filter_data(3, _data_row_cursor)); _delete_handler.finalize(); } @@ -1068,7 +1088,7 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { DeletePredicatePB del_pred; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred, 3); // 过滤条件2 @@ -1082,13 +1102,13 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { DeletePredicatePB del_pred_2; res = _delete_condition_handler.generate_delete_predicate(tablet->tablet_schema(), conditions, &del_pred_2); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); tablet->add_delete_predicate(del_pred_2, 4); // 指定版本号为4以载入meta中的所有过滤条件(过滤条件1，过滤条件2) res = _delete_handler.init(tablet->tablet_schema(), tablet->delete_predicates(), 4); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(2, _delete_handler.conditions_num()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(2, _delete_handler.conditions_num()); // 构造一行测试数据 std::vector data_str; @@ -1105,26 +1125,13 @@ TEST_F(TestDeleteHandler, FilterDataVersion) { data_str.push_back("1"); OlapTuple tuple(data_str); res = _data_row_cursor.from_tuple(tuple); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // 如果数据版本小于3，则过滤条件1生效，这条数据被过滤 - ASSERT_TRUE(_delete_handler.is_filter_data(2, _data_row_cursor)); + EXPECT_TRUE(_delete_handler.is_filter_data(2, _data_row_cursor)); // 如果数据版本大于3，则过滤条件1会被跳过 - ASSERT_FALSE(_delete_handler.is_filter_data(4, _data_row_cursor)); + EXPECT_FALSE(_delete_handler.is_filter_data(4, _data_row_cursor)); _delete_handler.finalize(); } } // namespace doris - -int main(int argc, char** argv) { - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - - doris::set_up(); - ret = RUN_ALL_TESTS(); - doris::tear_down(); - - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/delta_writer_test.cpp b/be/test/olap/delta_writer_test.cpp index 8f279d1abf..be45fae591 100644 --- a/be/test/olap/delta_writer_test.cpp +++ b/be/test/olap/delta_writer_test.cpp @@ -46,11 +46,11 @@ namespace doris { static const uint32_t MAX_PATH_LEN = 1024; -StorageEngine* k_engine = nullptr; +static StorageEngine* k_engine = nullptr; -void set_up() { +static void set_up() { char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = std::string(buffer) + "/data_test"; FileUtils::remove_all(config::storage_root_path); FileUtils::create_dir(config::storage_root_path); @@ -60,24 +60,25 @@ void set_up() { doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); ExecEnv* exec_env = doris::ExecEnv::GetInstance(); exec_env->set_storage_engine(k_engine); k_engine->start_bg_threads(); } -void tear_down() { +static void tear_down() { if (k_engine != nullptr) { k_engine->stop(); delete k_engine; k_engine = nullptr; } - ASSERT_EQ(system("rm -rf ./data_test"), 0); + EXPECT_EQ(system("rm -rf ./data_test"), 0); FileUtils::remove_all(std::string(getenv("DORIS_HOME")) + UNUSED_PREFIX); } -void create_tablet_request(int64_t tablet_id, int32_t schema_hash, TCreateTabletReq* request) { +static void create_tablet_request(int64_t tablet_id, int32_t schema_hash, + TCreateTabletReq* request) { request->tablet_id = tablet_id; request->__set_version(1); request->tablet_schema.schema_hash = schema_hash; @@ -224,8 +225,8 @@ void create_tablet_request(int64_t tablet_id, int32_t schema_hash, TCreateTablet request->tablet_schema.columns.push_back(v10); } -void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_hash, - TCreateTabletReq* request) { +static void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_hash, + TCreateTabletReq* request) { request->tablet_id = tablet_id; request->__set_version(1); request->tablet_schema.schema_hash = schema_hash; @@ -261,7 +262,7 @@ void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_h request->tablet_schema.columns.push_back(v1); } -TDescriptorTable create_descriptor_tablet() { +static TDescriptorTable create_descriptor_tablet() { TDescriptorTableBuilder dtb; TTupleDescriptorBuilder tuple_builder; @@ -311,7 +312,7 @@ TDescriptorTable create_descriptor_tablet() { return dtb.desc_tbl(); } -TDescriptorTable create_descriptor_tablet_with_sequence_col() { +static TDescriptorTable create_descriptor_tablet_with_sequence_col() { TDescriptorTableBuilder dtb; TTupleDescriptorBuilder tuple_builder; @@ -335,25 +336,19 @@ class TestDeltaWriter : public ::testing::Test { public: TestDeltaWriter() {} ~TestDeltaWriter() {} - - void SetUp() { - // Create local data dir for StorageEngine. - std::cout << "setup" << std::endl; + static void SetUpTestSuite() { + config::min_file_descriptor_number = 100; + set_up(); } - void TearDown() { - // Remove all dir. - std::cout << "tear down" << std::endl; - //doris::tear_down(); - //ASSERT_EQ(OLAP_SUCCESS, remove_all_dir(config::storage_root_path)); - } + static void TearDownTestSuite() { tear_down(); } }; TEST_F(TestDeltaWriter, open) { TCreateTabletReq request; create_tablet_request(10003, 270068375, &request); OLAPStatus res = k_engine->create_tablet(request); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); TDescriptorTable tdesc_tbl = create_descriptor_tablet(); ObjectPool obj_pool; @@ -367,25 +362,25 @@ TEST_F(TestDeltaWriter, open) { WriteRequest write_req = {10003, 270068375, WriteType::LOAD, 20001, 30001, load_id, tuple_desc}; DeltaWriter* delta_writer = nullptr; DeltaWriter::open(&write_req, &delta_writer); - ASSERT_NE(delta_writer, nullptr); + EXPECT_NE(delta_writer, nullptr); res = delta_writer->close(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); res = delta_writer->close_wait(nullptr, false); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); SAFE_DELETE(delta_writer); TDropTabletReq drop_request; auto tablet_id = 10003; auto schema_hash = 270068375; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } TEST_F(TestDeltaWriter, write) { TCreateTabletReq request; create_tablet_request(10004, 270068376, &request); OLAPStatus res = k_engine->create_tablet(request); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); TDescriptorTable tdesc_tbl = create_descriptor_tablet(); ObjectPool obj_pool; @@ -401,7 +396,7 @@ TEST_F(TestDeltaWriter, write) { 30002, load_id, tuple_desc, &(tuple_desc->slots())}; DeltaWriter* delta_writer = nullptr; DeltaWriter::open(&write_req, &delta_writer); - ASSERT_NE(delta_writer, nullptr); + EXPECT_NE(delta_writer, nullptr); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -464,46 +459,39 @@ TEST_F(TestDeltaWriter, write) { *(DecimalV2Value*)(tuple->get_slot(slots[19]->tuple_offset())) = val_decimal; res = delta_writer->write(tuple); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } res = delta_writer->close(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); res = delta_writer->close_wait(nullptr, false); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // publish version success TabletSharedPtr tablet = k_engine->tablet_manager()->get_tablet(write_req.tablet_id, write_req.schema_hash); - std::cout << "before publish, tablet row nums:" << tablet->num_rows() << std::endl; OlapMeta* meta = tablet->data_dir()->get_meta(); Version version; version.first = tablet->rowset_with_max_version()->end_version() + 1; version.second = tablet->rowset_with_max_version()->end_version() + 1; - std::cout << "start to add rowset version:" << version.first << "-" << version.second - << std::endl; std::map tablet_related_rs; StorageEngine::instance()->txn_manager()->get_txn_related_tablets( write_req.txn_id, write_req.partition_id, &tablet_related_rs); for (auto& tablet_rs : tablet_related_rs) { - std::cout << "start to publish txn" << std::endl; RowsetSharedPtr rowset = tablet_rs.second; res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - ASSERT_EQ(OLAP_SUCCESS, res); - std::cout << "start to add inc rowset:" << rowset->rowset_id() - << ", num rows:" << rowset->num_rows() << ", version:" << rowset->version().first - << "-" << rowset->version().second << std::endl; + EXPECT_EQ(OLAP_SUCCESS, res); res = tablet->add_inc_rowset(rowset); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } - ASSERT_EQ(1, tablet->num_rows()); + EXPECT_EQ(1, tablet->num_rows()); auto tablet_id = 10003; auto schema_hash = 270068375; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); delete delta_writer; } @@ -511,7 +499,7 @@ TEST_F(TestDeltaWriter, sequence_col) { TCreateTabletReq request; create_tablet_request_with_sequence_col(10005, 270068377, &request); OLAPStatus res = k_engine->create_tablet(request); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); TDescriptorTable tdesc_tbl = create_descriptor_tablet_with_sequence_col(); ObjectPool obj_pool; @@ -527,7 +515,7 @@ TEST_F(TestDeltaWriter, sequence_col) { 30003, load_id, tuple_desc, &(tuple_desc->slots())}; DeltaWriter* delta_writer = nullptr; DeltaWriter::open(&write_req, &delta_writer); - ASSERT_NE(delta_writer, nullptr); + EXPECT_NE(delta_writer, nullptr); MemTracker tracker; MemPool pool(&tracker); @@ -542,63 +530,40 @@ TEST_F(TestDeltaWriter, sequence_col) { ->from_date_str("2020-07-16 19:39:43", 19); res = delta_writer->write(tuple); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } res = delta_writer->close(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); res = delta_writer->close_wait(nullptr, false); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // publish version success TabletSharedPtr tablet = k_engine->tablet_manager()->get_tablet(write_req.tablet_id, write_req.schema_hash); - std::cout << "before publish, tablet row nums:" << tablet->num_rows() << std::endl; OlapMeta* meta = tablet->data_dir()->get_meta(); Version version; version.first = tablet->rowset_with_max_version()->end_version() + 1; version.second = tablet->rowset_with_max_version()->end_version() + 1; - std::cout << "start to add rowset version:" << version.first << "-" << version.second - << std::endl; std::map tablet_related_rs; StorageEngine::instance()->txn_manager()->get_txn_related_tablets( write_req.txn_id, write_req.partition_id, &tablet_related_rs); for (auto& tablet_rs : tablet_related_rs) { - std::cout << "start to publish txn" << std::endl; RowsetSharedPtr rowset = tablet_rs.second; res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - ASSERT_EQ(OLAP_SUCCESS, res); - std::cout << "start to add inc rowset:" << rowset->rowset_id() - << ", num rows:" << rowset->num_rows() << ", version:" << rowset->version().first - << "-" << rowset->version().second << std::endl; + EXPECT_EQ(OLAP_SUCCESS, res); res = tablet->add_inc_rowset(rowset); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } - ASSERT_EQ(1, tablet->num_rows()); + EXPECT_EQ(1, tablet->num_rows()); auto tablet_id = 10005; auto schema_hash = 270068377; res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); delete delta_writer; } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - doris::set_up(); - ret = RUN_ALL_TESTS(); - doris::tear_down(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/engine_storage_migration_task_test.cpp b/be/test/olap/engine_storage_migration_task_test.cpp index 68c88f853f..2de5b1cb98 100644 --- a/be/test/olap/engine_storage_migration_task_test.cpp +++ b/be/test/olap/engine_storage_migration_task_test.cpp @@ -44,16 +44,17 @@ namespace doris { static const uint32_t MAX_PATH_LEN = 1024; -StorageEngine* k_engine = nullptr; -std::string path1; -std::string path2; +static StorageEngine* k_engine = nullptr; +static std::string path1; +static std::string path2; -void set_up() { +static void set_up() { char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); path1 = std::string(buffer) + "/data_test_1"; path2 = std::string(buffer) + "/data_test_2"; config::storage_root_path = path1 + ";" + path2; + config::min_file_descriptor_number = 1000; FileUtils::remove_all(path1); FileUtils::create_dir(path1); @@ -66,26 +67,26 @@ void set_up() { doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); ExecEnv* exec_env = doris::ExecEnv::GetInstance(); exec_env->set_storage_engine(k_engine); k_engine->start_bg_threads(); } -void tear_down() { +static void tear_down() { if (k_engine != nullptr) { k_engine->stop(); delete k_engine; k_engine = nullptr; } - ASSERT_EQ(system("rm -rf ./data_test_1"), 0); - ASSERT_EQ(system("rm -rf ./data_test_2"), 0); + EXPECT_EQ(system("rm -rf ./data_test_1"), 0); + EXPECT_EQ(system("rm -rf ./data_test_2"), 0); FileUtils::remove_all(std::string(getenv("DORIS_HOME")) + UNUSED_PREFIX); } -void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_hash, - TCreateTabletReq* request) { +static void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_hash, + TCreateTabletReq* request) { request->tablet_id = tablet_id; request->__set_version(1); request->tablet_schema.schema_hash = schema_hash; @@ -121,7 +122,7 @@ void create_tablet_request_with_sequence_col(int64_t tablet_id, int32_t schema_h request->tablet_schema.columns.push_back(v1); } -TDescriptorTable create_descriptor_tablet_with_sequence_col() { +static TDescriptorTable create_descriptor_tablet_with_sequence_col() { TDescriptorTableBuilder dtb; TTupleDescriptorBuilder tuple_builder; @@ -145,25 +146,19 @@ class TestEngineStorageMigrationTask : public ::testing::Test { public: TestEngineStorageMigrationTask() {} ~TestEngineStorageMigrationTask() {} - - void SetUp() { - // Create local data dir for StorageEngine. - std::cout << "setup" << std::endl; + static void SetUpTestSuite() { + config::min_file_descriptor_number = 100; + set_up(); } - void TearDown() { - // Remove all dir. - std::cout << "tear down" << std::endl; - //doris::tear_down(); - //ASSERT_EQ(OLAP_SUCCESS, remove_all_dir(config::storage_root_path)); - } + static void TearDownTestSuite() { tear_down(); } }; TEST_F(TestEngineStorageMigrationTask, write_and_migration) { TCreateTabletReq request; create_tablet_request_with_sequence_col(10005, 270068377, &request); OLAPStatus res = k_engine->create_tablet(request); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); TDescriptorTable tdesc_tbl = create_descriptor_tablet_with_sequence_col(); ObjectPool obj_pool; @@ -179,7 +174,7 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { 30003, load_id, tuple_desc, &(tuple_desc->slots())}; DeltaWriter* delta_writer = nullptr; DeltaWriter::open(&write_req, &delta_writer); - ASSERT_NE(delta_writer, nullptr); + EXPECT_NE(delta_writer, nullptr); MemTracker tracker; MemPool pool(&tracker); @@ -194,41 +189,34 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { ->from_date_str("2020-07-16 19:39:43", 19); res = delta_writer->write(tuple); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } res = delta_writer->close(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); res = delta_writer->close_wait(nullptr, false); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // publish version success TabletSharedPtr tablet = k_engine->tablet_manager()->get_tablet(write_req.tablet_id, write_req.schema_hash); - std::cout << "before publish, tablet row nums:" << tablet->num_rows() << std::endl; OlapMeta* meta = tablet->data_dir()->get_meta(); Version version; version.first = tablet->rowset_with_max_version()->end_version() + 1; version.second = tablet->rowset_with_max_version()->end_version() + 1; - std::cout << "start to add rowset version:" << version.first << "-" << version.second - << std::endl; std::map tablet_related_rs; StorageEngine::instance()->txn_manager()->get_txn_related_tablets( write_req.txn_id, write_req.partition_id, &tablet_related_rs); for (auto& tablet_rs : tablet_related_rs) { - std::cout << "start to publish txn" << std::endl; RowsetSharedPtr rowset = tablet_rs.second; res = k_engine->txn_manager()->publish_txn(meta, write_req.partition_id, write_req.txn_id, write_req.tablet_id, write_req.schema_hash, tablet_rs.first.tablet_uid, version); - ASSERT_EQ(OLAP_SUCCESS, res); - std::cout << "start to add inc rowset:" << rowset->rowset_id() - << ", num rows:" << rowset->num_rows() << ", version:" << rowset->version().first - << "-" << rowset->version().second << std::endl; + EXPECT_EQ(OLAP_SUCCESS, res); res = tablet->add_inc_rowset(rowset); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); } - ASSERT_EQ(1, tablet->num_rows()); + EXPECT_EQ(1, tablet->num_rows()); // we should sleep 1 second for the migrated tablet has different time with the current tablet sleep(1); @@ -240,63 +228,45 @@ TEST_F(TestEngineStorageMigrationTask, write_and_migration) { } else if (tablet->data_dir()->path() == path2) { dest_store = StorageEngine::instance()->get_store(path1); } - ASSERT_NE(dest_store, nullptr); - std::cout << "dest store:" << dest_store->path() << std::endl; + EXPECT_NE(dest_store, nullptr); // migrating EngineStorageMigrationTask engine_task(tablet, dest_store); res = engine_task.execute(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); // reget the tablet from manager after migration auto tablet_id = 10005; auto schema_hash = 270068377; TabletSharedPtr tablet2 = k_engine->tablet_manager()->get_tablet(tablet_id, schema_hash); // check path - ASSERT_EQ(tablet2->data_dir()->path(), dest_store->path()); + EXPECT_EQ(tablet2->data_dir()->path(), dest_store->path()); // check rows - ASSERT_EQ(1, tablet2->num_rows()); + EXPECT_EQ(1, tablet2->num_rows()); // tablet2 should not equal to tablet - ASSERT_NE(tablet2, tablet); + EXPECT_NE(tablet2, tablet); // test case 2 // migrate tablet2 back to the tablet's path // sleep 1 second for update time sleep(1); dest_store = StorageEngine::instance()->get_store(tablet->data_dir()->path()); - ASSERT_NE(dest_store, nullptr); - ASSERT_NE(dest_store->path(), tablet2->data_dir()->path()); - std::cout << "dest store:" << dest_store->path() << std::endl; + EXPECT_NE(dest_store, nullptr); + EXPECT_NE(dest_store->path(), tablet2->data_dir()->path()); EngineStorageMigrationTask engine_task2(tablet2, dest_store); res = engine_task2.execute(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); TabletSharedPtr tablet3 = k_engine->tablet_manager()->get_tablet(tablet_id, schema_hash); // check path - ASSERT_EQ(tablet3->data_dir()->path(), tablet->data_dir()->path()); + EXPECT_EQ(tablet3->data_dir()->path(), tablet->data_dir()->path()); // check rows - ASSERT_EQ(1, tablet3->num_rows()); + EXPECT_EQ(1, tablet3->num_rows()); // orgi_tablet should not equal to new_tablet and tablet - ASSERT_NE(tablet3, tablet2); - ASSERT_NE(tablet3, tablet); + EXPECT_NE(tablet3, tablet2); + EXPECT_NE(tablet3, tablet); // test case 2 end res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); delete delta_writer; } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - doris::set_up(); - ret = RUN_ALL_TESTS(); - doris::tear_down(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/file_helper_test.cpp b/be/test/olap/file_helper_test.cpp index 6b0833bb29..2bc2229bb5 100644 --- a/be/test/olap/file_helper_test.cpp +++ b/be/test/olap/file_helper_test.cpp @@ -26,7 +26,7 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "olap/olap_define.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/logging.h" #ifndef BE_TEST @@ -45,13 +45,13 @@ public: // create a mock cgroup folder virtual void SetUp() { std::filesystem::remove_all(_s_test_data_path); - ASSERT_FALSE(std::filesystem::exists(_s_test_data_path)); + EXPECT_FALSE(std::filesystem::exists(_s_test_data_path)); // create a mock cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_test_data_path)); + EXPECT_TRUE(std::filesystem::create_directory(_s_test_data_path)); } // delete the mock cgroup folder - virtual void TearDown() { ASSERT_TRUE(std::filesystem::remove_all(_s_test_data_path)); } + virtual void TearDown() { EXPECT_TRUE(std::filesystem::remove_all(_s_test_data_path)); } static std::string _s_test_data_path; }; @@ -62,35 +62,35 @@ TEST_F(FileHandlerTest, TestWrite) { FileHandler file_handler; std::string file_name = _s_test_data_path + "/abcd123.txt"; // create a file using open - ASSERT_FALSE(std::filesystem::exists(file_name)); + EXPECT_FALSE(std::filesystem::exists(file_name)); OLAPStatus op_status = file_handler.open_with_mode(file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR); - ASSERT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); - ASSERT_TRUE(std::filesystem::exists(file_name)); + EXPECT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); + EXPECT_TRUE(std::filesystem::exists(file_name)); // tell current offset off_t cur_offset = file_handler.tell(); - ASSERT_EQ(0, cur_offset); + EXPECT_EQ(0, cur_offset); off_t length = file_handler.length(); - ASSERT_EQ(0, length); + EXPECT_EQ(0, length); // seek to 10 and test offset off_t res = file_handler.seek(10, SEEK_SET); - ASSERT_EQ(10, res); + EXPECT_EQ(10, res); length = file_handler.length(); - ASSERT_EQ(0, length); + EXPECT_EQ(0, length); cur_offset = file_handler.tell(); - ASSERT_EQ(10, cur_offset); + EXPECT_EQ(10, cur_offset); // write 12 bytes to disk char ten_bytes[12]; memset(&ten_bytes, 0, sizeof(ten_bytes)); file_handler.write(&ten_bytes, sizeof(ten_bytes)); cur_offset = file_handler.tell(); - ASSERT_EQ(22, cur_offset); + EXPECT_EQ(22, cur_offset); length = file_handler.length(); - ASSERT_EQ(22, length); + EXPECT_EQ(22, length); char large_bytes2[(1 << 10)]; memset(&large_bytes2, 0, sizeof(large_bytes2)); @@ -102,14 +102,3 @@ TEST_F(FileHandlerTest, TestWrite) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/file_utils_test.cpp b/be/test/olap/file_utils_test.cpp index f5367d9864..0b0f390e62 100644 --- a/be/test/olap/file_utils_test.cpp +++ b/be/test/olap/file_utils_test.cpp @@ -47,9 +47,9 @@ class FileUtilsTest : public testing::Test { public: // create a mock cgroup folder virtual void SetUp() { - ASSERT_FALSE(std::filesystem::exists(_s_test_data_path)); + EXPECT_FALSE(std::filesystem::exists(_s_test_data_path)); // create a mock cgroup path - ASSERT_TRUE(std::filesystem::create_directory(_s_test_data_path)); + EXPECT_TRUE(std::filesystem::create_directory(_s_test_data_path)); } void save_string_file(const std::filesystem::path& filename, const std::string& content) { std::ofstream file; @@ -59,7 +59,7 @@ public: } // delete the mock cgroup folder - virtual void TearDown() { ASSERT_TRUE(std::filesystem::remove_all(_s_test_data_path)); } + virtual void TearDown() { EXPECT_TRUE(std::filesystem::remove_all(_s_test_data_path)); } static std::string _s_test_data_path; }; @@ -70,11 +70,11 @@ TEST_F(FileUtilsTest, TestCopyFile) { FileHandler src_file_handler; std::string src_file_name = _s_test_data_path + "/abcd12345.txt"; // create a file using open - ASSERT_FALSE(std::filesystem::exists(src_file_name)); + EXPECT_FALSE(std::filesystem::exists(src_file_name)); OLAPStatus op_status = src_file_handler.open_with_mode( src_file_name, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR); - ASSERT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); - ASSERT_TRUE(std::filesystem::exists(src_file_name)); + EXPECT_EQ(OLAPStatus::OLAP_SUCCESS, op_status); + EXPECT_TRUE(std::filesystem::exists(src_file_name)); char large_bytes2[(1 << 12)]; memset(&large_bytes2, 0, sizeof(large_bytes2)); @@ -92,43 +92,43 @@ TEST_F(FileUtilsTest, TestCopyFile) { dst_file_handler.open(dst_file_name, O_RDONLY); int64_t dst_length = dst_file_handler.length(); int64_t src_length = 4194317; - ASSERT_EQ(src_length, dst_length); + EXPECT_EQ(src_length, dst_length); } TEST_F(FileUtilsTest, TestRemove) { // remove_all - ASSERT_TRUE(FileUtils::remove_all("./file_test").ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test")); + EXPECT_TRUE(FileUtils::remove_all("./file_test").ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test")); - ASSERT_TRUE(FileUtils::create_dir("./file_test/123/456/789").ok()); - ASSERT_TRUE(FileUtils::create_dir("./file_test/abc/def/zxc").ok()); - ASSERT_TRUE(FileUtils::create_dir("./file_test/abc/123").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/123/456/789").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/abc/def/zxc").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/abc/123").ok()); save_string_file("./file_test/s1", "123"); save_string_file("./file_test/123/s2", "123"); - ASSERT_TRUE(FileUtils::check_exist("./file_test")); - ASSERT_TRUE(FileUtils::remove_all("./file_test").ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test")); + EXPECT_TRUE(FileUtils::check_exist("./file_test")); + EXPECT_TRUE(FileUtils::remove_all("./file_test").ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test")); // remove - ASSERT_TRUE(FileUtils::create_dir("./file_test/abc/123").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/abc/123").ok()); save_string_file("./file_test/abc/123/s2", "123"); - ASSERT_TRUE(FileUtils::check_exist("./file_test/abc/123/s2")); - ASSERT_TRUE(FileUtils::remove("./file_test/abc/123/s2").ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test/abc/123/s2")); + EXPECT_TRUE(FileUtils::check_exist("./file_test/abc/123/s2")); + EXPECT_TRUE(FileUtils::remove("./file_test/abc/123/s2").ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test/abc/123/s2")); - ASSERT_TRUE(FileUtils::check_exist("./file_test/abc/123")); - ASSERT_TRUE(FileUtils::remove("./file_test/abc/123/").ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test/abc/123")); + EXPECT_TRUE(FileUtils::check_exist("./file_test/abc/123")); + EXPECT_TRUE(FileUtils::remove("./file_test/abc/123/").ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test/abc/123")); - ASSERT_TRUE(FileUtils::remove_all("./file_test").ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test")); + EXPECT_TRUE(FileUtils::remove_all("./file_test").ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test")); // remove paths - ASSERT_TRUE(FileUtils::create_dir("./file_test/123/456/789").ok()); - ASSERT_TRUE(FileUtils::create_dir("./file_test/abc/def/zxc").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/123/456/789").ok()); + EXPECT_TRUE(FileUtils::create_dir("./file_test/abc/def/zxc").ok()); save_string_file("./file_test/s1", "123"); save_string_file("./file_test/s2", "123"); @@ -137,17 +137,17 @@ TEST_F(FileUtilsTest, TestRemove) { ps.push_back("./file_test/123/456"); ps.push_back("./file_test/123"); - ASSERT_TRUE(FileUtils::check_exist("./file_test/123")); - ASSERT_TRUE(FileUtils::remove_paths(ps).ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test/123")); + EXPECT_TRUE(FileUtils::check_exist("./file_test/123")); + EXPECT_TRUE(FileUtils::remove_paths(ps).ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test/123")); ps.clear(); ps.push_back("./file_test/s1"); ps.push_back("./file_test/abc/def"); - ASSERT_TRUE(FileUtils::remove_paths(ps).ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test/s1")); - ASSERT_FALSE(FileUtils::check_exist("./file_test/abc/def/")); + EXPECT_TRUE(FileUtils::remove_paths(ps).ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test/s1")); + EXPECT_FALSE(FileUtils::check_exist("./file_test/abc/def/")); ps.clear(); ps.push_back("./file_test/abc/def/zxc"); @@ -155,49 +155,49 @@ TEST_F(FileUtilsTest, TestRemove) { ps.push_back("./file_test/abc/def"); ps.push_back("./file_test/abc"); - ASSERT_TRUE(FileUtils::remove_paths(ps).ok()); - ASSERT_FALSE(FileUtils::check_exist("./file_test/s2")); - ASSERT_FALSE(FileUtils::check_exist("./file_test/abc")); + EXPECT_TRUE(FileUtils::remove_paths(ps).ok()); + EXPECT_FALSE(FileUtils::check_exist("./file_test/s2")); + EXPECT_FALSE(FileUtils::check_exist("./file_test/abc")); - ASSERT_TRUE(FileUtils::remove_all("./file_test").ok()); + EXPECT_TRUE(FileUtils::remove_all("./file_test").ok()); } TEST_F(FileUtilsTest, TestCreateDir) { // normal std::string path = "./file_test/123/456/789"; FileUtils::remove_all("./file_test"); - ASSERT_FALSE(FileUtils::check_exist(path)); + EXPECT_FALSE(FileUtils::check_exist(path)); - ASSERT_TRUE(FileUtils::create_dir(path).ok()); + EXPECT_TRUE(FileUtils::create_dir(path).ok()); - ASSERT_TRUE(FileUtils::check_exist(path)); - ASSERT_TRUE(FileUtils::is_dir("./file_test")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123/456")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123/456/789")); + EXPECT_TRUE(FileUtils::check_exist(path)); + EXPECT_TRUE(FileUtils::is_dir("./file_test")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123/456")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123/456/789")); FileUtils::remove_all("./file_test"); // normal path = "./file_test/123/456/789/"; FileUtils::remove_all("./file_test"); - ASSERT_FALSE(FileUtils::check_exist(path)); + EXPECT_FALSE(FileUtils::check_exist(path)); - ASSERT_TRUE(FileUtils::create_dir(path).ok()); + EXPECT_TRUE(FileUtils::create_dir(path).ok()); - ASSERT_TRUE(FileUtils::check_exist(path)); - ASSERT_TRUE(FileUtils::is_dir("./file_test")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123/456")); - ASSERT_TRUE(FileUtils::is_dir("./file_test/123/456/789")); + EXPECT_TRUE(FileUtils::check_exist(path)); + EXPECT_TRUE(FileUtils::is_dir("./file_test")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123/456")); + EXPECT_TRUE(FileUtils::is_dir("./file_test/123/456/789")); FileUtils::remove_all("./file_test"); // absolute path; std::string real_path; Env::Default()->canonicalize(".", &real_path); - ASSERT_TRUE(FileUtils::create_dir(real_path + "/file_test/absolute/path/123/asdf").ok()); - ASSERT_TRUE(FileUtils::is_dir("./file_test/absolute/path/123/asdf")); + EXPECT_TRUE(FileUtils::create_dir(real_path + "/file_test/absolute/path/123/asdf").ok()); + EXPECT_TRUE(FileUtils::is_dir("./file_test/absolute/path/123/asdf")); FileUtils::remove_all("./file_test"); } @@ -213,16 +213,16 @@ TEST_F(FileUtilsTest, TestListDirsFiles) { std::set dirs; std::set files; - ASSERT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, &files, Env::Default()).ok()); - ASSERT_EQ(5, dirs.size()); - ASSERT_EQ(0, files.size()); + EXPECT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, &files, Env::Default()).ok()); + EXPECT_EQ(5, dirs.size()); + EXPECT_EQ(0, files.size()); dirs.clear(); files.clear(); - ASSERT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, nullptr, Env::Default()).ok()); - ASSERT_EQ(5, dirs.size()); - ASSERT_EQ(0, files.size()); + EXPECT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, nullptr, Env::Default()).ok()); + EXPECT_EQ(5, dirs.size()); + EXPECT_EQ(0, files.size()); save_string_file("./file_test/f1", "just test"); save_string_file("./file_test/f2", "just test"); @@ -231,28 +231,17 @@ TEST_F(FileUtilsTest, TestListDirsFiles) { dirs.clear(); files.clear(); - ASSERT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, &files, Env::Default()).ok()); - ASSERT_EQ(5, dirs.size()); - ASSERT_EQ(3, files.size()); + EXPECT_TRUE(FileUtils::list_dirs_files("./file_test", &dirs, &files, Env::Default()).ok()); + EXPECT_EQ(5, dirs.size()); + EXPECT_EQ(3, files.size()); dirs.clear(); files.clear(); - ASSERT_TRUE(FileUtils::list_dirs_files("./file_test", nullptr, &files, Env::Default()).ok()); - ASSERT_EQ(0, dirs.size()); - ASSERT_EQ(3, files.size()); + EXPECT_TRUE(FileUtils::list_dirs_files("./file_test", nullptr, &files, Env::Default()).ok()); + EXPECT_EQ(0, dirs.size()); + EXPECT_EQ(3, files.size()); FileUtils::remove_all(path); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/fs/file_block_manager_test.cpp b/be/test/olap/fs/file_block_manager_test.cpp index 86fb6d9d39..e22a83a6f5 100644 --- a/be/test/olap/fs/file_block_manager_test.cpp +++ b/be/test/olap/fs/file_block_manager_test.cpp @@ -35,14 +35,14 @@ protected: void SetUp() override { if (FileUtils::check_exist(kBlockManagerDir)) { - ASSERT_TRUE(FileUtils::remove_all(kBlockManagerDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kBlockManagerDir).ok()); } - ASSERT_TRUE(FileUtils::create_dir(kBlockManagerDir).ok()); + EXPECT_TRUE(FileUtils::create_dir(kBlockManagerDir).ok()); } void TearDown() override { if (FileUtils::check_exist(kBlockManagerDir)) { - ASSERT_TRUE(FileUtils::remove_all(kBlockManagerDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kBlockManagerDir).ok()); } } }; @@ -58,7 +58,7 @@ TEST_F(FileBlockManagerTest, NormalTest) { std::string fname = kBlockManagerDir + "/test_file"; fs::CreateBlockOptions wblock_opts(fname); Status st = fbm->create_block(wblock_opts, &wblock); - ASSERT_TRUE(st.ok()) << st.get_error_msg(); + EXPECT_TRUE(st.ok()) << st.get_error_msg(); std::string data = "abcdefghijklmnopqrstuvwxyz"; wblock->append(data); @@ -69,18 +69,13 @@ TEST_F(FileBlockManagerTest, NormalTest) { std::unique_ptr rblock; st = fbm->open_block(path_desc, &rblock); uint64_t file_size = 0; - ASSERT_TRUE(rblock->size(&file_size).ok()); - ASSERT_EQ(data.size(), file_size); + EXPECT_TRUE(rblock->size(&file_size).ok()); + EXPECT_EQ(data.size(), file_size); std::string read_buff(data.size(), 'a'); Slice read_slice(read_buff); rblock->read(0, read_slice); - ASSERT_EQ(data, read_buff); + EXPECT_EQ(data, read_buff); rblock->close(); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/generic_iterators_test.cpp b/be/test/olap/generic_iterators_test.cpp index ebbef342d4..2b581ce387 100644 --- a/be/test/olap/generic_iterators_test.cpp +++ b/be/test/olap/generic_iterators_test.cpp @@ -53,7 +53,7 @@ TEST(GenericIteratorsTest, AutoIncrement) { StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowBlockV2 block(schema, 128); @@ -63,14 +63,14 @@ TEST(GenericIteratorsTest, AutoIncrement) { st = iter->next_batch(&block); for (int i = 0; i < block.num_rows(); ++i) { auto row = block.row(i); - ASSERT_EQ(row_count, *(int16_t*)row.cell_ptr(0)); - ASSERT_EQ(row_count + 1, *(int32_t*)row.cell_ptr(1)); - ASSERT_EQ(row_count + 2, *(int64_t*)row.cell_ptr(2)); + EXPECT_EQ(row_count, *(int16_t*)row.cell_ptr(0)); + EXPECT_EQ(row_count + 1, *(int32_t*)row.cell_ptr(1)); + EXPECT_EQ(row_count + 2, *(int64_t*)row.cell_ptr(2)); row_count++; } } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(500, row_count); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(500, row_count); delete iter; } @@ -86,7 +86,7 @@ TEST(GenericIteratorsTest, Union) { auto iter = new_union_iterator(inputs); StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowBlockV2 block(schema, 128); @@ -102,14 +102,14 @@ TEST(GenericIteratorsTest, Union) { base_value -= 100; } auto row = block.row(i); - ASSERT_EQ(base_value, *(int16_t*)row.cell_ptr(0)); - ASSERT_EQ(base_value + 1, *(int32_t*)row.cell_ptr(1)); - ASSERT_EQ(base_value + 2, *(int64_t*)row.cell_ptr(2)); + EXPECT_EQ(base_value, *(int16_t*)row.cell_ptr(0)); + EXPECT_EQ(base_value + 1, *(int32_t*)row.cell_ptr(1)); + EXPECT_EQ(base_value + 2, *(int64_t*)row.cell_ptr(2)); row_count++; } } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(600, row_count); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(600, row_count); delete iter; } @@ -125,7 +125,7 @@ TEST(GenericIteratorsTest, Merge) { auto iter = new_merge_iterator(std::move(inputs), -1); StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowBlockV2 block(schema, 128); @@ -144,21 +144,16 @@ TEST(GenericIteratorsTest, Merge) { base_value = row_count - 300; } auto row = block.row(i); - ASSERT_EQ(base_value, *(int16_t*)row.cell_ptr(0)); - ASSERT_EQ(base_value + 1, *(int32_t*)row.cell_ptr(1)); - ASSERT_EQ(base_value + 2, *(int64_t*)row.cell_ptr(2)); + EXPECT_EQ(base_value, *(int16_t*)row.cell_ptr(0)); + EXPECT_EQ(base_value + 1, *(int32_t*)row.cell_ptr(1)); + EXPECT_EQ(base_value + 2, *(int64_t*)row.cell_ptr(2)); row_count++; } } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(600, row_count); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(600, row_count); delete iter; } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/hll_test.cpp b/be/test/olap/hll_test.cpp index 5f1572e1b8..3131efdeb2 100644 --- a/be/test/olap/hll_test.cpp +++ b/be/test/olap/hll_test.cpp @@ -39,31 +39,31 @@ TEST_F(TestHll, Normal) { // empty { Slice str((char*)buf, 0); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } // check unknown type { buf[0] = 60; Slice str((char*)buf, 1); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } // empty { HyperLogLog empty_hll; int len = empty_hll.serialize(buf); - ASSERT_EQ(1, len); + EXPECT_EQ(1, len); HyperLogLog test_hll(Slice((char*)buf, len)); - ASSERT_EQ(0, test_hll.estimate_cardinality()); + EXPECT_EQ(0, test_hll.estimate_cardinality()); // check serialize { Slice str((char*)buf, len); - ASSERT_TRUE(HyperLogLog::is_valid(str)); + EXPECT_TRUE(HyperLogLog::is_valid(str)); } { Slice str((char*)buf, len + 1); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } } // explicit [0. 100) @@ -73,16 +73,16 @@ TEST_F(TestHll, Normal) { explicit_hll.update(hash(i)); } int len = explicit_hll.serialize(buf); - ASSERT_EQ(1 + 1 + 100 * 8, len); + EXPECT_EQ(1 + 1 + 100 * 8, len); // check serialize { Slice str((char*)buf, len); - ASSERT_TRUE(HyperLogLog::is_valid(str)); + EXPECT_TRUE(HyperLogLog::is_valid(str)); } { Slice str((char*)buf, 1); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } HyperLogLog test_hll(Slice((char*)buf, len)); @@ -94,7 +94,7 @@ TEST_F(TestHll, Normal) { } test_hll.merge(other_hll); } - ASSERT_EQ(100, test_hll.estimate_cardinality()); + EXPECT_EQ(100, test_hll.estimate_cardinality()); } // sparse [1024, 2048) HyperLogLog sparse_hll; @@ -103,16 +103,16 @@ TEST_F(TestHll, Normal) { sparse_hll.update(hash(i + 1024)); } int len = sparse_hll.serialize(buf); - ASSERT_TRUE(len < HLL_REGISTERS_COUNT + 1); + EXPECT_TRUE(len < HLL_REGISTERS_COUNT + 1); // check serialize { Slice str((char*)buf, len); - ASSERT_TRUE(HyperLogLog::is_valid(str)); + EXPECT_TRUE(HyperLogLog::is_valid(str)); } { Slice str((char*)buf, 1 + 3); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } HyperLogLog test_hll(Slice((char*)buf, len)); @@ -125,9 +125,9 @@ TEST_F(TestHll, Normal) { test_hll.merge(other_hll); } auto cardinality = test_hll.estimate_cardinality(); - ASSERT_EQ(sparse_hll.estimate_cardinality(), cardinality); + EXPECT_EQ(sparse_hll.estimate_cardinality(), cardinality); // 2% error rate - ASSERT_TRUE(cardinality > 1000 && cardinality < 1045); + EXPECT_TRUE(cardinality > 1000 && cardinality < 1045); } // full [64 * 1024, 128 * 1024) HyperLogLog full_hll; @@ -136,29 +136,29 @@ TEST_F(TestHll, Normal) { full_hll.update(hash(64 * 1024 + i)); } int len = full_hll.serialize(buf); - ASSERT_EQ(HLL_REGISTERS_COUNT + 1, len); + EXPECT_EQ(HLL_REGISTERS_COUNT + 1, len); // check serialize { Slice str((char*)buf, len); - ASSERT_TRUE(HyperLogLog::is_valid(str)); + EXPECT_TRUE(HyperLogLog::is_valid(str)); } { Slice str((char*)buf, len + 1); - ASSERT_FALSE(HyperLogLog::is_valid(str)); + EXPECT_FALSE(HyperLogLog::is_valid(str)); } HyperLogLog test_hll(Slice((char*)buf, len)); auto cardinality = test_hll.estimate_cardinality(); - ASSERT_EQ(full_hll.estimate_cardinality(), cardinality); + EXPECT_EQ(full_hll.estimate_cardinality(), cardinality); // 2% error rate - ASSERT_TRUE(cardinality > 62 * 1024 && cardinality < 66 * 1024); + EXPECT_TRUE(cardinality > 62 * 1024 && cardinality < 66 * 1024); } // merge explicit to empty_hll { HyperLogLog new_explicit_hll; new_explicit_hll.merge(explicit_hll); - ASSERT_EQ(100, new_explicit_hll.estimate_cardinality()); + EXPECT_EQ(100, new_explicit_hll.estimate_cardinality()); // merge another explicit { @@ -168,45 +168,40 @@ TEST_F(TestHll, Normal) { } // this is converted to full other_hll.merge(new_explicit_hll); - ASSERT_TRUE(other_hll.estimate_cardinality() > 190); + EXPECT_TRUE(other_hll.estimate_cardinality() > 190); } // merge full { new_explicit_hll.merge(full_hll); - ASSERT_TRUE(new_explicit_hll.estimate_cardinality() > full_hll.estimate_cardinality()); + EXPECT_TRUE(new_explicit_hll.estimate_cardinality() > full_hll.estimate_cardinality()); } } // merge sparse to empty_hll { HyperLogLog new_sparse_hll; new_sparse_hll.merge(sparse_hll); - ASSERT_EQ(sparse_hll.estimate_cardinality(), new_sparse_hll.estimate_cardinality()); + EXPECT_EQ(sparse_hll.estimate_cardinality(), new_sparse_hll.estimate_cardinality()); // merge explicit new_sparse_hll.merge(explicit_hll); - ASSERT_TRUE(new_sparse_hll.estimate_cardinality() > sparse_hll.estimate_cardinality()); + EXPECT_TRUE(new_sparse_hll.estimate_cardinality() > sparse_hll.estimate_cardinality()); // merge full new_sparse_hll.merge(full_hll); - ASSERT_TRUE(new_sparse_hll.estimate_cardinality() > full_hll.estimate_cardinality()); + EXPECT_TRUE(new_sparse_hll.estimate_cardinality() > full_hll.estimate_cardinality()); } } TEST_F(TestHll, InvalidPtr) { { HyperLogLog hll(Slice((char*)nullptr, 0)); - ASSERT_EQ(0, hll.estimate_cardinality()); + EXPECT_EQ(0, hll.estimate_cardinality()); } { uint8_t buf[64] = {60}; HyperLogLog hll(Slice(buf, 1)); - ASSERT_EQ(0, hll.estimate_cardinality()); + EXPECT_EQ(0, hll.estimate_cardinality()); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/in_list_predicate_test.cpp b/be/test/olap/in_list_predicate_test.cpp index a3456264be..285e6ea375 100644 --- a/be/test/olap/in_list_predicate_test.cpp +++ b/be/test/olap/in_list_predicate_test.cpp @@ -163,11 +163,11 @@ public: values.insert(6); \ ColumnPredicate* pred = new InListPredicate(0, std::move(values)); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 3); \ + EXPECT_EQ(_vectorized_batch->size(), 3); \ uint16_t* sel = _vectorized_batch->selected(); \ - ASSERT_EQ(*(col_data + sel[0]), 4); \ - ASSERT_EQ(*(col_data + sel[1]), 5); \ - ASSERT_EQ(*(col_data + sel[2]), 6); \ + EXPECT_EQ(*(col_data + sel[0]), 4); \ + EXPECT_EQ(*(col_data + sel[1]), 5); \ + EXPECT_EQ(*(col_data + sel[2]), 6); \ \ /* for has nulls */ \ col_vector->set_no_nulls(false); \ @@ -184,9 +184,9 @@ public: _vectorized_batch->set_size(size); \ _vectorized_batch->set_selected_in_use(false); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 1); \ + EXPECT_EQ(_vectorized_batch->size(), 1); \ sel = _vectorized_batch->selected(); \ - ASSERT_EQ(*(col_data + sel[0]), 5); \ + EXPECT_EQ(*(col_data + sel[0]), 5); \ delete pred; \ } @@ -223,10 +223,10 @@ TEST_IN_LIST_PREDICATE(int128_t, LARGEINT, "LARGEINT") } \ \ pred->evaluate(&column, sel, &selected_size); \ - ASSERT_EQ(selected_size, 3); \ - ASSERT_EQ(*((TYPE*)column.cell_ptr(sel[0])), 4); \ - ASSERT_EQ(*((TYPE*)column.cell_ptr(sel[1])), 5); \ - ASSERT_EQ(*((TYPE*)column.cell_ptr(sel[2])), 6); \ + EXPECT_EQ(selected_size, 3); \ + EXPECT_EQ(*((TYPE*)column.cell_ptr(sel[0])), 4); \ + EXPECT_EQ(*((TYPE*)column.cell_ptr(sel[1])), 5); \ + EXPECT_EQ(*((TYPE*)column.cell_ptr(sel[2])), 6); \ \ /* for has nulls */ \ TabletSchema tablet_schema2; \ @@ -250,8 +250,8 @@ TEST_IN_LIST_PREDICATE(int128_t, LARGEINT, "LARGEINT") selected_size = 10; \ \ pred->evaluate(&column2, sel, &selected_size); \ - ASSERT_EQ(selected_size, 1); \ - ASSERT_EQ(*((TYPE*)column2.cell_ptr(sel[0])), 5); \ + EXPECT_EQ(selected_size, 1); \ + EXPECT_EQ(*((TYPE*)column2.cell_ptr(sel[0])), 5); \ delete pred; \ } @@ -285,11 +285,11 @@ TEST_F(TestInListPredicate, FLOAT_COLUMN) { *(col_data + i) = i + 0.1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 4.1); - ASSERT_FLOAT_EQ(*(col_data + sel[1]), 5.1); - ASSERT_FLOAT_EQ(*(col_data + sel[2]), 6.1); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 4.1); + EXPECT_FLOAT_EQ(*(col_data + sel[1]), 5.1); + EXPECT_FLOAT_EQ(*(col_data + sel[2]), 6.1); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -301,10 +301,10 @@ TEST_F(TestInListPredicate, FLOAT_COLUMN) { *reinterpret_cast(col_block_view.data()) = i + 0.1f; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); + EXPECT_EQ(select_size, 3); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -321,9 +321,9 @@ TEST_F(TestInListPredicate, FLOAT_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_FLOAT_EQ(*(col_data + sel[0]), 5.1); + EXPECT_FLOAT_EQ(*(col_data + sel[0]), 5.1); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -338,8 +338,8 @@ TEST_F(TestInListPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); + EXPECT_EQ(select_size, 1); + EXPECT_FLOAT_EQ(*(float*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); delete pred; } @@ -370,11 +370,11 @@ TEST_F(TestInListPredicate, DOUBLE_COLUMN) { *(col_data + i) = i + 0.1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_DOUBLE_EQ(*(col_data + sel[0]), 4.1); - ASSERT_DOUBLE_EQ(*(col_data + sel[1]), 5.1); - ASSERT_DOUBLE_EQ(*(col_data + sel[2]), 6.1); + EXPECT_DOUBLE_EQ(*(col_data + sel[0]), 4.1); + EXPECT_DOUBLE_EQ(*(col_data + sel[1]), 5.1); + EXPECT_DOUBLE_EQ(*(col_data + sel[2]), 6.1); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -386,10 +386,10 @@ TEST_F(TestInListPredicate, DOUBLE_COLUMN) { *reinterpret_cast(col_block_view.data()) = i + 0.1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); + EXPECT_EQ(select_size, 3); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 4.1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), 5.1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), 6.1); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -406,9 +406,9 @@ TEST_F(TestInListPredicate, DOUBLE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_DOUBLE_EQ(*(col_data + sel[0]), 5.1); + EXPECT_DOUBLE_EQ(*(col_data + sel[0]), 5.1); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -423,8 +423,8 @@ TEST_F(TestInListPredicate, DOUBLE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); + EXPECT_EQ(select_size, 1); + EXPECT_DOUBLE_EQ(*(double*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), 5.1); delete pred; } @@ -461,11 +461,11 @@ TEST_F(TestInListPredicate, DECIMAL_COLUMN) { (*(col_data + i)).fraction = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value1); - ASSERT_EQ(*(col_data + sel[1]), value2); - ASSERT_EQ(*(col_data + sel[2]), value3); + EXPECT_EQ(*(col_data + sel[0]), value1); + EXPECT_EQ(*(col_data + sel[1]), value2); + EXPECT_EQ(*(col_data + sel[2]), value3); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -478,10 +478,10 @@ TEST_F(TestInListPredicate, DECIMAL_COLUMN) { reinterpret_cast(col_block_view.data())->fraction = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); + EXPECT_EQ(select_size, 3); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -499,9 +499,9 @@ TEST_F(TestInListPredicate, DECIMAL_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value2); + EXPECT_EQ(*(col_data + sel[0]), value2); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -517,8 +517,8 @@ TEST_F(TestInListPredicate, DECIMAL_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(decimal12_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); delete pred; } @@ -571,11 +571,11 @@ TEST_F(TestInListPredicate, CHAR_COLUMN) { string_buffer += 5; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value1); - ASSERT_EQ(*(col_data + sel[1]), value2); - ASSERT_EQ(*(col_data + sel[2]), value3); + EXPECT_EQ(*(col_data + sel[0]), value1); + EXPECT_EQ(*(col_data + sel[1]), value2); + EXPECT_EQ(*(col_data + sel[2]), value3); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -594,10 +594,10 @@ TEST_F(TestInListPredicate, CHAR_COLUMN) { string_buffer += 5; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); + EXPECT_EQ(select_size, 3); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -621,9 +621,9 @@ TEST_F(TestInListPredicate, CHAR_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value2); + EXPECT_EQ(*(col_data + sel[0]), value2); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -644,8 +644,8 @@ TEST_F(TestInListPredicate, CHAR_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); delete pred; } @@ -698,11 +698,11 @@ TEST_F(TestInListPredicate, VARCHAR_COLUMN) { string_buffer += i + 1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value1); - ASSERT_EQ(*(col_data + sel[1]), value2); - ASSERT_EQ(*(col_data + sel[2]), value3); + EXPECT_EQ(*(col_data + sel[0]), value1); + EXPECT_EQ(*(col_data + sel[1]), value2); + EXPECT_EQ(*(col_data + sel[2]), value3); // for ColumnBlock no null init_row_block(&tablet_schema, size); @@ -721,10 +721,10 @@ TEST_F(TestInListPredicate, VARCHAR_COLUMN) { string_buffer += i + 1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); + EXPECT_EQ(select_size, 3); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr(), value2); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr(), value3); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -747,9 +747,9 @@ TEST_F(TestInListPredicate, VARCHAR_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(*(col_data + sel[0]), value2); + EXPECT_EQ(*(col_data + sel[0]), value2); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -770,8 +770,8 @@ TEST_F(TestInListPredicate, VARCHAR_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); + EXPECT_EQ(select_size, 1); + EXPECT_EQ(*(StringValue*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr(), value2); delete pred; } @@ -814,11 +814,11 @@ TEST_F(TestInListPredicate, DATE_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-09"); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[1])), "2017-09-10"); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[2])), "2017-09-11"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-09"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[1])), "2017-09-10"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[2])), "2017-09-11"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -831,14 +831,14 @@ TEST_F(TestInListPredicate, DATE_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 3); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-09"); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr()), "2017-09-10"); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr()), "2017-09-11"); @@ -858,9 +858,9 @@ TEST_F(TestInListPredicate, DATE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); + EXPECT_EQ(datetime::to_date_string(*(col_data + sel[0])), "2017-09-10"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -876,8 +876,8 @@ TEST_F(TestInListPredicate, DATE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_date_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_date_string( *(uint24_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10"); @@ -924,11 +924,11 @@ TEST_F(TestInListPredicate, DATETIME_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 3); + EXPECT_EQ(_vectorized_batch->size(), 3); uint16_t* sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-09 00:00:01"); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[1])), "2017-09-10 01:00:00"); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[2])), "2017-09-11 01:01:00"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-09 00:00:01"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[1])), "2017-09-10 01:00:00"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[2])), "2017-09-11 01:01:00"); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -941,14 +941,14 @@ TEST_F(TestInListPredicate, DATETIME_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 3); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 3); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-09 00:00:01"); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[1]).cell_ptr()), "2017-09-10 01:00:00"); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[2]).cell_ptr()), "2017-09-11 01:01:00"); @@ -968,9 +968,9 @@ TEST_F(TestInListPredicate, DATETIME_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 1); + EXPECT_EQ(_vectorized_batch->size(), 1); sel = _vectorized_batch->selected(); - ASSERT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); + EXPECT_EQ(datetime::to_datetime_string(*(col_data + sel[0])), "2017-09-10 01:00:00"); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -986,8 +986,8 @@ TEST_F(TestInListPredicate, DATETIME_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 1); - ASSERT_EQ(datetime::to_datetime_string( + EXPECT_EQ(select_size, 1); + EXPECT_EQ(datetime::to_datetime_string( *(uint64_t*)col_block.cell(_row_block->selection_vector()[0]).cell_ptr()), "2017-09-10 01:00:00"); @@ -995,18 +995,3 @@ TEST_F(TestInListPredicate, DATETIME_COLUMN) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/key_coder_test.cpp b/be/test/olap/key_coder_test.cpp index 32b709f197..96f6210f21 100644 --- a/be/test/olap/key_coder_test.cpp +++ b/be/test/olap/key_coder_test.cpp @@ -54,13 +54,13 @@ void test_integer_encode() { result.append("00"); } - ASSERT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); + EXPECT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); { Slice slice(buf); CppType check_val; key_coder->decode_ascending(&slice, sizeof(CppType), (uint8_t*)&check_val, nullptr); - ASSERT_EQ(val, check_val); + EXPECT_EQ(val, check_val); } } @@ -74,12 +74,12 @@ void test_integer_encode() { result.append("FF"); } - ASSERT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); + EXPECT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); { Slice slice(buf); CppType check_val; key_coder->decode_ascending(&slice, sizeof(CppType), (uint8_t*)&check_val, nullptr); - ASSERT_EQ(val, check_val); + EXPECT_EQ(val, check_val); } } @@ -94,11 +94,11 @@ void test_integer_encode() { key_coder->encode_ascending(&val2, sizeof(CppType), &buf2); if (val1 < val2) { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); } else if (val1 > val2) { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); } else { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) == 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) == 0); } } } @@ -129,13 +129,13 @@ TEST_F(KeyCoderTest, test_date) { result.append("00"); } - ASSERT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); + EXPECT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); { Slice slice(buf); CppType check_val; key_coder->decode_ascending(&slice, sizeof(CppType), (uint8_t*)&check_val, nullptr); - ASSERT_EQ(val, check_val); + EXPECT_EQ(val, check_val); } } @@ -146,12 +146,12 @@ TEST_F(KeyCoderTest, test_date) { std::string result("002710"); - ASSERT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); + EXPECT_STREQ(result.c_str(), hexdump(buf.data(), buf.size()).c_str()); { Slice slice(buf); CppType check_val; key_coder->decode_ascending(&slice, sizeof(CppType), (uint8_t*)&check_val, nullptr); - ASSERT_EQ(val, check_val); + EXPECT_EQ(val, check_val); } } @@ -166,11 +166,11 @@ TEST_F(KeyCoderTest, test_date) { key_coder->encode_ascending(&val2, sizeof(CppType), &buf2); if (val1 < val2) { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); } else if (val1 > val2) { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); } else { - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) == 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) == 0); } } } @@ -186,25 +186,25 @@ TEST_F(KeyCoderTest, test_decimal) { decimal12_t check_val; Slice slice1(buf1); key_coder->decode_ascending(&slice1, sizeof(decimal12_t), (uint8_t*)&check_val, nullptr); - ASSERT_EQ(check_val, val1); + EXPECT_EQ(check_val, val1); { decimal12_t val2 = {-1, -100000000}; std::string buf2; key_coder->encode_ascending(&val2, sizeof(decimal12_t), &buf2); - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); } { decimal12_t val2 = {1, 100000001}; std::string buf2; key_coder->encode_ascending(&val2, sizeof(decimal12_t), &buf2); - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) < 0); } { decimal12_t val2 = {0, 0}; std::string buf2; key_coder->encode_ascending(&val2, sizeof(decimal12_t), &buf2); - ASSERT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); + EXPECT_TRUE(memcmp(buf1.c_str(), buf2.c_str(), buf1.size()) > 0); std::string result("80"); for (int i = 0; i < sizeof(int64_t) - 1; ++i) { @@ -215,7 +215,7 @@ TEST_F(KeyCoderTest, test_decimal) { result.append("00"); } - ASSERT_STREQ(result.c_str(), hexdump(buf2.data(), buf2.size()).c_str()); + EXPECT_STREQ(result.c_str(), hexdump(buf2.data(), buf2.size()).c_str()); } } @@ -232,10 +232,10 @@ TEST_F(KeyCoderTest, test_char) { Slice check_slice; auto st = key_coder->decode_ascending(&encoded_key, 10, (uint8_t*)&check_slice, &_pool); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_EQ(10, check_slice.size); - ASSERT_EQ(strncmp("1234567890", check_slice.data, 10), 0); + EXPECT_EQ(10, check_slice.size); + EXPECT_EQ(strncmp("1234567890", check_slice.data, 10), 0); } { @@ -245,10 +245,10 @@ TEST_F(KeyCoderTest, test_char) { Slice check_slice; auto st = key_coder->decode_ascending(&encoded_key, 5, (uint8_t*)&check_slice, &_pool); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_EQ(5, check_slice.size); - ASSERT_EQ(strncmp("12345", check_slice.data, 5), 0); + EXPECT_EQ(5, check_slice.size); + EXPECT_EQ(strncmp("12345", check_slice.data, 5), 0); } } @@ -265,10 +265,10 @@ TEST_F(KeyCoderTest, test_varchar) { Slice check_slice; auto st = key_coder->decode_ascending(&encoded_key, 15, (uint8_t*)&check_slice, &_pool); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_EQ(10, check_slice.size); - ASSERT_EQ(strncmp("1234567890", check_slice.data, 10), 0); + EXPECT_EQ(10, check_slice.size); + EXPECT_EQ(strncmp("1234567890", check_slice.data, 10), 0); } { @@ -278,16 +278,11 @@ TEST_F(KeyCoderTest, test_varchar) { Slice check_slice; auto st = key_coder->decode_ascending(&encoded_key, 5, (uint8_t*)&check_slice, &_pool); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_EQ(5, check_slice.size); - ASSERT_EQ(strncmp("12345", check_slice.data, 5), 0); + EXPECT_EQ(5, check_slice.size); + EXPECT_EQ(strncmp("12345", check_slice.data, 5), 0); } } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/lru_cache_test.cpp b/be/test/olap/lru_cache_test.cpp index d71fdeb936..247fd107ec 100644 --- a/be/test/olap/lru_cache_test.cpp +++ b/be/test/olap/lru_cache_test.cpp @@ -21,7 +21,7 @@ #include -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/logging.h" using namespace doris; @@ -116,75 +116,72 @@ public: CacheTest* CacheTest::_s_current; TEST_F(CacheTest, HitAndMiss) { - ASSERT_EQ(-1, Lookup(100)); + EXPECT_EQ(-1, Lookup(100)); Insert(100, 101, 1); - ASSERT_EQ(101, Lookup(100)); - ASSERT_EQ(-1, Lookup(200)); - ASSERT_EQ(-1, Lookup(300)); + EXPECT_EQ(101, Lookup(100)); + EXPECT_EQ(-1, Lookup(200)); + EXPECT_EQ(-1, Lookup(300)); Insert(200, 201, 1); - ASSERT_EQ(101, Lookup(100)); - ASSERT_EQ(201, Lookup(200)); - ASSERT_EQ(-1, Lookup(300)); + EXPECT_EQ(101, Lookup(100)); + EXPECT_EQ(201, Lookup(200)); + EXPECT_EQ(-1, Lookup(300)); Insert(100, 102, 1); - ASSERT_EQ(102, Lookup(100)); - ASSERT_EQ(201, Lookup(200)); - ASSERT_EQ(-1, Lookup(300)); + EXPECT_EQ(102, Lookup(100)); + EXPECT_EQ(201, Lookup(200)); + EXPECT_EQ(-1, Lookup(300)); - ASSERT_EQ(1, _deleted_keys.size()); - ASSERT_EQ(100, _deleted_keys[0]); - ASSERT_EQ(101, _deleted_values[0]); + EXPECT_EQ(1, _deleted_keys.size()); + EXPECT_EQ(100, _deleted_keys[0]); + EXPECT_EQ(101, _deleted_values[0]); } TEST_F(CacheTest, Erase) { Erase(200); - ASSERT_EQ(0, _deleted_keys.size()); + EXPECT_EQ(0, _deleted_keys.size()); Insert(100, 101, 1); Insert(200, 201, 1); Erase(100); - ASSERT_EQ(-1, Lookup(100)); - ASSERT_EQ(201, Lookup(200)); - ASSERT_EQ(1, _deleted_keys.size()); - ASSERT_EQ(100, _deleted_keys[0]); - ASSERT_EQ(101, _deleted_values[0]); + EXPECT_EQ(-1, Lookup(100)); + EXPECT_EQ(201, Lookup(200)); + EXPECT_EQ(1, _deleted_keys.size()); + EXPECT_EQ(100, _deleted_keys[0]); + EXPECT_EQ(101, _deleted_values[0]); Erase(100); - ASSERT_EQ(-1, Lookup(100)); - ASSERT_EQ(201, Lookup(200)); - ASSERT_EQ(1, _deleted_keys.size()); + EXPECT_EQ(-1, Lookup(100)); + EXPECT_EQ(201, Lookup(200)); + EXPECT_EQ(1, _deleted_keys.size()); } TEST_F(CacheTest, EntriesArePinned) { Insert(100, 101, 1); std::string result1; Cache::Handle* h1 = _cache->lookup(EncodeKey(&result1, 100)); - if (h1 == nullptr) { - std::cout << "h1 is null" << std::endl; - } - ASSERT_EQ(101, DecodeValue(_cache->value(h1))); + EXPECT_EQ(101, DecodeValue(_cache->value(h1))); Insert(100, 102, 1); std::string result2; Cache::Handle* h2 = _cache->lookup(EncodeKey(&result2, 100)); - ASSERT_EQ(102, DecodeValue(_cache->value(h2))); - ASSERT_EQ(0, _deleted_keys.size()); + EXPECT_EQ(102, DecodeValue(_cache->value(h2))); + EXPECT_EQ(0, _deleted_keys.size()); _cache->release(h1); - ASSERT_EQ(1, _deleted_keys.size()); - ASSERT_EQ(100, _deleted_keys[0]); - ASSERT_EQ(101, _deleted_values[0]); + EXPECT_EQ(1, _deleted_keys.size()); + EXPECT_EQ(100, _deleted_keys[0]); + EXPECT_EQ(101, _deleted_values[0]); Erase(100); - ASSERT_EQ(-1, Lookup(100)); - ASSERT_EQ(1, _deleted_keys.size()); + EXPECT_EQ(-1, Lookup(100)); + EXPECT_EQ(1, _deleted_keys.size()); _cache->release(h2); - ASSERT_EQ(2, _deleted_keys.size()); - ASSERT_EQ(100, _deleted_keys[1]); - ASSERT_EQ(102, _deleted_values[1]); + EXPECT_EQ(2, _deleted_keys.size()); + EXPECT_EQ(100, _deleted_keys[1]); + EXPECT_EQ(102, _deleted_values[1]); } TEST_F(CacheTest, EvictionPolicy) { @@ -194,12 +191,12 @@ TEST_F(CacheTest, EvictionPolicy) { // Frequently used entry must be kept around for (int i = 0; i < kCacheSize + 100; i++) { Insert(1000 + i, 2000 + i, 1); - ASSERT_EQ(2000 + i, Lookup(1000 + i)); - ASSERT_EQ(101, Lookup(100)); + EXPECT_EQ(2000 + i, Lookup(1000 + i)); + EXPECT_EQ(101, Lookup(100)); } - ASSERT_EQ(101, Lookup(100)); - ASSERT_EQ(-1, Lookup(200)); + EXPECT_EQ(101, Lookup(100)); + EXPECT_EQ(-1, Lookup(200)); } TEST_F(CacheTest, EvictionPolicyWithDurable) { @@ -210,18 +207,16 @@ TEST_F(CacheTest, EvictionPolicyWithDurable) { // Frequently used entry must be kept around for (int i = 0; i < kCacheSize + 100; i++) { Insert(1000 + i, 2000 + i, 1); - ASSERT_EQ(2000 + i, Lookup(1000 + i)); - ASSERT_EQ(101, Lookup(100)); + EXPECT_EQ(2000 + i, Lookup(1000 + i)); + EXPECT_EQ(101, Lookup(100)); } - ASSERT_EQ(-1, Lookup(300)); - ASSERT_EQ(101, Lookup(100)); - ASSERT_EQ(201, Lookup(200)); + EXPECT_EQ(-1, Lookup(300)); + EXPECT_EQ(101, Lookup(100)); + EXPECT_EQ(201, Lookup(200)); } -static void deleter(const CacheKey& key, void* v) { - std::cout << "delete key " << key.to_string() << std::endl; -} +static void deleter(const CacheKey& key, void* v) {} static void insert_LRUCache(LRUCache& cache, const CacheKey& key, int value, CachePriority priority) { @@ -237,31 +232,31 @@ TEST_F(CacheTest, Usage) { // 95 + 3 means handle_size + key size CacheKey key1("100"); insert_LRUCache(cache, key1, 100, CachePriority::NORMAL); - ASSERT_EQ(198, cache.get_usage()); // 100 + 95 + 3 + EXPECT_EQ(198, cache.get_usage()); // 100 + 95 + 3 CacheKey key2("200"); insert_LRUCache(cache, key2, 200, CachePriority::DURABLE); - ASSERT_EQ(496, cache.get_usage()); // 198 + 200 + 95 + 3 + EXPECT_EQ(496, cache.get_usage()); // 198 + 200 + 95 + 3 CacheKey key3("300"); insert_LRUCache(cache, key3, 300, CachePriority::NORMAL); - ASSERT_EQ(894, cache.get_usage()); // 496 + 300 + 95 + 3 + EXPECT_EQ(894, cache.get_usage()); // 496 + 300 + 95 + 3 CacheKey key4("400"); insert_LRUCache(cache, key4, 400, CachePriority::NORMAL); - ASSERT_EQ(796, cache.get_usage()); // 894 + 400 + 95 + 3 - (300 + 100 + (95 + 3) * 2) + EXPECT_EQ(796, cache.get_usage()); // 894 + 400 + 95 + 3 - (300 + 100 + (95 + 3) * 2) CacheKey key5("500"); insert_LRUCache(cache, key5, 500, CachePriority::NORMAL); - ASSERT_EQ(896, cache.get_usage()); // 796 + 500 + 95 + 3 - (400 + 95 +3) + EXPECT_EQ(896, cache.get_usage()); // 796 + 500 + 95 + 3 - (400 + 95 +3) CacheKey key6("600"); insert_LRUCache(cache, key6, 600, CachePriority::NORMAL); - ASSERT_EQ(996, cache.get_usage()); // 896 + 600 + 95 +3 - (500 + 95 + 3) + EXPECT_EQ(996, cache.get_usage()); // 896 + 600 + 95 +3 - (500 + 95 + 3) CacheKey key7("950"); insert_LRUCache(cache, key7, 950, CachePriority::DURABLE); - ASSERT_EQ(1048, cache.get_usage()); // 996 + 950 + 95 +3 - (200 + 600 + (95 + 3) * 2) + EXPECT_EQ(1048, cache.get_usage()); // 996 + 950 + 95 +3 - (200 + 600 + (95 + 3) * 2) } TEST_F(CacheTest, Prune) { @@ -272,49 +267,49 @@ TEST_F(CacheTest, Prune) { // 95 + 3 means handle_size + key size CacheKey key1("100"); insert_LRUCache(cache, key1, 100, CachePriority::NORMAL); - ASSERT_EQ(1, cache.get_usage()); + EXPECT_EQ(1, cache.get_usage()); CacheKey key2("200"); insert_LRUCache(cache, key2, 200, CachePriority::DURABLE); - ASSERT_EQ(2, cache.get_usage()); + EXPECT_EQ(2, cache.get_usage()); CacheKey key3("300"); insert_LRUCache(cache, key3, 300, CachePriority::NORMAL); - ASSERT_EQ(3, cache.get_usage()); + EXPECT_EQ(3, cache.get_usage()); CacheKey key4("400"); insert_LRUCache(cache, key4, 400, CachePriority::NORMAL); - ASSERT_EQ(4, cache.get_usage()); + EXPECT_EQ(4, cache.get_usage()); CacheKey key5("500"); insert_LRUCache(cache, key5, 500, CachePriority::NORMAL); - ASSERT_EQ(5, cache.get_usage()); + EXPECT_EQ(5, cache.get_usage()); CacheKey key6("600"); insert_LRUCache(cache, key6, 600, CachePriority::NORMAL); - ASSERT_EQ(5, cache.get_usage()); + EXPECT_EQ(5, cache.get_usage()); CacheKey key7("700"); insert_LRUCache(cache, key7, 700, CachePriority::DURABLE); - ASSERT_EQ(5, cache.get_usage()); + EXPECT_EQ(5, cache.get_usage()); auto pred = [](const void* value) -> bool { return false; }; cache.prune_if(pred); - ASSERT_EQ(5, cache.get_usage()); + EXPECT_EQ(5, cache.get_usage()); auto pred2 = [](const void* value) -> bool { return DecodeValue((void*)value) > 400; }; cache.prune_if(pred2); - ASSERT_EQ(2, cache.get_usage()); + EXPECT_EQ(2, cache.get_usage()); cache.prune(); - ASSERT_EQ(0, cache.get_usage()); + EXPECT_EQ(0, cache.get_usage()); for (int i = 1; i <= 5; ++i) { insert_LRUCache(cache, CacheKey {std::to_string(i)}, i, CachePriority::NORMAL); - ASSERT_EQ(i, cache.get_usage()); + EXPECT_EQ(i, cache.get_usage()); } cache.prune_if([](const void*) { return true; }); - ASSERT_EQ(0, cache.get_usage()); + EXPECT_EQ(0, cache.get_usage()); } TEST_F(CacheTest, HeavyEntries) { @@ -341,23 +336,23 @@ TEST_F(CacheTest, HeavyEntries) { if (r >= 0) { cached_weight += weight; - ASSERT_EQ(1000 + i, r); + EXPECT_EQ(1000 + i, r); } } - ASSERT_LE(cached_weight, kCacheSize + kCacheSize / 10); + EXPECT_LE(cached_weight, kCacheSize + kCacheSize / 10); } TEST_F(CacheTest, NewId) { uint64_t a = _cache->new_id(); uint64_t b = _cache->new_id(); - ASSERT_NE(a, b); + EXPECT_NE(a, b); } TEST_F(CacheTest, SimpleBenchmark) { for (int i = 0; i < kCacheSize * LOOP_LESS_OR_MORE(10, 10000); i++) { Insert(1000 + i, 2000 + i, 1); - ASSERT_EQ(2000 + i, Lookup(1000 + i)); + EXPECT_EQ(2000 + i, Lookup(1000 + i)); } } @@ -365,14 +360,14 @@ TEST(CacheHandleTest, HandleTableTest) { HandleTable ht; for (uint32_t i = 0; i < ht._length; ++i) { - ASSERT_NE(ht._list[i], nullptr); - ASSERT_EQ(ht._list[i]->next_hash, nullptr); - ASSERT_EQ(ht._list[i]->prev_hash, nullptr); + EXPECT_NE(ht._list[i], nullptr); + EXPECT_EQ(ht._list[i]->next_hash, nullptr); + EXPECT_EQ(ht._list[i]->prev_hash, nullptr); } const int count = 10; CacheKey keys[count] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}; - ASSERT_NE(keys[0], keys[1]); + EXPECT_NE(keys[0], keys[1]); LRUHandle* hs[count]; for (int i = 0; i < count; ++i) { CacheKey* key = &keys[i]; @@ -392,21 +387,21 @@ TEST(CacheHandleTest, HandleTableTest) { memcpy(h->key_data, key->data(), key->size()); LRUHandle* old = ht.insert(h); - ASSERT_EQ(ht._elems, i + 1); - ASSERT_EQ(old, nullptr); // there is no entry with the same key and hash + EXPECT_EQ(ht._elems, i + 1); + EXPECT_EQ(old, nullptr); // there is no entry with the same key and hash hs[i] = h; } - ASSERT_EQ(ht._elems, count); + EXPECT_EQ(ht._elems, count); LRUHandle* h = ht.lookup(CacheKey(std::to_string(count - 1)), 1); LRUHandle* head = ht._list[1 & (ht._length - 1)]; - ASSERT_EQ(head, h->prev_hash); - ASSERT_EQ(head->next_hash, h); + EXPECT_EQ(head, h->prev_hash); + EXPECT_EQ(head->next_hash, h); int index = count - 1; while (h != nullptr) { - ASSERT_EQ(hs[index], h) << index; + EXPECT_EQ(hs[index], h) << index; h = h->next_hash; if (h != nullptr) { - ASSERT_EQ(hs[index], h->prev_hash); + EXPECT_EQ(hs[index], h->prev_hash); } --index; } @@ -428,41 +423,41 @@ TEST(CacheHandleTest, HandleTableTest) { h->priority = CachePriority::NORMAL; memcpy(h->key_data, key->data(), key->size()); - ASSERT_EQ(ht.insert(h), hs[i]); // there is an entry with the same key and hash - ASSERT_EQ(ht._elems, count); + EXPECT_EQ(ht.insert(h), hs[i]); // there is an entry with the same key and hash + EXPECT_EQ(ht._elems, count); free(hs[i]); hs[i] = h; } - ASSERT_EQ(ht._elems, count); + EXPECT_EQ(ht._elems, count); for (int i = 0; i < count; ++i) { - ASSERT_EQ(ht.lookup(keys[i], 1), hs[i]); + EXPECT_EQ(ht.lookup(keys[i], 1), hs[i]); } LRUHandle* old = ht.remove(CacheKey("9"), 1); // first in hash table linked-list - ASSERT_EQ(old, hs[9]); - ASSERT_EQ(old->prev_hash, head); - ASSERT_EQ(old->next_hash, hs[8]); // hs[8] is the new first node - ASSERT_EQ(head->next_hash, hs[8]); - ASSERT_EQ(hs[8]->prev_hash, head); + EXPECT_EQ(old, hs[9]); + EXPECT_EQ(old->prev_hash, head); + EXPECT_EQ(old->next_hash, hs[8]); // hs[8] is the new first node + EXPECT_EQ(head->next_hash, hs[8]); + EXPECT_EQ(hs[8]->prev_hash, head); old = ht.remove(CacheKey("0"), 1); // last in hash table linked-list - ASSERT_EQ(old, hs[0]); - ASSERT_EQ(old->prev_hash, hs[1]); // hs[1] is the new last node - ASSERT_EQ(old->prev_hash->next_hash, nullptr); + EXPECT_EQ(old, hs[0]); + EXPECT_EQ(old->prev_hash, hs[1]); // hs[1] is the new last node + EXPECT_EQ(old->prev_hash->next_hash, nullptr); old = ht.remove(CacheKey("5"), 1); // middle in hash table linked-list - ASSERT_EQ(old, hs[5]); - ASSERT_EQ(old->prev_hash, hs[6]); - ASSERT_EQ(old->next_hash, hs[4]); - ASSERT_EQ(hs[6]->next_hash, hs[4]); - ASSERT_EQ(hs[4]->prev_hash, hs[6]); + EXPECT_EQ(old, hs[5]); + EXPECT_EQ(old->prev_hash, hs[6]); + EXPECT_EQ(old->next_hash, hs[4]); + EXPECT_EQ(hs[6]->next_hash, hs[4]); + EXPECT_EQ(hs[4]->prev_hash, hs[6]); ht.remove(hs[4]); // middle in hash table linked-list - ASSERT_EQ(hs[6]->next_hash, hs[3]); - ASSERT_EQ(hs[3]->prev_hash, hs[6]); + EXPECT_EQ(hs[6]->next_hash, hs[3]); + EXPECT_EQ(hs[3]->prev_hash, hs[6]); - ASSERT_EQ(ht._elems, count - 4); + EXPECT_EQ(ht._elems, count - 4); for (int i = 0; i < count; ++i) { free(hs[i]); @@ -470,8 +465,3 @@ TEST(CacheHandleTest, HandleTableTest) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/memtable_flush_executor_test.cpp b/be/test/olap/memtable_flush_executor_test.cpp index cc5fef5edd..aab1a92403 100644 --- a/be/test/olap/memtable_flush_executor_test.cpp +++ b/be/test/olap/memtable_flush_executor_test.cpp @@ -57,7 +57,7 @@ void set_up() { doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); ExecEnv* exec_env = doris::ExecEnv::GetInstance(); exec_env->set_storage_engine(k_engine); @@ -85,10 +85,6 @@ class TestMemTableFlushExecutor : public ::testing::Test { public: TestMemTableFlushExecutor() {} ~TestMemTableFlushExecutor() {} - - void SetUp() { std::cout << "setup" << std::endl; } - - void TearDown() { std::cout << "tear down" << std::endl; } }; TEST_F(TestMemTableFlushExecutor, create_flush_handler) { @@ -97,41 +93,24 @@ TEST_F(TestMemTableFlushExecutor, create_flush_handler) { std::shared_ptr flush_handler; k_flush_executor->create_flush_handler(path_hash, &flush_handler); - ASSERT_NE(nullptr, flush_handler.get()); + EXPECT_NE(nullptr, flush_handler.get()); FlushResult res; res.flush_status = OLAP_SUCCESS; res.flush_time_ns = 100; flush_handler->on_flush_finished(res); - ASSERT_FALSE(flush_handler->is_cancelled()); - ASSERT_EQ(100, flush_handler->get_stats().flush_time_ns); - ASSERT_EQ(1, flush_handler->get_stats().flush_count); + EXPECT_FALSE(flush_handler->is_cancelled()); + EXPECT_EQ(100, flush_handler->get_stats().flush_time_ns); + EXPECT_EQ(1, flush_handler->get_stats().flush_count); FlushResult res2; res2.flush_status = OLAP_ERR_OTHER_ERROR; flush_handler->on_flush_finished(res2); - ASSERT_TRUE(flush_handler->is_cancelled()); - ASSERT_EQ(100, flush_handler->get_stats().flush_time_ns); - ASSERT_EQ(1, flush_handler->get_stats().flush_count); + EXPECT_TRUE(flush_handler->is_cancelled()); + EXPECT_EQ(100, flush_handler->get_stats().flush_time_ns); + EXPECT_EQ(1, flush_handler->get_stats().flush_count); - ASSERT_EQ(OLAP_ERR_OTHER_ERROR, flush_handler->wait()); + EXPECT_EQ(OLAP_ERR_OTHER_ERROR, flush_handler->wait()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - doris::set_up(); - ret = RUN_ALL_TESTS(); - doris::tear_down(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/null_predicate_test.cpp b/be/test/olap/null_predicate_test.cpp index 7b2a90f1a6..51c7abb48f 100644 --- a/be/test/olap/null_predicate_test.cpp +++ b/be/test/olap/null_predicate_test.cpp @@ -133,7 +133,7 @@ public: *(col_data + i) = i; \ } \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 0); \ + EXPECT_EQ(_vectorized_batch->size(), 0); \ \ /* for ColumnBlock nulls */ \ init_row_block(&tablet_schema, size); \ @@ -145,7 +145,7 @@ public: *reinterpret_cast(col_block_view.data()) = i; \ } \ pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); \ - ASSERT_EQ(select_size, 0); \ + EXPECT_EQ(select_size, 0); \ \ /* for vectorized::Block no null */ \ _row_block->clear(); \ @@ -155,7 +155,7 @@ public: ColumnPtr vec_col = vec_block.get_columns()[0]; \ pred->evaluate(const_cast(*vec_col), \ _row_block->selection_vector(), &select_size); \ - ASSERT_EQ(select_size, 0); \ + EXPECT_EQ(select_size, 0); \ \ /* for has nulls */ \ col_vector->set_no_nulls(false); \ @@ -172,7 +172,7 @@ public: _vectorized_batch->set_size(size); \ _vectorized_batch->set_selected_in_use(false); \ pred->evaluate(_vectorized_batch); \ - ASSERT_EQ(_vectorized_batch->size(), 5); \ + EXPECT_EQ(_vectorized_batch->size(), 5); \ \ /* for ColumnBlock has nulls */ \ col_block_view = ColumnBlockView(&col_block); \ @@ -187,7 +187,7 @@ public: _row_block->clear(); \ select_size = _row_block->selected_size(); \ pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); \ - ASSERT_EQ(select_size, 5); \ + EXPECT_EQ(select_size, 5); \ \ /* for vectorized::Block has nulls */ \ _row_block->clear(); \ @@ -197,7 +197,7 @@ public: vec_col = vec_block.get_columns()[0]; \ pred->evaluate(const_cast(*vec_col), \ _row_block->selection_vector(), &select_size); \ - ASSERT_EQ(select_size, 5); \ + EXPECT_EQ(select_size, 5); \ pred.reset(); \ } @@ -227,7 +227,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { *(col_data + i) = i + 0.1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -239,7 +239,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { *reinterpret_cast(col_block_view.data()) = i + 0.1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -249,7 +249,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -266,7 +266,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 5); + EXPECT_EQ(_vectorized_batch->size(), 5); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -281,7 +281,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); // for vectorized::Block has nulls _row_block->clear(); @@ -291,7 +291,7 @@ TEST_F(TestNullPredicate, FLOAT_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); } TEST_F(TestNullPredicate, DOUBLE_COLUMN) { @@ -315,7 +315,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { *(col_data + i) = i + 0.1; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -327,7 +327,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { *reinterpret_cast(col_block_view.data()) = i + 0.1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -337,7 +337,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -354,7 +354,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 5); + EXPECT_EQ(_vectorized_batch->size(), 5); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -369,7 +369,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); // for vectorized::Block has nulls _row_block->clear(); @@ -379,7 +379,7 @@ TEST_F(TestNullPredicate, DOUBLE_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 5); + EXPECT_EQ(select_size, 5); } TEST_F(TestNullPredicate, DECIMAL_COLUMN) { @@ -405,7 +405,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { (*(col_data + i)).fraction = i; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -418,7 +418,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { reinterpret_cast(col_block_view.data())->fraction = i; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -428,7 +428,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -446,7 +446,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 4); + EXPECT_EQ(_vectorized_batch->size(), 4); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -462,7 +462,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 4); + EXPECT_EQ(select_size, 4); // for vectorized::Block has nulls _row_block->clear(); @@ -472,7 +472,7 @@ TEST_F(TestNullPredicate, DECIMAL_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 4); + EXPECT_EQ(select_size, 4); } TEST_F(TestNullPredicate, STRING_COLUMN) { @@ -502,9 +502,9 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { (*(col_data + i)).ptr = string_buffer; string_buffer += i + 1; } - ASSERT_EQ(_vectorized_batch->size(), 10); + EXPECT_EQ(_vectorized_batch->size(), 10); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -523,7 +523,7 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { string_buffer += i + 1; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -533,7 +533,7 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -556,7 +556,7 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 4); + EXPECT_EQ(_vectorized_batch->size(), 4); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -577,7 +577,7 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 4); + EXPECT_EQ(select_size, 4); // for vectorized::Block has nulls _row_block->clear(); @@ -587,7 +587,7 @@ TEST_F(TestNullPredicate, STRING_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 4); + EXPECT_EQ(select_size, 4); } TEST_F(TestNullPredicate, DATE_COLUMN) { @@ -619,7 +619,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -632,7 +632,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -642,7 +642,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -660,7 +660,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 2); + EXPECT_EQ(_vectorized_batch->size(), 2); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -676,7 +676,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); // for vectorized::Block has nulls _row_block->clear(); @@ -686,7 +686,7 @@ TEST_F(TestNullPredicate, DATE_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); } TEST_F(TestNullPredicate, DATETIME_COLUMN) { @@ -718,7 +718,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { *(col_data + i) = timestamp; } pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 0); + EXPECT_EQ(_vectorized_batch->size(), 0); // for ColumnBlock no nulls init_row_block(&tablet_schema, size); @@ -731,7 +731,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { *reinterpret_cast(col_block_view.data()) = timestamp; } pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for vectorized::Block no null _row_block->clear(); @@ -741,7 +741,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { ColumnPtr vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 0); + EXPECT_EQ(select_size, 0); // for VectorizedBatch has nulls col_vector->set_no_nulls(false); @@ -759,7 +759,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { _vectorized_batch->set_size(size); _vectorized_batch->set_selected_in_use(false); pred->evaluate(_vectorized_batch); - ASSERT_EQ(_vectorized_batch->size(), 2); + EXPECT_EQ(_vectorized_batch->size(), 2); // for ColumnBlock has nulls col_block_view = ColumnBlockView(&col_block); @@ -775,7 +775,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { _row_block->clear(); select_size = _row_block->selected_size(); pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); // for vectorized::Block has nulls _row_block->clear(); @@ -785,22 +785,7 @@ TEST_F(TestNullPredicate, DATETIME_COLUMN) { vec_col = vec_block.get_columns()[0]; pred->evaluate(const_cast(*vec_col), _row_block->selection_vector(), &select_size); - ASSERT_EQ(select_size, 2); + EXPECT_EQ(select_size, 2); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/olap_meta_test.cpp b/be/test/olap/olap_meta_test.cpp index 4ba0abb0f7..42d7599aff 100644 --- a/be/test/olap/olap_meta_test.cpp +++ b/be/test/olap/olap_meta_test.cpp @@ -43,8 +43,8 @@ public: _meta = new OlapMeta(_root_path); OLAPStatus s = _meta->init(); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_TRUE(std::filesystem::exists(_root_path + "/meta")); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_TRUE(std::filesystem::exists(_root_path + "/meta")); } virtual void TearDown() { @@ -59,7 +59,7 @@ private: TEST_F(OlapMetaTest, TestGetRootPath) { std::string root_path = _meta->get_root_path(); - ASSERT_EQ("./ut_dir/olap_meta_test", root_path); + EXPECT_EQ("./ut_dir/olap_meta_test", root_path); } TEST_F(OlapMetaTest, TestPutAndGet) { @@ -67,15 +67,15 @@ TEST_F(OlapMetaTest, TestPutAndGet) { std::string key = "key"; std::string value = "value"; OLAPStatus s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); std::string value_get; s = _meta->get(META_COLUMN_FAMILY_INDEX, key, &value_get); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_EQ(value, value_get); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(value, value_get); // abnormal cases s = _meta->get(META_COLUMN_FAMILY_INDEX, "key_not_exist", &value_get); - ASSERT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); + EXPECT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); } TEST_F(OlapMetaTest, TestRemove) { @@ -83,15 +83,15 @@ TEST_F(OlapMetaTest, TestRemove) { std::string key = "key"; std::string value = "value"; OLAPStatus s = _meta->put(META_COLUMN_FAMILY_INDEX, key, value); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); std::string value_get; s = _meta->get(META_COLUMN_FAMILY_INDEX, key, &value_get); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_EQ(value, value_get); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(value, value_get); s = _meta->remove(META_COLUMN_FAMILY_INDEX, key); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); s = _meta->remove(META_COLUMN_FAMILY_INDEX, "key_not_exist"); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); } TEST_F(OlapMetaTest, TestIterate) { @@ -103,7 +103,7 @@ TEST_F(OlapMetaTest, TestIterate) { std::stringstream ss; ss << key << "_" << i; s = _meta->put(META_COLUMN_FAMILY_INDEX, ss.str(), value); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); } bool error_flag = false; s = _meta->iterate(META_COLUMN_FAMILY_INDEX, "hdr_", @@ -114,13 +114,8 @@ TEST_F(OlapMetaTest, TestIterate) { } return true; }); - ASSERT_EQ(false, error_flag); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(false, error_flag); + EXPECT_EQ(OLAP_SUCCESS, s); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/options_test.cpp b/be/test/olap/options_test.cpp index 19509d2a90..4631d71997 100644 --- a/be/test/olap/options_test.cpp +++ b/be/test/olap/options_test.cpp @@ -24,19 +24,22 @@ namespace doris { -void set_up() { - ASSERT_EQ(system("rm -rf ./test_run && mkdir -p ./test_run"), 0); - ASSERT_EQ(system("mkdir -p ./test_run/palo && mkdir -p ./test_run/palo.ssd"), 0); +static void set_up() { + EXPECT_EQ(system("rm -rf ./test_run && mkdir -p ./test_run"), 0); + EXPECT_EQ(system("mkdir -p ./test_run/palo && mkdir -p ./test_run/palo.ssd"), 0); } -void tear_down() { - ASSERT_EQ(system("rm -rf ./test_run"), 0); +static void tear_down() { + EXPECT_EQ(system("rm -rf ./test_run"), 0); } class OptionsTest : public testing::Test { public: OptionsTest() {} virtual ~OptionsTest() {} + static void SetUpTestSuite() { set_up(); } + + static void TearDownTestSuite() { tear_down(); } }; TEST_F(OptionsTest, parse_root_path) { @@ -50,73 +53,62 @@ TEST_F(OptionsTest, parse_root_path) { // /path<.extension>, { root_path = path1; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path1.c_str(), path.path.c_str()); - ASSERT_EQ(-1, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::HDD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path1.c_str(), path.path.c_str()); + EXPECT_EQ(-1, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); } { root_path = path2; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path2.c_str(), path.path.c_str()); - ASSERT_EQ(-1, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::SSD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path2.c_str(), path.path.c_str()); + EXPECT_EQ(-1, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path2 + ", 50"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path2.c_str(), path.path.c_str()); - ASSERT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::SSD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path2.c_str(), path.path.c_str()); + EXPECT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } // /path, :,... { root_path = path1 + ", capacity:50, medium: ssd"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path1.c_str(), path.path.c_str()); - ASSERT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::SSD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path1.c_str(), path.path.c_str()); + EXPECT_EQ(50 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + ", medium: ssd, capacity:30"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path1.c_str(), path.path.c_str()); - ASSERT_EQ(30 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::SSD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path1.c_str(), path.path.c_str()); + EXPECT_EQ(30 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + " , medium: ssd, 60"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path1.c_str(), path.path.c_str()); - ASSERT_EQ(60 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::SSD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path1.c_str(), path.path.c_str()); + EXPECT_EQ(60 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::SSD, path.storage_medium); } { root_path = path1 + ", medium: ssd, 60, medium: hdd, capacity: 10"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path1.c_str(), path.path.c_str()); - ASSERT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::HDD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path1.c_str(), path.path.c_str()); + EXPECT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); } { root_path = path2 + ", medium: hdd, 60, capacity: 10"; - ASSERT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); - ASSERT_STREQ(path2.c_str(), path.path.c_str()); - ASSERT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); - ASSERT_EQ(TStorageMedium::HDD, path.storage_medium); + EXPECT_EQ(OLAP_SUCCESS, parse_root_path(root_path, &path)); + EXPECT_STREQ(path2.c_str(), path.path.c_str()); + EXPECT_EQ(10 * GB_EXCHANGE_BYTE, path.capacity_bytes); + EXPECT_EQ(TStorageMedium::HDD, path.storage_medium); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - - int ret = doris::OLAP_SUCCESS; - doris::set_up(); - ret = RUN_ALL_TESTS(); - doris::tear_down(); - - return ret; -} diff --git a/be/test/olap/page_cache_test.cpp b/be/test/olap/page_cache_test.cpp index 0abd0745d4..1eca896010 100644 --- a/be/test/olap/page_cache_test.cpp +++ b/be/test/olap/page_cache_test.cpp @@ -43,11 +43,11 @@ TEST(StoragePageCacheTest, data_page_only) { Slice data(buf, 1024); cache.insert(key, data, &handle, page_type, false); - ASSERT_EQ(handle.data().data, buf); + EXPECT_EQ(handle.data().data, buf); auto found = cache.lookup(key, &handle, page_type); - ASSERT_TRUE(found); - ASSERT_EQ(buf, handle.data().data); + EXPECT_TRUE(found); + EXPECT_EQ(buf, handle.data().data); } { @@ -57,10 +57,10 @@ TEST(StoragePageCacheTest, data_page_only) { Slice data(buf, 1024); cache.insert(memory_key, data, &handle, page_type, true); - ASSERT_EQ(handle.data().data, buf); + EXPECT_EQ(handle.data().data, buf); auto found = cache.lookup(memory_key, &handle, page_type); - ASSERT_TRUE(found); + EXPECT_TRUE(found); } // put too many page to eliminate first page @@ -76,16 +76,15 @@ TEST(StoragePageCacheTest, data_page_only) { PageCacheHandle handle; StoragePageCache::CacheKey miss_key("abc", 1); auto found = cache.lookup(miss_key, &handle, page_type); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } // cache miss for eliminated key { PageCacheHandle handle; auto found = cache.lookup(key, &handle, page_type); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } - } // All cache space is allocated to index pages @@ -104,11 +103,11 @@ TEST(StoragePageCacheTest, index_page_only) { Slice data(buf, 1024); cache.insert(key, data, &handle, page_type, false); - ASSERT_EQ(handle.data().data, buf); + EXPECT_EQ(handle.data().data, buf); auto found = cache.lookup(key, &handle, page_type); - ASSERT_TRUE(found); - ASSERT_EQ(buf, handle.data().data); + EXPECT_TRUE(found); + EXPECT_EQ(buf, handle.data().data); } { @@ -118,10 +117,10 @@ TEST(StoragePageCacheTest, index_page_only) { Slice data(buf, 1024); cache.insert(memory_key, data, &handle, page_type, true); - ASSERT_EQ(handle.data().data, buf); + EXPECT_EQ(handle.data().data, buf); auto found = cache.lookup(memory_key, &handle, page_type); - ASSERT_TRUE(found); + EXPECT_TRUE(found); } // put too many page to eliminate first page @@ -137,16 +136,15 @@ TEST(StoragePageCacheTest, index_page_only) { PageCacheHandle handle; StoragePageCache::CacheKey miss_key("abc", 1); auto found = cache.lookup(miss_key, &handle, page_type); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } // cache miss for eliminated key { PageCacheHandle handle; auto found = cache.lookup(key, &handle, page_type); - ASSERT_FALSE(found); + EXPECT_FALSE(found); } - } // Cache space is allocated by index_page_cache_ratio @@ -170,15 +168,15 @@ TEST(StoragePageCacheTest, mixed_pages) { cache.insert(data_key, data, &data_handle, page_type_data, false); cache.insert(index_key, index, &index_handle, page_type_index, false); - ASSERT_EQ(data_handle.data().data, buf_data); - ASSERT_EQ(index_handle.data().data, buf_index); + EXPECT_EQ(data_handle.data().data, buf_data); + EXPECT_EQ(index_handle.data().data, buf_index); auto found_data = cache.lookup(data_key, &data_handle, page_type_data); auto found_index = cache.lookup(index_key, &index_handle, page_type_index); - ASSERT_TRUE(found_data); - ASSERT_TRUE(found_index); - ASSERT_EQ(buf_data, data_handle.data().data); - ASSERT_EQ(buf_index, index_handle.data().data); + EXPECT_TRUE(found_data); + EXPECT_TRUE(found_index); + EXPECT_EQ(buf_data, data_handle.data().data); + EXPECT_EQ(buf_index, index_handle.data().data); } { @@ -190,13 +188,13 @@ TEST(StoragePageCacheTest, mixed_pages) { cache.insert(data_key_mem, data, &data_handle, page_type_data, true); cache.insert(index_key_mem, index, &index_handle, page_type_index, true); - ASSERT_EQ(data_handle.data().data, buf_data); - ASSERT_EQ(index_handle.data().data, buf_index); + EXPECT_EQ(data_handle.data().data, buf_data); + EXPECT_EQ(index_handle.data().data, buf_index); auto found_data = cache.lookup(data_key_mem, &data_handle, page_type_data); auto found_index = cache.lookup(index_key_mem, &index_handle, page_type_index); - ASSERT_TRUE(found_data); - ASSERT_TRUE(found_index); + EXPECT_TRUE(found_data); + EXPECT_TRUE(found_index); } // put too many page to eliminate first page of both cache @@ -214,8 +212,8 @@ TEST(StoragePageCacheTest, mixed_pages) { StoragePageCache::CacheKey miss_key("abc", 1); auto found_data = cache.lookup(miss_key, &data_handle, page_type_data); auto found_index = cache.lookup(miss_key, &index_handle, page_type_index); - ASSERT_FALSE(found_data); - ASSERT_FALSE(found_index); + EXPECT_FALSE(found_data); + EXPECT_FALSE(found_index); } // cache miss by page type @@ -228,11 +226,11 @@ TEST(StoragePageCacheTest, mixed_pages) { Slice data(buf_data, 1024), index(buf_index, 1024); cache.insert(miss_key_data, data, &data_handle, page_type_data, false); cache.insert(miss_key_index, index, &index_handle, page_type_index, false); - + auto found_data = cache.lookup(miss_key_data, &data_handle, page_type_index); auto found_index = cache.lookup(miss_key_index, &index_handle, page_type_data); - ASSERT_FALSE(found_data); - ASSERT_FALSE(found_index); + EXPECT_FALSE(found_data); + EXPECT_FALSE(found_index); } // cache miss for eliminated key @@ -240,15 +238,9 @@ TEST(StoragePageCacheTest, mixed_pages) { PageCacheHandle data_handle, index_handle; auto found_data = cache.lookup(data_key, &data_handle, page_type_data); auto found_index = cache.lookup(index_key, &index_handle, page_type_index); - ASSERT_FALSE(found_data); - ASSERT_FALSE(found_index); + EXPECT_FALSE(found_data); + EXPECT_FALSE(found_index); } - } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/push_handler_test.cpp b/be/test/olap/push_handler_test.cpp index f4efdb40e7..a3a5d57235 100644 --- a/be/test/olap/push_handler_test.cpp +++ b/be/test/olap/push_handler_test.cpp @@ -425,38 +425,32 @@ TEST_F(PushHandlerTest, PushBrokerReaderNormal) { // line 1 reader.next(&row); - ASSERT_FALSE(reader.eof()); - ASSERT_EQ(0, *(int32_t*)row.cell(0).cell_ptr()); - ASSERT_EQ(0, *(int16_t*)row.cell(1).cell_ptr()); - ASSERT_EQ("a0", ((Slice*)row.cell(2).cell_ptr())->to_string()); - ASSERT_EQ(0, *(int64_t*)row.cell(3).cell_ptr()); + EXPECT_FALSE(reader.eof()); + EXPECT_EQ(0, *(int32_t*)row.cell(0).cell_ptr()); + EXPECT_EQ(0, *(int16_t*)row.cell(1).cell_ptr()); + EXPECT_EQ("a0", ((Slice*)row.cell(2).cell_ptr())->to_string()); + EXPECT_EQ(0, *(int64_t*)row.cell(3).cell_ptr()); // line 2 reader.next(&row); - ASSERT_FALSE(reader.eof()); - ASSERT_EQ(0, *(int32_t*)row.cell(0).cell_ptr()); - ASSERT_EQ(2, *(int16_t*)row.cell(1).cell_ptr()); - ASSERT_EQ("a1", ((Slice*)row.cell(2).cell_ptr())->to_string()); - ASSERT_EQ(3, *(int64_t*)row.cell(3).cell_ptr()); + EXPECT_FALSE(reader.eof()); + EXPECT_EQ(0, *(int32_t*)row.cell(0).cell_ptr()); + EXPECT_EQ(2, *(int16_t*)row.cell(1).cell_ptr()); + EXPECT_EQ("a1", ((Slice*)row.cell(2).cell_ptr())->to_string()); + EXPECT_EQ(3, *(int64_t*)row.cell(3).cell_ptr()); // line 3 reader.next(&row); - ASSERT_FALSE(reader.eof()); - ASSERT_EQ(1, *(int32_t*)row.cell(0).cell_ptr()); - ASSERT_EQ(4, *(int16_t*)row.cell(1).cell_ptr()); - ASSERT_EQ("a2", ((Slice*)row.cell(2).cell_ptr())->to_string()); - ASSERT_EQ(6, *(int64_t*)row.cell(3).cell_ptr()); + EXPECT_FALSE(reader.eof()); + EXPECT_EQ(1, *(int32_t*)row.cell(0).cell_ptr()); + EXPECT_EQ(4, *(int16_t*)row.cell(1).cell_ptr()); + EXPECT_EQ("a2", ((Slice*)row.cell(2).cell_ptr())->to_string()); + EXPECT_EQ(6, *(int64_t*)row.cell(3).cell_ptr()); // eof reader.next(&row); - ASSERT_TRUE(reader.eof()); + EXPECT_TRUE(reader.eof()); reader.close(); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/row_block_test.cpp b/be/test/olap/row_block_test.cpp index 214b24cabe..fffa470d70 100644 --- a/be/test/olap/row_block_test.cpp +++ b/be/test/olap/row_block_test.cpp @@ -90,7 +90,7 @@ TEST_F(TestRowBlock, init) { block_info.row_num = 1024; block_info.null_supported = true; block.init(block_info); - ASSERT_EQ(9 + 17 + 17, block._mem_row_bytes); + EXPECT_EQ(9 + 17 + 17, block._mem_row_bytes); } { // has nullbyte @@ -99,7 +99,7 @@ TEST_F(TestRowBlock, init) { block_info.row_num = 1024; block_info.null_supported = false; block.init(block_info); - ASSERT_EQ(9 + 17 + 17, block._mem_row_bytes); + EXPECT_EQ(9 + 17 + 17, block._mem_row_bytes); } { RowBlock block(&tablet_schema); @@ -109,10 +109,10 @@ TEST_F(TestRowBlock, init) { block_info.column_ids.push_back(1); block.init(block_info); // null + sizeof(Slice) - ASSERT_EQ(17, block._mem_row_bytes); - ASSERT_EQ(std::numeric_limits::max(), block._field_offset_in_memory[0]); - ASSERT_EQ(0, block._field_offset_in_memory[1]); - ASSERT_EQ(std::numeric_limits::max(), block._field_offset_in_memory[2]); + EXPECT_EQ(17, block._mem_row_bytes); + EXPECT_EQ(std::numeric_limits::max(), block._field_offset_in_memory[0]); + EXPECT_EQ(0, block._field_offset_in_memory[1]); + EXPECT_EQ(std::numeric_limits::max(), block._field_offset_in_memory[2]); } } @@ -154,7 +154,7 @@ TEST_F(TestRowBlock, write_and_read) { } } block.finalize(5); - ASSERT_EQ(5, block.row_num()); + EXPECT_EQ(5, block.row_num()); } TEST_F(TestRowBlock, write_and_read_without_nullbyte) { @@ -195,7 +195,7 @@ TEST_F(TestRowBlock, write_and_read_without_nullbyte) { } } block.finalize(5); - ASSERT_EQ(5, block.row_num()); + EXPECT_EQ(5, block.row_num()); } TEST_F(TestRowBlock, compress_failed) { @@ -233,7 +233,7 @@ TEST_F(TestRowBlock, compress_failed) { } } block.finalize(5); - ASSERT_EQ(5, block.row_num()); + EXPECT_EQ(5, block.row_num()); } TEST_F(TestRowBlock, decompress_failed) { @@ -271,7 +271,7 @@ TEST_F(TestRowBlock, decompress_failed) { } } block.finalize(5); - ASSERT_EQ(5, block.row_num()); + EXPECT_EQ(5, block.row_num()); } TEST_F(TestRowBlock, clear) { @@ -284,10 +284,10 @@ TEST_F(TestRowBlock, clear) { block.init(block_info); block.finalize(5); - ASSERT_EQ(5, block.row_num()); - ASSERT_EQ(1024, block.capacity()); + EXPECT_EQ(5, block.row_num()); + EXPECT_EQ(1024, block.capacity()); block.clear(); - ASSERT_EQ(1024, block.row_num()); + EXPECT_EQ(1024, block.row_num()); } TEST_F(TestRowBlock, pos_limit) { @@ -300,39 +300,25 @@ TEST_F(TestRowBlock, pos_limit) { block.init(block_info); // assert init value - ASSERT_EQ(0, block.pos()); - ASSERT_EQ(0, block.limit()); - ASSERT_FALSE(block.has_remaining()); - ASSERT_EQ(DEL_PARTIAL_SATISFIED, block.block_status()); + EXPECT_EQ(0, block.pos()); + EXPECT_EQ(0, block.limit()); + EXPECT_FALSE(block.has_remaining()); + EXPECT_EQ(DEL_PARTIAL_SATISFIED, block.block_status()); block.set_limit(100); - ASSERT_EQ(100, block.limit()); - ASSERT_TRUE(block.has_remaining()); - ASSERT_EQ(100, block.remaining()); + EXPECT_EQ(100, block.limit()); + EXPECT_TRUE(block.has_remaining()); + EXPECT_EQ(100, block.remaining()); block.set_pos(2); - ASSERT_TRUE(block.has_remaining()); - ASSERT_EQ(98, block.remaining()); + EXPECT_TRUE(block.has_remaining()); + EXPECT_EQ(98, block.remaining()); block.pos_inc(); - ASSERT_TRUE(block.has_remaining()); - ASSERT_EQ(97, block.remaining()); + EXPECT_TRUE(block.has_remaining()); + EXPECT_EQ(97, block.remaining()); block.set_block_status(DEL_SATISFIED); - ASSERT_EQ(DEL_SATISFIED, block.block_status()); + EXPECT_EQ(DEL_SATISFIED, block.block_status()); } } // namespace doris - -// @brief Test Stub -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/olap/row_block_v2_test.cpp b/be/test/olap/row_block_v2_test.cpp index 37e973276a..a0e7fec4f6 100644 --- a/be/test/olap/row_block_v2_test.cpp +++ b/be/test/olap/row_block_v2_test.cpp @@ -131,43 +131,37 @@ TEST_F(TestRowBlockV2, test_convert) { RowCursor helper; helper.init(tablet_schema); auto st = input_block.convert_to_row_block(&helper, &output_block); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(5, output_block.limit()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(5, output_block.limit()); for (int i = 0; i < 5; ++i) { char* field1 = output_block.field_ptr(i, 0); char* field2 = output_block.field_ptr(i, 1); char* field3 = output_block.field_ptr(i, 2); char* field4 = output_block.field_ptr(i, 3); // test null bit - ASSERT_FALSE(*reinterpret_cast(field1)); - ASSERT_FALSE(*reinterpret_cast(field2)); - ASSERT_FALSE(*reinterpret_cast(field3)); - ASSERT_FALSE(*reinterpret_cast(field4)); + EXPECT_FALSE(*reinterpret_cast(field1)); + EXPECT_FALSE(*reinterpret_cast(field2)); + EXPECT_FALSE(*reinterpret_cast(field3)); + EXPECT_FALSE(*reinterpret_cast(field4)); uint64_t k1 = *reinterpret_cast(field1 + 1); - ASSERT_EQ((i + 1) * 10, k1); + EXPECT_EQ((i + 1) * 10, k1); Slice k2 = *reinterpret_cast(field2 + 1); char buf[10]; memset(buf, 'a' + ((i + 1) * 10) % 10, 10); Slice k2_v(buf, 10); - ASSERT_EQ(k2_v, k2); + EXPECT_EQ(k2_v, k2); Slice k3 = *reinterpret_cast(field3 + 1); char buf2[10]; memset(buf2, 'A' + ((i + 1) * 10) % 10, 10); Slice k3_v(buf2, 10); - ASSERT_EQ(k3_v, k3); + EXPECT_EQ(k3_v, k3); uint32_t v1 = *reinterpret_cast(field4 + 1); - ASSERT_EQ((i + 1) * 10 * 10, v1); + EXPECT_EQ((i + 1) * 10 * 10, v1); } } } // namespace doris - -// @brief Test Stub -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/row_cursor_test.cpp b/be/test/olap/row_cursor_test.cpp index 9dd2447e8f..c67dd191a5 100644 --- a/be/test/olap/row_cursor_test.cpp +++ b/be/test/olap/row_cursor_test.cpp @@ -270,9 +270,9 @@ TEST_F(TestRowCursor, InitRowCursor) { set_tablet_schema_for_init(&tablet_schema); RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 126); - ASSERT_EQ(row.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 126); + EXPECT_EQ(row.get_variable_len(), 20); } TEST_F(TestRowCursor, InitRowCursorWithColumnCount) { @@ -280,11 +280,11 @@ TEST_F(TestRowCursor, InitRowCursorWithColumnCount) { set_tablet_schema_for_init(&tablet_schema); RowCursor row; OLAPStatus res = row.init(tablet_schema, 5); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 23); - ASSERT_EQ(row.get_variable_len(), 0); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 23); + EXPECT_EQ(row.get_variable_len(), 0); row.allocate_memory_for_string_type(tablet_schema); - ASSERT_EQ(row.get_variable_len(), 0); + EXPECT_EQ(row.get_variable_len(), 0); } TEST_F(TestRowCursor, InitRowCursorWithColIds) { @@ -298,9 +298,9 @@ TEST_F(TestRowCursor, InitRowCursorWithColIds) { RowCursor row; OLAPStatus res = row.init(tablet_schema, col_ids); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 63); - ASSERT_EQ(row.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 63); + EXPECT_EQ(row.get_variable_len(), 20); } TEST_F(TestRowCursor, InitRowCursorWithScanKey) { @@ -316,17 +316,17 @@ TEST_F(TestRowCursor, InitRowCursorWithScanKey) { RowCursor row; OLAPStatus res = row.init_scan_key(tablet_schema, scan_keys, schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 34); - ASSERT_EQ(row.get_variable_len(), 39); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 34); + EXPECT_EQ(row.get_variable_len(), 39); OlapTuple tuple1(scan_keys); res = row.from_tuple(tuple1); - ASSERT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(res, OLAP_SUCCESS); OlapTuple tuple2 = row.to_tuple(); - ASSERT_TRUE(strncmp(tuple2.get_value(0).c_str(), "0&char_exceed_length", 20)); - ASSERT_TRUE(strncmp(tuple2.get_value(1).c_str(), "0&varchar_exceed_length", 23)); + EXPECT_TRUE(strncmp(tuple2.get_value(0).c_str(), "0&char_exceed_length", 20)); + EXPECT_TRUE(strncmp(tuple2.get_value(1).c_str(), "0&varchar_exceed_length", 23)); } TEST_F(TestRowCursor, EqualAndCompare) { @@ -335,9 +335,9 @@ TEST_F(TestRowCursor, EqualAndCompare) { RowCursor left; OLAPStatus res = left.init(tablet_schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(left.get_fixed_len(), 78); - ASSERT_EQ(left.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(left.get_fixed_len(), 78); + EXPECT_EQ(left.get_variable_len(), 20); Slice l_char("well"); int32_t l_int = 10; @@ -352,19 +352,19 @@ TEST_F(TestRowCursor, EqualAndCompare) { res = right_eq.init(tablet_schema, col_ids); Slice r_char_eq = ("well"); right_eq.set_field_content(0, reinterpret_cast(&r_char_eq), _mem_pool.get()); - ASSERT_EQ(compare_row_key(left, right_eq), 0); + EXPECT_EQ(compare_row_key(left, right_eq), 0); RowCursor right_lt; res = right_lt.init(tablet_schema, col_ids); Slice r_char_lt = ("welm"); right_lt.set_field_content(0, reinterpret_cast(&r_char_lt), _mem_pool.get()); - ASSERT_LT(compare_row_key(left, right_lt), 0); + EXPECT_LT(compare_row_key(left, right_lt), 0); RowCursor right_gt; res = right_gt.init(tablet_schema, col_ids); Slice r_char_gt = ("welk"); right_gt.set_field_content(0, reinterpret_cast(&r_char_gt), _mem_pool.get()); - ASSERT_GT(compare_row_key(left, right_gt), 0); + EXPECT_GT(compare_row_key(left, right_gt), 0); } TEST_F(TestRowCursor, IndexCmp) { @@ -373,9 +373,9 @@ TEST_F(TestRowCursor, IndexCmp) { RowCursor left; OLAPStatus res = left.init(tablet_schema, 2); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(left.get_fixed_len(), 22); - ASSERT_EQ(left.get_variable_len(), 4); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(left.get_fixed_len(), 22); + EXPECT_EQ(left.get_variable_len(), 4); Slice l_char("well"); int32_t l_int = 10; @@ -389,7 +389,7 @@ TEST_F(TestRowCursor, IndexCmp) { right_eq.set_field_content(0, reinterpret_cast(&r_char_eq), _mem_pool.get()); right_eq.set_field_content(1, reinterpret_cast(&r_int_eq), _mem_pool.get()); - ASSERT_EQ(index_compare_row(left, right_eq), 0); + EXPECT_EQ(index_compare_row(left, right_eq), 0); RowCursor right_lt; res = right_lt.init(tablet_schema, 2); @@ -397,7 +397,7 @@ TEST_F(TestRowCursor, IndexCmp) { int32_t r_int_lt = 11; right_lt.set_field_content(0, reinterpret_cast(&r_char_lt), _mem_pool.get()); right_lt.set_field_content(1, reinterpret_cast(&r_int_lt), _mem_pool.get()); - ASSERT_LT(index_compare_row(left, right_lt), 0); + EXPECT_LT(index_compare_row(left, right_lt), 0); RowCursor right_gt; res = right_gt.init(tablet_schema, 2); @@ -405,7 +405,7 @@ TEST_F(TestRowCursor, IndexCmp) { int32_t r_int_gt = 10; right_gt.set_field_content(0, reinterpret_cast(&r_char_gt), _mem_pool.get()); right_gt.set_field_content(1, reinterpret_cast(&r_int_gt), _mem_pool.get()); - ASSERT_GT(index_compare_row(left, right_gt), 0); + EXPECT_GT(index_compare_row(left, right_gt), 0); } TEST_F(TestRowCursor, FullKeyCmp) { @@ -414,9 +414,9 @@ TEST_F(TestRowCursor, FullKeyCmp) { RowCursor left; OLAPStatus res = left.init(tablet_schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(left.get_fixed_len(), 78); - ASSERT_EQ(left.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(left.get_fixed_len(), 78); + EXPECT_EQ(left.get_variable_len(), 20); Slice l_char("well"); int32_t l_int = 10; @@ -429,7 +429,7 @@ TEST_F(TestRowCursor, FullKeyCmp) { int32_t r_int_eq = 10; right_eq.set_field_content(0, reinterpret_cast(&r_char_eq), _mem_pool.get()); right_eq.set_field_content(1, reinterpret_cast(&r_int_eq), _mem_pool.get()); - ASSERT_EQ(compare_row(left, right_eq), 0); + EXPECT_EQ(compare_row(left, right_eq), 0); RowCursor right_lt; res = right_lt.init(tablet_schema); @@ -437,7 +437,7 @@ TEST_F(TestRowCursor, FullKeyCmp) { int32_t r_int_lt = 11; right_lt.set_field_content(0, reinterpret_cast(&r_char_lt), _mem_pool.get()); right_lt.set_field_content(1, reinterpret_cast(&r_int_lt), _mem_pool.get()); - ASSERT_LT(compare_row(left, right_lt), 0); + EXPECT_LT(compare_row(left, right_lt), 0); RowCursor right_gt; res = right_gt.init(tablet_schema); @@ -445,7 +445,7 @@ TEST_F(TestRowCursor, FullKeyCmp) { int32_t r_int_gt = 10; right_gt.set_field_content(0, reinterpret_cast(&r_char_gt), _mem_pool.get()); right_gt.set_field_content(1, reinterpret_cast(&r_int_gt), _mem_pool.get()); - ASSERT_GT(compare_row(left, right_gt), 0); + EXPECT_GT(compare_row(left, right_gt), 0); } TEST_F(TestRowCursor, AggregateWithoutNull) { @@ -455,9 +455,9 @@ TEST_F(TestRowCursor, AggregateWithoutNull) { RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 78); - ASSERT_EQ(row.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 78); + EXPECT_EQ(row.get_variable_len(), 20); row.allocate_memory_for_string_type(tablet_schema); RowCursor left; @@ -500,16 +500,16 @@ TEST_F(TestRowCursor, AggregateWithoutNull) { int128_t agg_value = 0; memcpy(&agg_value, row.cell_ptr(2), 16); - ASSERT_TRUE(agg_value == ((int128_t)(1) << 101)); + EXPECT_TRUE(agg_value == ((int128_t)(1) << 101)); double agg_double = *reinterpret_cast(row.cell_ptr(3)); - ASSERT_TRUE(agg_double == r_double); + EXPECT_TRUE(agg_double == r_double); decimal12_t agg_decimal = *reinterpret_cast(row.cell_ptr(4)); - ASSERT_TRUE(agg_decimal == r_decimal); + EXPECT_TRUE(agg_decimal == r_decimal); Slice* agg_varchar = reinterpret_cast(row.cell_ptr(5)); - ASSERT_EQ(agg_varchar->compare(r_varchar), 0); + EXPECT_EQ(agg_varchar->compare(r_varchar), 0); } TEST_F(TestRowCursor, AggregateWithNull) { @@ -519,9 +519,9 @@ TEST_F(TestRowCursor, AggregateWithNull) { RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(res, OLAP_SUCCESS); - ASSERT_EQ(row.get_fixed_len(), 78); - ASSERT_EQ(row.get_variable_len(), 20); + EXPECT_EQ(res, OLAP_SUCCESS); + EXPECT_EQ(row.get_fixed_len(), 78); + EXPECT_EQ(row.get_variable_len(), 20); row.allocate_memory_for_string_type(tablet_schema); RowCursor left; @@ -561,21 +561,16 @@ TEST_F(TestRowCursor, AggregateWithNull) { int128_t agg_value = 0; memcpy(&agg_value, row.cell_ptr(2), 16); - ASSERT_TRUE(agg_value == ((int128_t)(1) << 101)); + EXPECT_TRUE(agg_value == ((int128_t)(1) << 101)); bool is_null_double = left.is_null(3); - ASSERT_TRUE(is_null_double); + EXPECT_TRUE(is_null_double); decimal12_t agg_decimal = *reinterpret_cast(row.cell_ptr(4)); - ASSERT_TRUE(agg_decimal == r_decimal); + EXPECT_TRUE(agg_decimal == r_decimal); bool is_null_varchar = row.is_null(5); - ASSERT_TRUE(is_null_varchar); + EXPECT_TRUE(is_null_varchar); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/alpha_rowset_test.cpp b/be/test/olap/rowset/alpha_rowset_test.cpp index bfa198265e..85e8d4d0e6 100644 --- a/be/test/olap/rowset/alpha_rowset_test.cpp +++ b/be/test/olap/rowset/alpha_rowset_test.cpp @@ -48,28 +48,41 @@ using std::string; namespace doris { static const uint32_t MAX_PATH_LEN = 1024; +static StorageEngine* k_engine = nullptr; void set_up() { config::path_gc_check = false; char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = std::string(buffer) + "/data_test"; FileUtils::remove_all(config::storage_root_path); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); std::vector paths; paths.emplace_back(config::storage_root_path, -1); + + doris::EngineOptions options; + options.store_paths = paths; + Status s = doris::StorageEngine::open(options, &k_engine); + EXPECT_TRUE(s.ok()) << s.to_string(); + + ExecEnv* exec_env = doris::ExecEnv::GetInstance(); + exec_env->set_storage_engine(k_engine); std::string data_path = config::storage_root_path + "/data"; - ASSERT_TRUE(FileUtils::create_dir(data_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(data_path).ok()); std::string shard_path = data_path + "/0"; - ASSERT_TRUE(FileUtils::create_dir(shard_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(shard_path).ok()); std::string tablet_path = shard_path + "/12345"; - ASSERT_TRUE(FileUtils::create_dir(tablet_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(tablet_path).ok()); std::string schema_hash_path = tablet_path + "/1111"; - ASSERT_TRUE(FileUtils::create_dir(schema_hash_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(schema_hash_path).ok()); } void tear_down() { - FileUtils::remove_all(config::storage_root_path); + if (k_engine != nullptr) { + k_engine->stop(); + delete k_engine; + k_engine = nullptr; + } } void create_rowset_writer_context(TabletSchema* tablet_schema, @@ -108,7 +121,7 @@ void create_rowset_reader_context(TabletSchema* tablet_schema, rowset_reader_context->conditions = conditions; } -void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { +static void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { TabletSchemaPB tablet_schema_pb; tablet_schema_pb.set_keys_type(keys_type); tablet_schema_pb.set_num_short_key_columns(2); @@ -156,7 +169,6 @@ public: _mem_tracker.reset(new MemTracker(-1)); _mem_pool.reset(new MemPool(_mem_tracker.get())); } - virtual void TearDown() { tear_down(); } private: @@ -170,11 +182,11 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetWriter) { create_tablet_schema(AGG_KEYS, &tablet_schema); RowsetWriterContext rowset_writer_context; create_rowset_writer_context(&tablet_schema, &rowset_writer_context); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset_writer(rowset_writer_context, &_alpha_rowset_writer)); RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); int32_t field_0 = 10; row.set_field_content(0, reinterpret_cast(&field_0), _mem_pool.get()); @@ -185,11 +197,11 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetWriter) { _alpha_rowset_writer->add_row(row); _alpha_rowset_writer->flush(); RowsetSharedPtr alpha_rowset = _alpha_rowset_writer->build(); - ASSERT_TRUE(alpha_rowset != nullptr); + EXPECT_TRUE(alpha_rowset != nullptr); RowsetId rowset_id; rowset_id.init(10000); - ASSERT_EQ(rowset_id, alpha_rowset->rowset_id()); - ASSERT_EQ(1, alpha_rowset->num_rows()); + EXPECT_EQ(rowset_id, alpha_rowset->rowset_id()); + EXPECT_EQ(1, alpha_rowset->num_rows()); } TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { @@ -198,12 +210,12 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { RowsetWriterContext rowset_writer_context; create_rowset_writer_context(&tablet_schema, &rowset_writer_context); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset_writer(rowset_writer_context, &_alpha_rowset_writer)); RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); int32_t field_0 = 10; row.set_not_null(0); @@ -215,18 +227,18 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { row.set_not_null(2); row.set_field_content(2, reinterpret_cast(&field_2), _mem_pool.get()); res = _alpha_rowset_writer->add_row(row); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); res = _alpha_rowset_writer->flush(); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); RowsetSharedPtr alpha_rowset = _alpha_rowset_writer->build(); - ASSERT_TRUE(alpha_rowset != nullptr); + EXPECT_TRUE(alpha_rowset != nullptr); RowsetId rowset_id; rowset_id.init(10000); - ASSERT_EQ(rowset_id, alpha_rowset->rowset_id()); - ASSERT_EQ(1, alpha_rowset->num_rows()); + EXPECT_EQ(rowset_id, alpha_rowset->rowset_id()); + EXPECT_EQ(1, alpha_rowset->num_rows()); RowsetReaderSharedPtr rowset_reader; res = alpha_rowset->create_reader(&rowset_reader); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); std::vector return_columns; for (int i = 0; i < tablet_schema.num_columns(); ++i) { return_columns.push_back(i); @@ -234,7 +246,7 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { DeleteHandler delete_handler; DelPredicateArray predicate_array; res = delete_handler.init(tablet_schema, predicate_array, 4); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); RowsetReaderContext rowset_reader_context; std::set load_bf_columns; @@ -243,11 +255,11 @@ TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { create_rowset_reader_context(&tablet_schema, &return_columns, &delete_handler, &predicates, &load_bf_columns, &conditions, &rowset_reader_context); res = rowset_reader->init(&rowset_reader_context); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); RowBlock* row_block = nullptr; res = rowset_reader->next_block(&row_block); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(1, row_block->remaining()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(1, row_block->remaining()); } TEST_F(AlphaRowsetTest, TestRowCursorWithOrdinal) { @@ -307,20 +319,15 @@ TEST_F(AlphaRowsetTest, TestRowCursorWithOrdinal) { // should be: // row1, row3, row2 AlphaMergeContext* top1 = queue.top(); - ASSERT_EQ(top1, &ctx1); + EXPECT_EQ(top1, &ctx1); queue.pop(); AlphaMergeContext* top2 = queue.top(); - ASSERT_EQ(top2, &ctx3); + EXPECT_EQ(top2, &ctx3); queue.pop(); AlphaMergeContext* top3 = queue.top(); - ASSERT_EQ(top3, &ctx2); + EXPECT_EQ(top3, &ctx2); queue.pop(); - ASSERT_TRUE(queue.empty()); + EXPECT_TRUE(queue.empty()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/beta_rowset_test.cpp b/be/test/olap/rowset/beta_rowset_test.cpp index 752b9b5e3d..0725aacd10 100644 --- a/be/test/olap/rowset/beta_rowset_test.cpp +++ b/be/test/olap/rowset/beta_rowset_test.cpp @@ -45,6 +45,15 @@ static const uint32_t MAX_PATH_LEN = 1024; StorageEngine* k_engine = nullptr; class BetaRowsetTest : public testing::Test { +public: + static void TearDownTestSuite() { + if (k_engine != nullptr) { + k_engine->stop(); + delete k_engine; + k_engine = nullptr; + } + } + protected: OlapReaderStatistics _stats; @@ -54,11 +63,11 @@ protected: config::txn_shard_size = 1; char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = std::string(buffer) + "/data_test"; - ASSERT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); std::vector paths; paths.emplace_back(config::storage_root_path, -1); @@ -66,18 +75,18 @@ protected: doris::EngineOptions options; options.store_paths = paths; Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); ExecEnv* exec_env = doris::ExecEnv::GetInstance(); exec_env->set_storage_engine(k_engine); const std::string rowset_dir = "./data_test/data/beta_rowset_test"; - ASSERT_TRUE(FileUtils::create_dir(rowset_dir).ok()); + EXPECT_TRUE(FileUtils::create_dir(rowset_dir).ok()); } void TearDown() override { if (FileUtils::check_exist(config::storage_root_path)) { - ASSERT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::remove_all(config::storage_root_path).ok()); } } @@ -144,11 +153,11 @@ protected: void create_and_init_rowset_reader(Rowset* rowset, RowsetReaderContext& context, RowsetReaderSharedPtr* result) { auto s = rowset->create_reader(result); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_TRUE(*result != nullptr); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_TRUE(*result != nullptr); s = (*result)->init(&context); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); } }; @@ -166,7 +175,7 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { std::unique_ptr rowset_writer; s = RowsetFactory::create_rowset_writer(writer_context, &rowset_writer); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); RowCursor input_row; input_row.init(tablet_schema); @@ -185,16 +194,16 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { input_row.set_field_content(1, reinterpret_cast(&k2), &mem_pool); input_row.set_field_content(2, reinterpret_cast(&k3), &mem_pool); s = rowset_writer->add_row(input_row); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); } s = rowset_writer->flush(); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); } rowset = rowset_writer->build(); - ASSERT_TRUE(rowset != nullptr); - ASSERT_EQ(num_segments, rowset->rowset_meta()->num_segments()); - ASSERT_EQ(num_segments * rows_per_segment, rowset->rowset_meta()->num_rows()); + EXPECT_TRUE(rowset != nullptr); + EXPECT_EQ(num_segments, rowset->rowset_meta()->num_segments()); + EXPECT_EQ(num_segments * rows_per_segment, rowset->rowset_meta()->num_rows()); } { // test return ordered results and return k1 and k2 @@ -213,25 +222,25 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { - ASSERT_TRUE(output_block != nullptr); - ASSERT_GT(output_block->row_num(), 0); - ASSERT_EQ(0, output_block->pos()); - ASSERT_EQ(output_block->row_num(), output_block->limit()); - ASSERT_EQ(return_columns, output_block->row_block_info().column_ids); + EXPECT_TRUE(output_block != nullptr); + EXPECT_GT(output_block->row_num(), 0); + EXPECT_EQ(0, output_block->pos()); + EXPECT_EQ(output_block->row_num(), output_block->limit()); + EXPECT_EQ(return_columns, output_block->row_block_info().column_ids); // after sort merge segments, k1 will be 0, 1, 2, 10, 11, 12, 20, 21, 22, ..., 40950, 40951, 40952 for (int i = 0; i < output_block->row_num(); ++i) { char* field1 = output_block->field_ptr(i, 0); char* field2 = output_block->field_ptr(i, 1); // test null bit - ASSERT_FALSE(*reinterpret_cast(field1)); - ASSERT_FALSE(*reinterpret_cast(field2)); + EXPECT_FALSE(*reinterpret_cast(field1)); + EXPECT_FALSE(*reinterpret_cast(field2)); uint32_t k1 = *reinterpret_cast(field1 + 1); uint32_t k2 = *reinterpret_cast(field2 + 1); - ASSERT_EQ(k1 * 10, k2); + EXPECT_EQ(k1 * 10, k2); int rid = num_rows_read / 3; int seg_id = num_rows_read % 3; - ASSERT_EQ(rid * 10 + seg_id, k1); + EXPECT_EQ(rid * 10 + seg_id, k1); num_rows_read++; } } @@ -252,22 +261,22 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { - ASSERT_TRUE(output_block != nullptr); - ASSERT_EQ(1, output_block->row_num()); - ASSERT_EQ(0, output_block->pos()); - ASSERT_EQ(output_block->row_num(), output_block->limit()); - ASSERT_EQ(return_columns, output_block->row_block_info().column_ids); + EXPECT_TRUE(output_block != nullptr); + EXPECT_EQ(1, output_block->row_num()); + EXPECT_EQ(0, output_block->pos()); + EXPECT_EQ(output_block->row_num(), output_block->limit()); + EXPECT_EQ(return_columns, output_block->row_block_info().column_ids); // after sort merge segments, k1 will be 10 for (int i = 0; i < output_block->row_num(); ++i) { char* field1 = output_block->field_ptr(i, 0); char* field2 = output_block->field_ptr(i, 1); // test null bit - ASSERT_FALSE(*reinterpret_cast(field1)); - ASSERT_FALSE(*reinterpret_cast(field2)); + EXPECT_FALSE(*reinterpret_cast(field1)); + EXPECT_FALSE(*reinterpret_cast(field2)); uint32_t k1 = *reinterpret_cast(field1 + 1); uint32_t k2 = *reinterpret_cast(field2 + 1); - ASSERT_EQ(10, k1); - ASSERT_EQ(k1 * 10, k2); + EXPECT_EQ(10, k1); + EXPECT_EQ(k1 * 10, k2); num_rows_read++; } } @@ -294,18 +303,18 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { - ASSERT_TRUE(output_block != nullptr); - ASSERT_GT(output_block->row_num(), 0); - ASSERT_EQ(0, output_block->pos()); - ASSERT_EQ(output_block->row_num(), output_block->limit()); - ASSERT_EQ(return_columns, output_block->row_block_info().column_ids); + EXPECT_TRUE(output_block != nullptr); + EXPECT_GT(output_block->row_num(), 0); + EXPECT_EQ(0, output_block->pos()); + EXPECT_EQ(output_block->row_num(), output_block->limit()); + EXPECT_EQ(return_columns, output_block->row_block_info().column_ids); // for unordered result, k3 will be 0, 1, 2, ..., 4096*3-1 for (int i = 0; i < output_block->row_num(); ++i) { char* field3 = output_block->field_ptr(i, 2); // test null bit - ASSERT_FALSE(*reinterpret_cast(field3)); + EXPECT_FALSE(*reinterpret_cast(field3)); uint32_t k3 = *reinterpret_cast(field3 + 1); - ASSERT_EQ(num_rows_read, k3); + EXPECT_EQ(num_rows_read, k3); num_rows_read++; } } @@ -327,18 +336,18 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { RowBlock* output_block; uint32_t num_rows_read = 0; while ((s = rowset_reader->next_block(&output_block)) == OLAP_SUCCESS) { - ASSERT_TRUE(output_block != nullptr); - ASSERT_LE(output_block->row_num(), 100); - ASSERT_EQ(0, output_block->pos()); - ASSERT_EQ(output_block->row_num(), output_block->limit()); - ASSERT_EQ(return_columns, output_block->row_block_info().column_ids); + EXPECT_TRUE(output_block != nullptr); + EXPECT_LE(output_block->row_num(), 100); + EXPECT_EQ(0, output_block->pos()); + EXPECT_EQ(output_block->row_num(), output_block->limit()); + EXPECT_EQ(return_columns, output_block->row_block_info().column_ids); // for unordered result, k3 will be 0, 1, 2, ..., 99 for (int i = 0; i < output_block->row_num(); ++i) { char* field3 = output_block->field_ptr(i, 2); // test null bit - ASSERT_FALSE(*reinterpret_cast(field3)); + EXPECT_FALSE(*reinterpret_cast(field3)); uint32_t k3 = *reinterpret_cast(field3 + 1); - ASSERT_EQ(num_rows_read, k3); + EXPECT_EQ(num_rows_read, k3); num_rows_read++; } } @@ -351,10 +360,3 @@ TEST_F(BetaRowsetTest, BasicFunctionTest) { } } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - doris::SegmentLoader::create_global_instance(1000); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/rowset_converter_test.cpp b/be/test/olap/rowset/rowset_converter_test.cpp index 2c0bf93171..26fcf38f66 100644 --- a/be/test/olap/rowset/rowset_converter_test.cpp +++ b/be/test/olap/rowset/rowset_converter_test.cpp @@ -50,10 +50,10 @@ using std::string; namespace doris { static const uint32_t MAX_PATH_LEN = 1024; -StorageEngine* k_engine = nullptr; +static StorageEngine* k_engine = nullptr; -void create_rowset_writer_context(TabletSchema* tablet_schema, RowsetTypePB dst_type, - RowsetWriterContext* rowset_writer_context) { +static void create_rowset_writer_context(TabletSchema* tablet_schema, RowsetTypePB dst_type, + RowsetWriterContext* rowset_writer_context) { RowsetId rowset_id; rowset_id.init(10000); rowset_writer_context->rowset_id = rowset_id; @@ -68,12 +68,13 @@ void create_rowset_writer_context(TabletSchema* tablet_schema, RowsetTypePB dst_ rowset_writer_context->version.second = 1; } -void create_rowset_reader_context(TabletSchema* tablet_schema, - const std::vector* return_columns, - const DeleteHandler* delete_handler, - std::vector* predicates, - std::set* load_bf_columns, Conditions* conditions, - RowsetReaderContext* rowset_reader_context) { +static void create_rowset_reader_context(TabletSchema* tablet_schema, + const std::vector* return_columns, + const DeleteHandler* delete_handler, + std::vector* predicates, + std::set* load_bf_columns, + Conditions* conditions, + RowsetReaderContext* rowset_reader_context) { rowset_reader_context->reader_type = READER_ALTER_TABLE; rowset_reader_context->tablet_schema = tablet_schema; rowset_reader_context->need_ordered_result = true; @@ -89,7 +90,7 @@ void create_rowset_reader_context(TabletSchema* tablet_schema, rowset_reader_context->conditions = conditions; } -void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { +static void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { TabletSchemaPB tablet_schema_pb; tablet_schema_pb.set_keys_type(keys_type); tablet_schema_pb.set_num_short_key_columns(2); @@ -130,7 +131,7 @@ void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { tablet_schema->init_from_pb(tablet_schema_pb); } -void create_tablet_meta(TabletSchema* tablet_schema, TabletMeta* tablet_meta) { +static void create_tablet_meta(TabletSchema* tablet_schema, TabletMeta* tablet_meta) { TabletMetaPB tablet_meta_pb; tablet_meta_pb.set_table_id(10000); tablet_meta_pb.set_tablet_id(12345); @@ -157,10 +158,10 @@ public: config::txn_shard_size = 1; config::path_gc_check = false; char buffer[MAX_PATH_LEN]; - ASSERT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); + EXPECT_NE(getcwd(buffer, MAX_PATH_LEN), nullptr); config::storage_root_path = std::string(buffer) + "/data_test"; FileUtils::remove_all(config::storage_root_path); - ASSERT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(config::storage_root_path).ok()); std::vector paths; paths.emplace_back(config::storage_root_path, -1); @@ -168,25 +169,32 @@ public: options.store_paths = paths; if (k_engine == nullptr) { Status s = doris::StorageEngine::open(options, &k_engine); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); } ExecEnv* exec_env = doris::ExecEnv::GetInstance(); exec_env->set_storage_engine(k_engine); std::string data_path = config::storage_root_path + "/data"; - ASSERT_TRUE(FileUtils::create_dir(data_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(data_path).ok()); std::string shard_path = data_path + "/0"; - ASSERT_TRUE(FileUtils::create_dir(shard_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(shard_path).ok()); std::string tablet_path = shard_path + "/12345"; - ASSERT_TRUE(FileUtils::create_dir(tablet_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(tablet_path).ok()); _schema_hash_path = tablet_path + "/1111"; - ASSERT_TRUE(FileUtils::create_dir(_schema_hash_path).ok()); + EXPECT_TRUE(FileUtils::create_dir(_schema_hash_path).ok()); _mem_tracker.reset(new MemTracker(-1)); _mem_pool.reset(new MemPool(_mem_tracker.get())); } - virtual void TearDown() { FileUtils::remove_all(config::storage_root_path); } + virtual void TearDown() { + if (k_engine != nullptr) { + k_engine->stop(); + delete k_engine; + k_engine = nullptr; + } + FileUtils::remove_all(config::storage_root_path); + } void process(RowsetTypePB src_type, RowsetTypePB dst_type); @@ -203,11 +211,11 @@ void RowsetConverterTest::process(RowsetTypePB src_type, RowsetTypePB dst_type) RowsetWriterContext rowset_writer_context; create_rowset_writer_context(&tablet_schema, src_type, &rowset_writer_context); std::unique_ptr _rowset_writer; - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset_writer(rowset_writer_context, &_rowset_writer)); RowCursor row; OLAPStatus res = row.init(tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); std::vector test_data; for (int i = 0; i < 1024; ++i) { @@ -223,11 +231,11 @@ void RowsetConverterTest::process(RowsetTypePB src_type, RowsetTypePB dst_type) } _rowset_writer->flush(); RowsetSharedPtr src_rowset = _rowset_writer->build(); - ASSERT_TRUE(src_rowset != nullptr); + EXPECT_TRUE(src_rowset != nullptr); RowsetId src_rowset_id; src_rowset_id.init(10000); - ASSERT_EQ(src_rowset_id, src_rowset->rowset_id()); - ASSERT_EQ(1024, src_rowset->num_rows()); + EXPECT_EQ(src_rowset_id, src_rowset->rowset_id()); + EXPECT_EQ(1024, src_rowset->num_rows()); // convert TabletMetaSharedPtr tablet_meta(new TabletMeta()); @@ -237,28 +245,28 @@ void RowsetConverterTest::process(RowsetTypePB src_type, RowsetTypePB dst_type) FilePathDesc schema_hash_path_desc; schema_hash_path_desc.filepath = _schema_hash_path; if (dst_type == BETA_ROWSET) { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, rowset_converter.convert_alpha_to_beta( src_rowset->rowset_meta(), schema_hash_path_desc, &dst_rowset_meta_pb)); } else { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, rowset_converter.convert_beta_to_alpha( src_rowset->rowset_meta(), schema_hash_path_desc, &dst_rowset_meta_pb)); } - ASSERT_EQ(dst_type, dst_rowset_meta_pb.rowset_type()); - ASSERT_EQ(12345, dst_rowset_meta_pb.tablet_id()); - ASSERT_EQ(1024, dst_rowset_meta_pb.num_rows()); + EXPECT_EQ(dst_type, dst_rowset_meta_pb.rowset_type()); + EXPECT_EQ(12345, dst_rowset_meta_pb.tablet_id()); + EXPECT_EQ(1024, dst_rowset_meta_pb.num_rows()); // read RowsetMetaSharedPtr dst_rowset_meta(new RowsetMeta()); - ASSERT_TRUE(dst_rowset_meta->init_from_pb(dst_rowset_meta_pb)); + EXPECT_TRUE(dst_rowset_meta->init_from_pb(dst_rowset_meta_pb)); RowsetSharedPtr dst_rowset; - ASSERT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(&tablet_schema, schema_hash_path_desc, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(&tablet_schema, schema_hash_path_desc, dst_rowset_meta, &dst_rowset)); RowsetReaderSharedPtr dst_rowset_reader; - ASSERT_EQ(OLAP_SUCCESS, dst_rowset->create_reader(&dst_rowset_reader)); + EXPECT_EQ(OLAP_SUCCESS, dst_rowset->create_reader(&dst_rowset_reader)); RowsetReaderContext rowset_reader_context; std::set load_bf_columns; std::vector predicates; @@ -271,19 +279,19 @@ void RowsetConverterTest::process(RowsetTypePB src_type, RowsetTypePB dst_type) create_rowset_reader_context(&tablet_schema, &return_columns, &delete_handler, &predicates, &load_bf_columns, &conditions, &rowset_reader_context); res = dst_rowset_reader->init(&rowset_reader_context); - ASSERT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(OLAP_SUCCESS, res); RowBlock* row_block = nullptr; res = dst_rowset_reader->next_block(&row_block); - ASSERT_EQ(OLAP_SUCCESS, res); - ASSERT_EQ(1024, row_block->remaining()); + EXPECT_EQ(OLAP_SUCCESS, res); + EXPECT_EQ(1024, row_block->remaining()); RowCursor row_cursor; row_cursor.init(tablet_schema); for (int i = 0; i < 1024; ++i) { row_block->get_row(i, &row_cursor); - ASSERT_EQ(i, *(uint32_t*)row_cursor.cell_ptr(0)); - ASSERT_EQ("well" + std::to_string(i), (*(Slice*)row_cursor.cell_ptr(1)).to_string()); - ASSERT_EQ(10000 + i, *(uint32_t*)row_cursor.cell_ptr(2)); + EXPECT_EQ(i, *(uint32_t*)row_cursor.cell_ptr(0)); + EXPECT_EQ("well" + std::to_string(i), (*(Slice*)row_cursor.cell_ptr(1)).to_string()); + EXPECT_EQ(10000 + i, *(uint32_t*)row_cursor.cell_ptr(2)); } } @@ -296,10 +304,3 @@ TEST_F(RowsetConverterTest, TestConvertBetaRowsetToAlpha) { } } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - doris::SegmentLoader::create_global_instance(1000); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/rowset_meta_manager_test.cpp b/be/test/olap/rowset/rowset_meta_manager_test.cpp index 678325e10b..54fcf6e79d 100644 --- a/be/test/olap/rowset/rowset_meta_manager_test.cpp +++ b/be/test/olap/rowset/rowset_meta_manager_test.cpp @@ -18,8 +18,8 @@ #include "olap/rowset/rowset_meta_manager.h" #include -#include #include +#include #include #include @@ -40,13 +40,12 @@ using std::string; namespace doris { -static StorageEngine* k_engine = nullptr; - const std::string rowset_meta_path = "./be/test/olap/test_data/rowset_meta.json"; class RowsetMetaManagerTest : public testing::Test { public: virtual void SetUp() { + LOG(INFO) << "SetUp"; config::tablet_map_shard_size = 1; config::txn_map_shard_size = 1; config::txn_shard_size = 1; @@ -58,12 +57,12 @@ public: } std::string meta_path = "./meta"; - ASSERT_TRUE(std::filesystem::create_directory(meta_path)); + EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); - ASSERT_NE(nullptr, _meta); + EXPECT_NE(nullptr, _meta); OLAPStatus st = _meta->init(); - ASSERT_TRUE(st == OLAP_SUCCESS); - ASSERT_TRUE(std::filesystem::exists("./meta")); + EXPECT_TRUE(st == OLAP_SUCCESS); + EXPECT_TRUE(std::filesystem::exists("./meta")); std::ifstream infile(rowset_meta_path); char buffer[1024]; @@ -78,14 +77,17 @@ public: } virtual void TearDown() { - delete _meta; - ASSERT_TRUE(std::filesystem::remove_all("./meta")); + SAFE_DELETE(_meta); + SAFE_DELETE(k_engine); + EXPECT_TRUE(std::filesystem::remove_all("./meta")); + LOG(INFO) << "TearDown"; } + StorageEngine* k_engine = nullptr; private: OlapMeta* _meta; std::string _json_rowset_meta; - TabletUid _tablet_uid{0, 0}; + TabletUid _tablet_uid {0, 0}; }; TEST_F(RowsetMetaManagerTest, TestSaveAndGetAndRemove) { @@ -93,41 +95,36 @@ TEST_F(RowsetMetaManagerTest, TestSaveAndGetAndRemove) { rowset_id.init(10000); RowsetMeta rowset_meta; rowset_meta.init_from_json(_json_rowset_meta); - ASSERT_EQ(rowset_meta.rowset_id(), rowset_id); + EXPECT_EQ(rowset_meta.rowset_id(), rowset_id); RowsetMetaPB rowset_meta_pb; rowset_meta.to_rowset_pb(&rowset_meta_pb); OLAPStatus status = RowsetMetaManager::save(_meta, _tablet_uid, rowset_id, rowset_meta_pb); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); std::string json_rowset_meta_read; status = RowsetMetaManager::get_json_rowset_meta(_meta, _tablet_uid, rowset_id, &json_rowset_meta_read); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_EQ(_json_rowset_meta, json_rowset_meta_read); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_EQ(_json_rowset_meta, json_rowset_meta_read); status = RowsetMetaManager::remove(_meta, _tablet_uid, rowset_id); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_FALSE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_FALSE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); RowsetMetaSharedPtr rowset_meta_read(new RowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, rowset_id, rowset_meta_read); - ASSERT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != OLAP_SUCCESS); } TEST_F(RowsetMetaManagerTest, TestLoad) { RowsetId rowset_id; rowset_id.init(10000); OLAPStatus status = RowsetMetaManager::load_json_rowset_meta(_meta, rowset_meta_path); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(RowsetMetaManager::check_rowset_meta(_meta, _tablet_uid, rowset_id)); std::string json_rowset_meta_read; status = RowsetMetaManager::get_json_rowset_meta(_meta, _tablet_uid, rowset_id, &json_rowset_meta_read); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_EQ(_json_rowset_meta, json_rowset_meta_read); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_EQ(_json_rowset_meta, json_rowset_meta_read); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/rowset_meta_test.cpp b/be/test/olap/rowset/rowset_meta_test.cpp index e8b577bd3e..da101f0f6b 100644 --- a/be/test/olap/rowset/rowset_meta_test.cpp +++ b/be/test/olap/rowset/rowset_meta_test.cpp @@ -17,8 +17,8 @@ #include "olap/rowset/rowset_meta.h" -#include #include +#include #include #include @@ -45,12 +45,12 @@ class RowsetMetaTest : public testing::Test { public: virtual void SetUp() { std::string meta_path = "./meta"; - ASSERT_TRUE(std::filesystem::create_directory(meta_path)); + EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); - ASSERT_NE(nullptr, _meta); + EXPECT_NE(nullptr, _meta); OLAPStatus st = _meta->init(); - ASSERT_TRUE(st == OLAP_SUCCESS); - ASSERT_TRUE(std::filesystem::exists("./meta")); + EXPECT_TRUE(st == OLAP_SUCCESS); + EXPECT_TRUE(std::filesystem::exists("./meta")); std::ifstream infile(rowset_meta_path); char buffer[1024]; @@ -64,7 +64,7 @@ public: virtual void TearDown() { delete _meta; - ASSERT_TRUE(std::filesystem::remove_all("./meta")); + EXPECT_TRUE(std::filesystem::remove_all("./meta")); } private: @@ -75,25 +75,25 @@ private: void do_check(RowsetMeta rowset_meta) { RowsetId rowset_id; rowset_id.init(540081); - ASSERT_EQ(rowset_id, rowset_meta.rowset_id()); - ASSERT_EQ(15673, rowset_meta.tablet_id()); - ASSERT_EQ(4042, rowset_meta.txn_id()); - ASSERT_EQ(567997577, rowset_meta.tablet_schema_hash()); - ASSERT_EQ(ALPHA_ROWSET, rowset_meta.rowset_type()); - ASSERT_EQ(VISIBLE, rowset_meta.rowset_state()); - ASSERT_EQ(2, rowset_meta.start_version()); - ASSERT_EQ(2, rowset_meta.end_version()); - ASSERT_EQ(3929, rowset_meta.num_rows()); - ASSERT_EQ(84699, rowset_meta.total_disk_size()); - ASSERT_EQ(84464, rowset_meta.data_disk_size()); - ASSERT_EQ(235, rowset_meta.index_disk_size()); - ASSERT_EQ(false, rowset_meta.empty()); - ASSERT_EQ(1553765670, rowset_meta.creation_time()); + EXPECT_EQ(rowset_id, rowset_meta.rowset_id()); + EXPECT_EQ(15673, rowset_meta.tablet_id()); + EXPECT_EQ(4042, rowset_meta.txn_id()); + EXPECT_EQ(567997577, rowset_meta.tablet_schema_hash()); + EXPECT_EQ(ALPHA_ROWSET, rowset_meta.rowset_type()); + EXPECT_EQ(VISIBLE, rowset_meta.rowset_state()); + EXPECT_EQ(2, rowset_meta.start_version()); + EXPECT_EQ(2, rowset_meta.end_version()); + EXPECT_EQ(3929, rowset_meta.num_rows()); + EXPECT_EQ(84699, rowset_meta.total_disk_size()); + EXPECT_EQ(84464, rowset_meta.data_disk_size()); + EXPECT_EQ(235, rowset_meta.index_disk_size()); + EXPECT_EQ(false, rowset_meta.empty()); + EXPECT_EQ(1553765670, rowset_meta.creation_time()); } TEST_F(RowsetMetaTest, TestInit) { RowsetMeta rowset_meta; - ASSERT_TRUE(rowset_meta.init_from_json(_json_rowset_meta)); + EXPECT_TRUE(rowset_meta.init_from_json(_json_rowset_meta)); do_check(rowset_meta); RowsetMetaPB rowset_meta_pb; rowset_meta.to_rowset_pb(&rowset_meta_pb); @@ -109,30 +109,30 @@ TEST_F(RowsetMetaTest, TestInit) { TEST_F(RowsetMetaTest, TestInitWithInvalidData) { RowsetMeta rowset_meta; - ASSERT_FALSE(rowset_meta.init_from_json("invalid json meta data")); - ASSERT_FALSE(rowset_meta.init("invalid pb meta data")); + EXPECT_FALSE(rowset_meta.init_from_json("invalid json meta data")); + EXPECT_FALSE(rowset_meta.init("invalid pb meta data")); } void do_check_for_alpha(AlphaRowsetMeta alpha_rowset_meta) { RowsetId rowset_id; rowset_id.init(540081); - ASSERT_EQ(rowset_id, alpha_rowset_meta.rowset_id()); - ASSERT_EQ(15673, alpha_rowset_meta.tablet_id()); - ASSERT_EQ(4042, alpha_rowset_meta.txn_id()); - ASSERT_EQ(567997577, alpha_rowset_meta.tablet_schema_hash()); - ASSERT_EQ(ALPHA_ROWSET, alpha_rowset_meta.rowset_type()); - ASSERT_EQ(VISIBLE, alpha_rowset_meta.rowset_state()); - ASSERT_EQ(2, alpha_rowset_meta.start_version()); - ASSERT_EQ(2, alpha_rowset_meta.end_version()); - ASSERT_EQ(3929, alpha_rowset_meta.num_rows()); - ASSERT_EQ(84699, alpha_rowset_meta.total_disk_size()); - ASSERT_EQ(84464, alpha_rowset_meta.data_disk_size()); - ASSERT_EQ(235, alpha_rowset_meta.index_disk_size()); - ASSERT_EQ(false, alpha_rowset_meta.empty()); - ASSERT_EQ(1553765670, alpha_rowset_meta.creation_time()); + EXPECT_EQ(rowset_id, alpha_rowset_meta.rowset_id()); + EXPECT_EQ(15673, alpha_rowset_meta.tablet_id()); + EXPECT_EQ(4042, alpha_rowset_meta.txn_id()); + EXPECT_EQ(567997577, alpha_rowset_meta.tablet_schema_hash()); + EXPECT_EQ(ALPHA_ROWSET, alpha_rowset_meta.rowset_type()); + EXPECT_EQ(VISIBLE, alpha_rowset_meta.rowset_state()); + EXPECT_EQ(2, alpha_rowset_meta.start_version()); + EXPECT_EQ(2, alpha_rowset_meta.end_version()); + EXPECT_EQ(3929, alpha_rowset_meta.num_rows()); + EXPECT_EQ(84699, alpha_rowset_meta.total_disk_size()); + EXPECT_EQ(84464, alpha_rowset_meta.data_disk_size()); + EXPECT_EQ(235, alpha_rowset_meta.index_disk_size()); + EXPECT_EQ(false, alpha_rowset_meta.empty()); + EXPECT_EQ(1553765670, alpha_rowset_meta.creation_time()); std::vector segment_groups; alpha_rowset_meta.get_segment_groups(&segment_groups); - ASSERT_EQ(2, segment_groups.size()); + EXPECT_EQ(2, segment_groups.size()); } TEST_F(RowsetMetaTest, TestAlphaRowsetMeta) { @@ -165,14 +165,14 @@ TEST_F(RowsetMetaTest, TestAlphaRowsetMetaAdd) { rowset_meta.add_segment_group(new_segment_group); std::vector segment_groups; rowset_meta.get_segment_groups(&segment_groups); - ASSERT_EQ(3, segment_groups.size()); + EXPECT_EQ(3, segment_groups.size()); std::string meta_pb_string = ""; - ASSERT_TRUE(rowset_meta.serialize(&meta_pb_string)); + EXPECT_TRUE(rowset_meta.serialize(&meta_pb_string)); AlphaRowsetMeta rowset_meta_2; - ASSERT_TRUE(rowset_meta_2.init(meta_pb_string)); + EXPECT_TRUE(rowset_meta_2.init(meta_pb_string)); segment_groups.clear(); rowset_meta_2.get_segment_groups(&segment_groups); - ASSERT_EQ(3, segment_groups.size()); + EXPECT_EQ(3, segment_groups.size()); } TEST_F(RowsetMetaTest, TestAlphaRowsetMetaClear) { @@ -182,19 +182,14 @@ TEST_F(RowsetMetaTest, TestAlphaRowsetMetaClear) { rowset_meta.clear_segment_group(); std::vector segment_groups; rowset_meta.get_segment_groups(&segment_groups); - ASSERT_EQ(0, segment_groups.size()); + EXPECT_EQ(0, segment_groups.size()); std::string meta_pb_string = ""; - ASSERT_TRUE(rowset_meta.serialize(&meta_pb_string)); + EXPECT_TRUE(rowset_meta.serialize(&meta_pb_string)); AlphaRowsetMeta rowset_meta_2; - ASSERT_TRUE(rowset_meta_2.init(meta_pb_string)); + EXPECT_TRUE(rowset_meta_2.init(meta_pb_string)); segment_groups.clear(); rowset_meta_2.get_segment_groups(&segment_groups); - ASSERT_EQ(0, segment_groups.size()); + EXPECT_EQ(0, segment_groups.size()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp index 1bf2f3d635..d6360af4a0 100644 --- a/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp @@ -30,7 +30,7 @@ #include "olap/types.h" #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/debug_util.h" namespace doris { @@ -48,31 +48,31 @@ public: const Slice* ptr = &slices[0]; Status ret = page_builder.add(reinterpret_cast(ptr), &count); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); OwnedSlice s = page_builder.finish(); - ASSERT_EQ(slices.size(), page_builder.count()); - ASSERT_FALSE(page_builder.is_page_full()); + EXPECT_EQ(slices.size(), page_builder.count()); + EXPECT_FALSE(page_builder.is_page_full()); //check first value and last value Slice first_value; page_builder.get_first_value(&first_value); - ASSERT_EQ(slices[0], first_value); + EXPECT_EQ(slices[0], first_value); Slice last_value; page_builder.get_last_value(&last_value); - ASSERT_EQ(slices[count - 1], last_value); + EXPECT_EQ(slices[count - 1], last_value); // construct dict page OwnedSlice dict_slice; Status status = page_builder.get_dictionary_page(&dict_slice); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); PageDecoderOptions dict_decoder_options; std::unique_ptr dict_page_decoder( new BinaryPlainPageDecoder(dict_slice.slice(), dict_decoder_options)); status = dict_page_decoder->init(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // because every slice is unique - ASSERT_EQ(slices.size(), dict_page_decoder->count()); + EXPECT_EQ(slices.size(), dict_page_decoder->count()); StringRef dict_word_info[dict_page_decoder->_num_elems]; dict_page_decoder->get_dict_word_info(dict_word_info); @@ -84,8 +84,8 @@ public: page_decoder.set_dict_decoder(dict_page_decoder.get(), dict_word_info); status = page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(slices.size(), page_decoder.count()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(slices.size(), page_decoder.count()); //check values auto tracker = std::make_shared(); @@ -99,25 +99,25 @@ public: status = page_decoder.next_batch(&size, &block_view); Slice* values = reinterpret_cast(column_block.data()); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(slices.size(), size); - ASSERT_EQ("Individual", values[0].to_string()); - ASSERT_EQ("Lifetime", values[1].to_string()); - ASSERT_EQ("Objective", values[2].to_string()); - ASSERT_EQ("Value", values[3].to_string()); - ASSERT_EQ("Evolution", values[4].to_string()); - ASSERT_EQ("Nature", values[5].to_string()); - ASSERT_EQ("Captain", values[6].to_string()); - ASSERT_EQ("Xmas", values[7].to_string()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(slices.size(), size); + EXPECT_EQ("Individual", values[0].to_string()); + EXPECT_EQ("Lifetime", values[1].to_string()); + EXPECT_EQ("Objective", values[2].to_string()); + EXPECT_EQ("Value", values[3].to_string()); + EXPECT_EQ("Evolution", values[4].to_string()); + EXPECT_EQ("Nature", values[5].to_string()); + EXPECT_EQ("Captain", values[6].to_string()); + EXPECT_EQ("Xmas", values[7].to_string()); status = page_decoder.seek_to_position_in_page(5); status = page_decoder.next_batch(&size, &block_view); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // read 3 items - ASSERT_EQ(3, size); - ASSERT_EQ("Nature", values[0].to_string()); - ASSERT_EQ("Captain", values[1].to_string()); - ASSERT_EQ("Xmas", values[2].to_string()); + EXPECT_EQ(3, size); + EXPECT_EQ("Nature", values[0].to_string()); + EXPECT_EQ("Captain", values[1].to_string()); + EXPECT_EQ("Xmas", values[2].to_string()); } void test_with_large_data_size(const std::vector& contents) { @@ -136,7 +136,7 @@ public: size_t add_num = 1; const Slice* ptr = &contents[i]; Status ret = page_builder.add(reinterpret_cast(ptr), &add_num); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); if (page_builder.is_page_full()) { OwnedSlice s = page_builder.finish(); total_size += s.slice().size; @@ -156,7 +156,7 @@ public: Status status = page_builder.get_dictionary_page(&dict_slice); size_t data_size = total_size; total_size += dict_slice.slice().size; - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); LOG(INFO) << "total size:" << total_size << ", data size:" << data_size << ", dict size:" << dict_slice.slice().size << " result page size:" << results.size(); @@ -171,7 +171,7 @@ public: std::unique_ptr dict_page_decoder( new BinaryPlainPageDecoder(dict_slice.slice(), dict_decoder_options)); status = dict_page_decoder->init(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); StringRef dict_word_info[dict_page_decoder->_num_elems]; dict_page_decoder->get_dict_word_info(dict_word_info); @@ -182,7 +182,7 @@ public: status = page_decoder.init(); page_decoder.set_dict_decoder(dict_page_decoder.get(), dict_word_info); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); //check values auto tracker = std::make_shared(); @@ -199,10 +199,10 @@ public: //size_t pos = 613631; status = page_decoder.seek_to_position_in_page(pos); status = page_decoder.next_batch(&num, &block_view); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string expect = contents[page_start_ids[slice_index] + pos].to_string(); std::string actual = values[0].to_string(); - ASSERT_EQ(expect, actual) << "slice index:" << slice_index << ", pos:" << pos + EXPECT_EQ(expect, actual) << "slice index:" << slice_index << ", pos:" << pos << ", expect:" << hexdump((char*)expect.data(), expect.size()) << ", actual:" << hexdump((char*)actual.data(), actual.size()) << ", line number:" << page_start_ids[slice_index] + pos + 1; @@ -244,8 +244,3 @@ TEST_F(BinaryDictPageTest, TestEncodingRatio) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp index 781fce451f..0e0d34606d 100644 --- a/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp @@ -53,22 +53,22 @@ public: Slice* ptr = &slices[0]; Status ret = page_builder.add(reinterpret_cast(ptr), &count); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); OwnedSlice owned_slice = page_builder.finish(); //check first value and last value Slice first_value; page_builder.get_first_value(&first_value); - ASSERT_EQ(slices[0], first_value); + EXPECT_EQ(slices[0], first_value); Slice last_value; page_builder.get_last_value(&last_value); - ASSERT_EQ(slices[count - 1], last_value); + EXPECT_EQ(slices[count - 1], last_value); PageDecoderOptions decoder_options; PageDecoderType page_decoder(owned_slice.slice(), decoder_options); Status status = page_decoder.init(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); //test1 auto tracker = std::make_shared(); @@ -82,13 +82,13 @@ public: status = page_decoder.next_batch(&size, &column_block_view); Slice* values = reinterpret_cast(block.data()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Slice* value = reinterpret_cast(values); - ASSERT_EQ(3, size); - ASSERT_EQ("Hello", value[0].to_string()); - ASSERT_EQ(",", value[1].to_string()); - ASSERT_EQ("Doris", value[2].to_string()); + EXPECT_EQ(3, size); + EXPECT_EQ("Hello", value[0].to_string()); + EXPECT_EQ(",", value[1].to_string()); + EXPECT_EQ("Doris", value[2].to_string()); std::unique_ptr cvb2; ColumnVectorBatch::create(1, true, get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR), nullptr, @@ -100,10 +100,10 @@ public: page_decoder.seek_to_position_in_page(2); status = page_decoder.next_batch(&fetch_num, &column_block_view2); Slice* values2 = reinterpret_cast(block2.data()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); Slice* value2 = reinterpret_cast(values2); - ASSERT_EQ(1, fetch_num); - ASSERT_EQ("Doris", value2[0].to_string()); + EXPECT_EQ(1, fetch_num); + EXPECT_EQ("Doris", value2[0].to_string()); } }; @@ -113,8 +113,3 @@ TEST_F(BinaryPlainPageTest, TestBinaryPlainPageBuilderSeekByValueSmallPage) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp index b31c7334ca..b1ee537668 100644 --- a/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp @@ -54,24 +54,24 @@ public: Status ret = page_builder.add(reinterpret_cast(ptr), &count); OwnedSlice dict_slice = page_builder.finish(); - ASSERT_EQ(slices.size(), page_builder.count()); - ASSERT_FALSE(page_builder.is_page_full()); + EXPECT_EQ(slices.size(), page_builder.count()); + EXPECT_FALSE(page_builder.is_page_full()); //check first value and last value Slice first_value; page_builder.get_first_value(&first_value); - ASSERT_EQ(slices[0], first_value); + EXPECT_EQ(slices[0], first_value); Slice last_value; page_builder.get_last_value(&last_value); - ASSERT_EQ(slices[count - 1], last_value); + EXPECT_EQ(slices[count - 1], last_value); PageDecoderOptions dict_decoder_options; std::unique_ptr page_decoder( new BinaryPrefixPageDecoder(dict_slice.slice(), dict_decoder_options)); ret = page_decoder->init(); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); // because every slice is unique - ASSERT_EQ(slices.size(), page_decoder->count()); + EXPECT_EQ(slices.size(), page_decoder->count()); //check values auto tracker = std::make_shared(); @@ -85,10 +85,10 @@ public: ret = page_decoder->next_batch(&size, &block_view); Slice* values = reinterpret_cast(column_block.data()); - ASSERT_TRUE(ret.ok()); - ASSERT_EQ(slices.size(), size); + EXPECT_TRUE(ret.ok()); + EXPECT_EQ(slices.size(), size); for (int i = 1000; i < 1038; ++i) { - ASSERT_EQ(std::to_string(i), values[i - 1000].to_string()); + EXPECT_EQ(std::to_string(i), values[i - 1000].to_string()); } std::unique_ptr cvb2; @@ -96,35 +96,35 @@ public: ColumnBlock column_block2(cvb2.get(), &pool); ColumnBlockView block_view2(&column_block2); ret = page_decoder->seek_to_position_in_page(15); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); ret = page_decoder->next_batch(&size, &block_view2); values = reinterpret_cast(column_block2.data()); - ASSERT_TRUE(ret.ok()); - ASSERT_EQ(23, size); + EXPECT_TRUE(ret.ok()); + EXPECT_EQ(23, size); for (int i = 1015; i < 1038; ++i) { - ASSERT_EQ(std::to_string(i), values[i - 1015].to_string()); + EXPECT_EQ(std::to_string(i), values[i - 1015].to_string()); } Slice v1 = Slice("1039"); bool exact_match; ret = page_decoder->seek_at_or_after_value(&v1, &exact_match); - ASSERT_TRUE(ret.is_not_found()); + EXPECT_TRUE(ret.is_not_found()); Slice v2 = Slice("1000"); ret = page_decoder->seek_at_or_after_value(&v2, &exact_match); - ASSERT_TRUE(ret.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(ret.ok()); + EXPECT_TRUE(exact_match); Slice v3 = Slice("1037"); ret = page_decoder->seek_at_or_after_value(&v3, &exact_match); - ASSERT_TRUE(ret.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(ret.ok()); + EXPECT_TRUE(exact_match); Slice v4 = Slice("100"); ret = page_decoder->seek_at_or_after_value(&v4, &exact_match); - ASSERT_TRUE(ret.ok()); - ASSERT_TRUE(!exact_match); + EXPECT_TRUE(ret.ok()); + EXPECT_TRUE(!exact_match); } void test_encode_and_decode2() { @@ -150,13 +150,13 @@ public: std::unique_ptr page_decoder( new BinaryPrefixPageDecoder(dict_slice.slice(), dict_decoder_options)); ret = page_decoder->init(); - ASSERT_TRUE(ret.ok()); + EXPECT_TRUE(ret.ok()); Slice slice("c"); bool exact_match; ret = page_decoder->seek_at_or_after_value(&slice, &exact_match); - ASSERT_TRUE(ret.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(ret.ok()); + EXPECT_TRUE(exact_match); } }; @@ -170,8 +170,3 @@ TEST_F(BinaryPrefixPageTest, TestEncodeAndDecode2) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp b/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp index ef63aaddb3..d19270317c 100644 --- a/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp +++ b/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp @@ -28,9 +28,7 @@ #include "olap/rowset/segment_v2/bitmap_index_reader.h" #include "olap/rowset/segment_v2/bitmap_index_writer.h" #include "olap/types.h" -#include "runtime/mem_pool.h" -#include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" namespace doris { @@ -40,23 +38,17 @@ using roaring::Roaring; class BitmapIndexTest : public testing::Test { public: const std::string kTestDir = "./ut_dir/bitmap_index_test"; - BitmapIndexTest() : _tracker(new MemTracker()), _pool(_tracker.get()) {} - void SetUp() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } - ASSERT_TRUE(FileUtils::create_dir(kTestDir).ok()); + EXPECT_TRUE(FileUtils::create_dir(kTestDir).ok()); } void TearDown() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } } - -private: - std::shared_ptr _tracker; - MemPool _pool; }; template @@ -67,15 +59,15 @@ void write_index_file(std::string& filename, const void* values, size_t value_co std::unique_ptr wblock; fs::CreateBlockOptions opts(filename); std::string storage_name; - ASSERT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); + EXPECT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); std::unique_ptr writer; BitmapIndexWriter::create(type_info, &writer); writer->add_values(values, value_count); writer->add_nulls(null_count); - ASSERT_TRUE(writer->finish(wblock.get(), meta).ok()); - ASSERT_EQ(BITMAP_INDEX, meta->type()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(writer->finish(wblock.get(), meta).ok()); + EXPECT_EQ(BITMAP_INDEX, meta->type()); + EXPECT_TRUE(wblock->close().ok()); } } @@ -84,10 +76,10 @@ void get_bitmap_reader_iter(std::string& file_name, const ColumnIndexMetaPB& met BitmapIndexReader** reader, BitmapIndexIterator** iter) { *reader = new BitmapIndexReader(file_name, &meta.bitmap_index()); auto st = (*reader)->load(true, false); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = (*reader)->new_iterator(iter); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } TEST_F(BitmapIndexTest, test_invert) { @@ -105,34 +97,35 @@ TEST_F(BitmapIndexTest, test_invert) { BitmapIndexReader* reader = nullptr; BitmapIndexIterator* iter = nullptr; get_bitmap_reader_iter(file_name, meta, &reader, &iter); + EXPECT_FALSE(iter == nullptr); int value = 2; bool exact_match; Status st = iter->seek_dictionary(&value, &exact_match); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(exact_match); - ASSERT_EQ(2, iter->current_ordinal()); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(exact_match); + EXPECT_EQ(2, iter->current_ordinal()); Roaring bitmap; iter->read_bitmap(iter->current_ordinal(), &bitmap); - ASSERT_TRUE(Roaring::bitmapOf(1, 2) == bitmap); + EXPECT_TRUE(Roaring::bitmapOf(1, 2) == bitmap); int value2 = 1024 * 9; st = iter->seek_dictionary(&value2, &exact_match); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(exact_match); - ASSERT_EQ(1024 * 9, iter->current_ordinal()); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(exact_match); + EXPECT_EQ(1024 * 9, iter->current_ordinal()); iter->read_union_bitmap(iter->current_ordinal(), iter->bitmap_nums(), &bitmap); - ASSERT_EQ(1025, bitmap.cardinality()); + EXPECT_EQ(1025, bitmap.cardinality()); int value3 = 1024; iter->seek_dictionary(&value3, &exact_match); - ASSERT_EQ(1024, iter->current_ordinal()); + EXPECT_EQ(1024, iter->current_ordinal()); Roaring bitmap2; iter->read_union_bitmap(0, iter->current_ordinal(), &bitmap2); - ASSERT_EQ(1024, bitmap2.cardinality()); + EXPECT_EQ(1024, bitmap2.cardinality()); delete reader; delete iter; @@ -163,14 +156,14 @@ TEST_F(BitmapIndexTest, test_invert_2) { int value = 1026; bool exact_match; auto st = iter->seek_dictionary(&value, &exact_match); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(!exact_match); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(!exact_match); - ASSERT_EQ(1024, iter->current_ordinal()); + EXPECT_EQ(1024, iter->current_ordinal()); Roaring bitmap; iter->read_union_bitmap(0, iter->current_ordinal(), &bitmap); - ASSERT_EQ(1024, bitmap.cardinality()); + EXPECT_EQ(1024, bitmap.cardinality()); delete reader; delete iter; @@ -198,12 +191,12 @@ TEST_F(BitmapIndexTest, test_multi_pages) { int64_t value = 2019; bool exact_match; auto st = iter->seek_dictionary(&value, &exact_match); - ASSERT_TRUE(st.ok()) << "status:" << st.to_string(); - ASSERT_EQ(0, iter->current_ordinal()); + EXPECT_TRUE(st.ok()) << "status:" << st.to_string(); + EXPECT_EQ(0, iter->current_ordinal()); Roaring bitmap; iter->read_bitmap(iter->current_ordinal(), &bitmap); - ASSERT_EQ(1, bitmap.cardinality()); + EXPECT_EQ(1, bitmap.cardinality()); delete reader; delete iter; @@ -228,7 +221,7 @@ TEST_F(BitmapIndexTest, test_null) { Roaring bitmap; iter->read_null_bitmap(&bitmap); - ASSERT_EQ(30, bitmap.cardinality()); + EXPECT_EQ(30, bitmap.cardinality()); delete reader; delete iter; @@ -238,9 +231,3 @@ TEST_F(BitmapIndexTest, test_null) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp b/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp index e43f58c0ac..415a6bf097 100644 --- a/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp @@ -48,7 +48,7 @@ public: size_t n = 1; decoder->_copy_next_values(n, column_block_view.data()); - ASSERT_EQ(1, n); + EXPECT_EQ(1, n); *ret = *reinterpret_cast::CppType*>(block.cell_ptr(0)); } @@ -65,16 +65,16 @@ public: //check first value and last value CppType first_value; page_builder.get_first_value(&first_value); - ASSERT_EQ(src[0], first_value); + EXPECT_EQ(src[0], first_value); CppType last_value; page_builder.get_last_value(&last_value); - ASSERT_EQ(src[size - 1], last_value); + EXPECT_EQ(src[size - 1], last_value); segment_v2::PageDecoderOptions decoder_options; PageDecoderType page_decoder(s.slice(), decoder_options); Status status = page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, page_decoder.current_index()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, page_decoder.current_index()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -85,7 +85,7 @@ public: ColumnBlockView column_block_view(&block); status = page_decoder.next_batch(&size, &column_block_view); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); CppType* values = reinterpret_cast(block.data()); CppType* decoded = (CppType*)values; @@ -123,33 +123,33 @@ public: segment_v2::PageDecoderOptions decoder_options; PageDecoderType page_decoder(s.slice(), decoder_options); Status status = page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, page_decoder.current_index()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, page_decoder.current_index()); size_t index = random() % size; CppType seek_value = src[index]; bool exact_match; status = page_decoder.seek_at_or_after_value(&seek_value, &exact_match); EXPECT_EQ(index, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); CppType last_value = src[size - 1]; status = page_decoder.seek_at_or_after_value(&last_value, &exact_match); EXPECT_EQ(size - 1, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); CppType first_value = src[0]; status = page_decoder.seek_at_or_after_value(&first_value, &exact_match); EXPECT_EQ(0, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); status = page_decoder.seek_at_or_after_value(small_than_smallest, &exact_match); EXPECT_EQ(0, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(exact_match); status = page_decoder.seek_at_or_after_value(bigger_than_biggest, &exact_match); EXPECT_EQ(status.code(), TStatusCode::NOT_FOUND); @@ -349,8 +349,3 @@ TEST_F(BitShufflePageTest, TestBitShuffleDecimal12BlockEncoderSeekValue) { } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/block_bloom_filter_test.cpp b/be/test/olap/rowset/segment_v2/block_bloom_filter_test.cpp index fffcf876e6..9c3f15dcd6 100644 --- a/be/test/olap/rowset/segment_v2/block_bloom_filter_test.cpp +++ b/be/test/olap/rowset/segment_v2/block_bloom_filter_test.cpp @@ -39,14 +39,14 @@ TEST_F(BlockBloomFilterTest, Normal) { std::unique_ptr bf; // now CLASSIC_BLOOM_FILTER is not supported auto st = BloomFilter::create(CLASSIC_BLOOM_FILTER, &bf); - ASSERT_FALSE(st.ok()); - ASSERT_EQ(nullptr, bf); + EXPECT_FALSE(st.ok()); + EXPECT_EQ(nullptr, bf); st = BloomFilter::create(BLOCK_BLOOM_FILTER, &bf); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, bf); + EXPECT_TRUE(st.ok()); + EXPECT_NE(nullptr, bf); st = bf->init(_expected_num, _fpp, HASH_MURMUR3_X64_64); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(bf->size() > 0); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(bf->size() > 0); int num = 1000; uint32_t values[1000]; for (int i = 0; i < num; ++i) { @@ -58,30 +58,30 @@ TEST_F(BlockBloomFilterTest, Normal) { // add nullptr bf->add_bytes(nullptr, 1); for (int i = 0; i < num; ++i) { - ASSERT_TRUE(bf->test_bytes((char*)&values[i], sizeof(uint32_t))); + EXPECT_TRUE(bf->test_bytes((char*)&values[i], sizeof(uint32_t))); } // test nullptr - ASSERT_TRUE(bf->test_bytes(nullptr, 1)); + EXPECT_TRUE(bf->test_bytes(nullptr, 1)); // test read std::unique_ptr bf2; st = BloomFilter::create(BLOCK_BLOOM_FILTER, &bf2); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, bf2); + EXPECT_TRUE(st.ok()); + EXPECT_NE(nullptr, bf2); st = bf2->init(bf->data(), bf->size(), HASH_MURMUR3_X64_64); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(bf2->size() > 0); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(bf2->size() > 0); for (int i = 0; i < num; ++i) { - ASSERT_TRUE(bf2->test_bytes((char*)&values[i], sizeof(uint32_t))); + EXPECT_TRUE(bf2->test_bytes((char*)&values[i], sizeof(uint32_t))); } // test nullptr - ASSERT_TRUE(bf2->test_bytes(nullptr, 1)); + EXPECT_TRUE(bf2->test_bytes(nullptr, 1)); bf->reset(); char* data = bf->data(); // data is reset to 0 for (int i = 0; i < bf->size(); ++i) { - ASSERT_EQ(*data, 0); + EXPECT_EQ(*data, 0); data++; } } @@ -91,19 +91,19 @@ TEST_F(BlockBloomFilterTest, SP) { // test write std::unique_ptr bf; auto st = BloomFilter::create(BLOCK_BLOOM_FILTER, &bf); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, bf); + EXPECT_TRUE(st.ok()); + EXPECT_NE(nullptr, bf); st = bf->init(_expected_num, _fpp, HASH_MURMUR3_X64_64); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(bf->size() > 0); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(bf->size() > 0); std::unique_ptr bf2; st = BloomFilter::create(BLOCK_BLOOM_FILTER, &bf2); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, bf2); + EXPECT_TRUE(st.ok()); + EXPECT_NE(nullptr, bf2); st = bf2->init(_expected_num, _fpp, HASH_MURMUR3_X64_64); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(bf2->size() > 0); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(bf2->size() > 0); int num = _expected_num; int32_t values[num]; @@ -120,8 +120,8 @@ TEST_F(BlockBloomFilterTest, SP) { // true test for (int i = 0; i < num; ++i) { - ASSERT_TRUE(bf->test_bytes((char*)&values[i], 4)); - ASSERT_TRUE(bf2->test_bytes((char*)&values2[i], 4)); + EXPECT_TRUE(bf->test_bytes((char*)&values[i], 4)); + EXPECT_TRUE(bf2->test_bytes((char*)&values2[i], 4)); } // false test @@ -140,8 +140,8 @@ TEST_F(BlockBloomFilterTest, SP) { false_count2 += bf2->test_bytes((char*)&to_check2, 4); } } - ASSERT_LE((double)false_count1 / (num * 9), _fpp); - ASSERT_LE((double)false_count2 / (num * 9), _fpp); + EXPECT_LE((double)false_count1 / (num * 9), _fpp); + EXPECT_LE((double)false_count2 / (num * 9), _fpp); } // Test for slice @@ -149,11 +149,11 @@ TEST_F(BlockBloomFilterTest, slice) { // test write std::unique_ptr bf; auto st = BloomFilter::create(BLOCK_BLOOM_FILTER, &bf); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, bf); + EXPECT_TRUE(st.ok()); + EXPECT_NE(nullptr, bf); st = bf->init(_expected_num, _fpp, HASH_MURMUR3_X64_64); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(bf->size() > 0); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(bf->size() > 0); int num = 1024; std::string values[1024]; @@ -171,13 +171,8 @@ TEST_F(BlockBloomFilterTest, slice) { std::string value_not_exist = "char_value_not_exist"; Slice s = Slice(value_not_exist); - ASSERT_FALSE(bf->test_bytes(s.data, s.size)); + EXPECT_FALSE(bf->test_bytes(s.data, s.size)); } } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp b/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp index 6f18a97929..9815fb79bf 100644 --- a/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp +++ b/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp @@ -39,12 +39,12 @@ public: virtual void SetUp() { if (FileUtils::is_dir(dname)) { std::set files; - ASSERT_TRUE(FileUtils::list_dirs_files(dname, nullptr, &files, Env::Default()).ok()); + EXPECT_TRUE(FileUtils::list_dirs_files(dname, nullptr, &files, Env::Default()).ok()); for (const auto& file : files) { Status s = Env::Default()->delete_file(dname + "/" + file); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); } - ASSERT_TRUE(Env::Default()->delete_dir(dname).ok()); + EXPECT_TRUE(Env::Default()->delete_dir(dname).ok()); } } }; @@ -62,7 +62,7 @@ void write_bloom_filter_index_file(const std::string& file_name, const void* val fs::CreateBlockOptions opts(fname); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); std::unique_ptr bloom_filter_index_writer; BloomFilterOptions bf_options; @@ -76,14 +76,14 @@ void write_bloom_filter_index_file(const std::string& file_name, const void* val bloom_filter_index_writer->add_nulls(null_count); } st = bloom_filter_index_writer->flush(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); i += 1024; } st = bloom_filter_index_writer->finish(wblock.get(), index_meta); - ASSERT_TRUE(st.ok()) << "writer finish status:" << st.to_string(); - ASSERT_TRUE(wblock->close().ok()); - ASSERT_EQ(BLOOM_FILTER_INDEX, index_meta->type()); - ASSERT_EQ(bf_options.strategy, index_meta->bloom_filter_index().hash_strategy()); + EXPECT_TRUE(st.ok()) << "writer finish status:" << st.to_string(); + EXPECT_TRUE(wblock->close().ok()); + EXPECT_EQ(BLOOM_FILTER_INDEX, index_meta->type()); + EXPECT_EQ(bf_options.strategy, index_meta->bloom_filter_index().hash_strategy()); } } @@ -95,10 +95,10 @@ void get_bloom_filter_reader_iter(const std::string& file_name, const ColumnInde *reader = new BloomFilterIndexReader(fname, &meta.bloom_filter_index()); auto st = (*reader)->load(true, false); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = (*reader)->new_iterator(iter); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } template @@ -118,41 +118,41 @@ void test_bloom_filter_index_reader_writer_template( // page 0 std::unique_ptr bf; auto st = iter->read_bloom_filter(0, &bf); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int i = 0; i < 1024; ++i) { if (is_slice_type) { Slice* value = (Slice*)(val + i); - ASSERT_TRUE(bf->test_bytes(value->data, value->size)); + EXPECT_TRUE(bf->test_bytes(value->data, value->size)); } else { - ASSERT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); + EXPECT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); } } // page 1 st = iter->read_bloom_filter(1, &bf); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int i = 1024; i < 2048; ++i) { if (is_slice_type) { Slice* value = (Slice*)(val + i); - ASSERT_TRUE(bf->test_bytes(value->data, value->size)); + EXPECT_TRUE(bf->test_bytes(value->data, value->size)); } else { - ASSERT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); + EXPECT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); } } // page 2 st = iter->read_bloom_filter(2, &bf); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int i = 2048; i < 3071; ++i) { if (is_slice_type) { Slice* value = (Slice*)(val + i); - ASSERT_TRUE(bf->test_bytes(value->data, value->size)); + EXPECT_TRUE(bf->test_bytes(value->data, value->size)); } else { - ASSERT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); + EXPECT_TRUE(bf->test_bytes((char*)&val[i], sizeof(CppType))); } } // test nullptr - ASSERT_TRUE(bf->test_bytes(nullptr, 1)); + EXPECT_TRUE(bf->test_bytes(nullptr, 1)); delete reader; } @@ -290,9 +290,3 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_decimal) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/bloom_filter_page_test.cpp b/be/test/olap/rowset/segment_v2/bloom_filter_page_test.cpp index 47fc036521..997eb84f19 100644 --- a/be/test/olap/rowset/segment_v2/bloom_filter_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/bloom_filter_page_test.cpp @@ -47,22 +47,22 @@ public: PageBuilderOptions builder_options; builder_options.data_page_size = 256 * 1024; PageBuilderType bf_page_builder(builder_options); - ASSERT_FALSE(bf_page_builder.is_page_full()); + EXPECT_FALSE(bf_page_builder.is_page_full()); bf_page_builder.add(reinterpret_cast(src), &size); if (has_null) { size_t num = 1; bf_page_builder.add(nullptr, &num); } OwnedSlice s = bf_page_builder.finish(); - ASSERT_EQ(size + has_null, bf_page_builder.count()); + EXPECT_EQ(size + has_null, bf_page_builder.count()); BloomFilterPageDecoder bf_page_decoder(s.slice()); auto status = bf_page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, bf_page_decoder.current_index()); - ASSERT_EQ(1, bf_page_decoder.count()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, bf_page_decoder.current_index()); + EXPECT_EQ(1, bf_page_decoder.count()); status = bf_page_decoder.seek_to_position_in_page(0); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -72,21 +72,21 @@ public: ColumnBlockView column_block_view(&block); size_t size_to_fetch = 1; status = bf_page_decoder.next_batch(&size_to_fetch, &column_block_view); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(1, size_to_fetch); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(1, size_to_fetch); std::unique_ptr bf; BloomFilter::create(BLOCK_BLOOM_FILTER, &bf); - ASSERT_NE(nullptr, bf); + EXPECT_NE(nullptr, bf); auto ret = bf->init(values->data, values->size, HASH_MURMUR3_X64_64); - ASSERT_TRUE(ret); - ASSERT_EQ(has_null, bf->has_null()); + EXPECT_TRUE(ret); + EXPECT_EQ(has_null, bf->has_null()); for (size_t i = 0; i < size; ++i) { if (is_slice_type) { Slice* value = (Slice*)(src + i); - ASSERT_TRUE(bf->test_bytes(value->data, value->size)); + EXPECT_TRUE(bf->test_bytes(value->data, value->size)); } else { - ASSERT_TRUE(bf->test_bytes((char*)(src + i), sizeof(CppType))); + EXPECT_TRUE(bf->test_bytes((char*)(src + i), sizeof(CppType))); } } } @@ -179,8 +179,3 @@ TEST_F(BloomFilterPageTest, TestCharFieldBloomFilterPage) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp index 23576751fc..a07efd3536 100644 --- a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp +++ b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp @@ -31,7 +31,7 @@ #include "olap/types.h" #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" #include "vec/core/types.h" #include "vec/data_types/data_type_nothing.h" @@ -51,15 +51,16 @@ public: protected: void SetUp() override { + config::disable_storage_page_cache = true; if (FileUtils::check_exist(TEST_DIR)) { - ASSERT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); } - ASSERT_TRUE(FileUtils::create_dir(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::create_dir(TEST_DIR).ok()); } void TearDown() override { if (FileUtils::check_exist(TEST_DIR)) { - ASSERT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); } } @@ -83,7 +84,7 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, fs::CreateBlockOptions opts(fname); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock); - ASSERT_TRUE(st.ok()) << st.get_error_msg(); + EXPECT_TRUE(st.ok()) << st.get_error_msg(); ColumnWriterOptions writer_opts; writer_opts.meta = &meta; @@ -109,20 +110,20 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, std::unique_ptr writer; ColumnWriter::create(writer_opts, &column, wblock.get(), &writer); st = writer->init(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); for (int i = 0; i < num_rows; ++i) { st = writer->append(BitmapTest(src_is_null, i), src + i); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } - ASSERT_TRUE(writer->finish().ok()); - ASSERT_TRUE(writer->write_data().ok()); - ASSERT_TRUE(writer->write_ordinal_index().ok()); - ASSERT_TRUE(writer->write_zone_map().ok()); + EXPECT_TRUE(writer->finish().ok()); + EXPECT_TRUE(writer->write_data().ok()); + EXPECT_TRUE(writer->write_ordinal_index().ok()); + EXPECT_TRUE(writer->write_zone_map().ok()); // close the file - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(wblock->close().ok()); } auto type_info = get_scalar_type_info(type); // read and check @@ -134,25 +135,25 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, path_desc.filepath = fname; std::unique_ptr reader; auto st = ColumnReader::create(reader_opts, meta, num_rows, path_desc, &reader); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIterator* iter = nullptr; st = reader->new_iterator(&iter); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::unique_ptr rblock; fs::BlockManager* block_manager = fs::fs_util::block_manager(path_desc); block_manager->open_block(path_desc, &rblock); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIteratorOptions iter_opts; OlapReaderStatistics stats; iter_opts.stats = &stats; iter_opts.rblock = rblock.get(); st = iter->init(iter_opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = iter->seek_to_first(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -166,17 +167,17 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, size_t rows_read = 1024; ColumnBlockView dst(&col); st = iter->next_batch(&rows_read, &dst); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { - ASSERT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); + EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); if (!col.is_null(j)) { if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_CHAR) { Slice* src_slice = (Slice*)src_data; - ASSERT_EQ(src_slice[idx].to_string(), + EXPECT_EQ(src_slice[idx].to_string(), reinterpret_cast(col.cell_ptr(j))->to_string()) << "j:" << j; } else { - ASSERT_EQ(src[idx], *reinterpret_cast(col.cell_ptr(j))); + EXPECT_EQ(src[idx], *reinterpret_cast(col.cell_ptr(j))); } } idx++; @@ -194,22 +195,22 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, path_desc.filepath = fname; std::unique_ptr reader; auto st = ColumnReader::create(reader_opts, meta, num_rows, path_desc, &reader); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIterator* iter = nullptr; st = reader->new_iterator(&iter); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::unique_ptr rblock; fs::BlockManager* block_manager = fs::fs_util::block_manager(path_desc); block_manager->open_block(path_desc, &rblock); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIteratorOptions iter_opts; OlapReaderStatistics stats; iter_opts.stats = &stats; iter_opts.rblock = rblock.get(); st = iter->init(iter_opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -220,23 +221,23 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows, for (int rowid = 0; rowid < num_rows; rowid += 4025) { st = iter->seek_to_ordinal(rowid); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); int idx = rowid; size_t rows_read = 1024; ColumnBlockView dst(&col); st = iter->next_batch(&rows_read, &dst); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { - ASSERT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); + EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); if (!col.is_null(j)) { if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_CHAR) { Slice* src_slice = (Slice*)src_data; - ASSERT_EQ(src_slice[idx].to_string(), + EXPECT_EQ(src_slice[idx].to_string(), reinterpret_cast(col.cell_ptr(j))->to_string()); } else { - ASSERT_EQ(src[idx], *reinterpret_cast(col.cell_ptr(j))); + EXPECT_EQ(src[idx], *reinterpret_cast(col.cell_ptr(j))); } } idx++; @@ -268,7 +269,7 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i fs::CreateBlockOptions opts(fname); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock); - ASSERT_TRUE(st.ok()) << st.get_error_msg(); + EXPECT_TRUE(st.ok()) << st.get_error_msg(); ColumnWriterOptions writer_opts; writer_opts.meta = &meta; @@ -294,23 +295,23 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i std::unique_ptr writer; ColumnWriter::create(writer_opts, &list_column, wblock.get(), &writer); st = writer->init(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); for (int i = 0; i < num_rows; ++i) { st = writer->append(BitmapTest(src_is_null, i), src + i); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } st = writer->finish(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = writer->write_data(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = writer->write_ordinal_index(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // close the file - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(wblock->close().ok()); } auto type_info = get_type_info(&meta); @@ -321,25 +322,25 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i path_desc.filepath = fname; std::unique_ptr reader; auto st = ColumnReader::create(reader_opts, meta, num_rows, path_desc, &reader); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIterator* iter = nullptr; st = reader->new_iterator(&iter); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::unique_ptr rblock; fs::BlockManager* block_manager = fs::fs_util::block_manager(path_desc); st = block_manager->open_block(path_desc, &rblock); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); ColumnIteratorOptions iter_opts; OlapReaderStatistics stats; iter_opts.stats = &stats; iter_opts.rblock = rblock.get(); st = iter->init(iter_opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // sequence read { st = iter->seek_to_first(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); MemTracker tracker; MemPool pool(&tracker); @@ -353,11 +354,11 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i size_t rows_read = 1024; ColumnBlockView dst(&col); st = iter->next_batch(&rows_read, &dst); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { - ASSERT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); + EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); if (!col.is_null(j)) { - ASSERT_TRUE(type_info->equal(&src[idx], col.cell_ptr(j))); + EXPECT_TRUE(type_info->equal(&src[idx], col.cell_ptr(j))); } ++idx; } @@ -377,18 +378,18 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i for (int rowid = 0; rowid < num_rows; rowid += 4025) { st = iter->seek_to_ordinal(rowid); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); int idx = rowid; size_t rows_read = 1024; ColumnBlockView dst(&col); st = iter->next_batch(&rows_read, &dst); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { - ASSERT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); + EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j)); if (!col.is_null(j)) { - ASSERT_TRUE(type_info->equal(&src[idx], col.cell_ptr(j))); + EXPECT_TRUE(type_info->equal(&src[idx], col.cell_ptr(j))); } ++idx; } @@ -470,11 +471,11 @@ void test_read_default_value(string value, void* result) { type_info, tablet_column.length()); ColumnIteratorOptions iter_opts; auto st = iter.init(iter_opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // sequence read { st = iter.seek_to_first(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -488,19 +489,19 @@ void test_read_default_value(string value, void* result) { ColumnBlockView dst(&col); bool has_null; st = iter.next_batch(&rows_read, &dst, &has_null); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { if (type == OLAP_FIELD_TYPE_CHAR) { - ASSERT_EQ(*(string*)result, + EXPECT_EQ(*(string*)result, reinterpret_cast(col.cell_ptr(j))->to_string()) << "j:" << j; } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL || type == OLAP_FIELD_TYPE_OBJECT) { - ASSERT_EQ(value, reinterpret_cast(col.cell_ptr(j))->to_string()) + EXPECT_EQ(value, reinterpret_cast(col.cell_ptr(j))->to_string()) << "j:" << j; } else { ; - ASSERT_EQ(*(Type*)result, *(reinterpret_cast(col.cell_ptr(j)))); + EXPECT_EQ(*(Type*)result, *(reinterpret_cast(col.cell_ptr(j)))); } idx++; } @@ -516,25 +517,25 @@ void test_read_default_value(string value, void* result) { for (int rowid = 0; rowid < 2048; rowid += 128) { st = iter.seek_to_ordinal(rowid); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); int idx = rowid; size_t rows_read = 1024; ColumnBlockView dst(&col); bool has_null; st = iter.next_batch(&rows_read, &dst, &has_null); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { if (type == OLAP_FIELD_TYPE_CHAR) { - ASSERT_EQ(*(string*)result, + EXPECT_EQ(*(string*)result, reinterpret_cast(col.cell_ptr(j))->to_string()) << "j:" << j; } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL || type == OLAP_FIELD_TYPE_OBJECT) { - ASSERT_EQ(value, + EXPECT_EQ(value, reinterpret_cast(col.cell_ptr(j))->to_string()); } else { - ASSERT_EQ(*(Type*)result, + EXPECT_EQ(*(Type*)result, *(reinterpret_cast(col.cell_ptr(j)))); } idx++; @@ -581,12 +582,12 @@ void test_v_read_default_value(string value, void* result) { type_info, tablet_column.length()); ColumnIteratorOptions iter_opts; auto st = iter.init(iter_opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // sequence read { st = iter.seek_to_first(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); vectorized::MutableColumnPtr mcp = create_vectorized_column_ptr(type); @@ -594,35 +595,35 @@ void test_v_read_default_value(string value, void* result) { bool has_null; st = iter.next_batch(&rows_read, mcp, &has_null); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int j = 0; j < rows_read; ++j) { if (type == OLAP_FIELD_TYPE_CHAR) { } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL || type == OLAP_FIELD_TYPE_OBJECT) { } else if (type == OLAP_FIELD_TYPE_DATE || type == OLAP_FIELD_TYPE_DATETIME) { StringRef sr = mcp->get_data_at(j); - ASSERT_EQ(sr.size, sizeof(vectorized::Int64)); + EXPECT_EQ(sr.size, sizeof(vectorized::Int64)); auto x = unaligned_load(sr.data); auto value = binary_cast(x); char buf[64] = {}; value.to_string(buf); int ret = strcmp(buf, (char*)result); - ASSERT_EQ(ret, 0); + EXPECT_EQ(ret, 0); } else if (type == OLAP_FIELD_TYPE_DECIMAL) { StringRef sr = mcp->get_data_at(j); - ASSERT_EQ(sr.size, sizeof(vectorized::Int128)); + EXPECT_EQ(sr.size, sizeof(vectorized::Int128)); DecimalV2Value v1(unaligned_load(sr.data)); decimal12_t* v2 = (decimal12_t*)result; - ASSERT_EQ(v2->integer, v1.int_value()); - ASSERT_EQ(v2->fraction, v1.frac_value()); + EXPECT_EQ(v2->integer, v1.int_value()); + EXPECT_EQ(v2->fraction, v1.frac_value()); } else { StringRef sr = mcp->get_data_at(j); - ASSERT_EQ(sr.size, sizeof(Type)); + EXPECT_EQ(sr.size, sizeof(Type)); int ret = memcmp(sr.data, result, sr.size); - ASSERT_EQ(ret, 0); + EXPECT_EQ(ret, 0); } } } @@ -831,7 +832,7 @@ TEST_F(ColumnReaderWriterTest, test_mixed_empty_arrays) { std::unique_ptr array_is_null(new uint8_t[BitmapSize(num_array)]()); std::unique_ptr collection_values(new CollectionValue[num_array]); int data[] = {1, 2, 3}; - for (int i = 0; i < num_array; ++ i) { + for (int i = 0; i < num_array; ++i) { if (i % 2 == 1) { new (&collection_values[i]) CollectionValue(0); } else { @@ -844,9 +845,3 @@ TEST_F(ColumnReaderWriterTest, test_mixed_empty_arrays) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/encoding_info_test.cpp b/be/test/olap/rowset/segment_v2/encoding_info_test.cpp index 0a6ee9dcf8..7396967c56 100644 --- a/be/test/olap/rowset/segment_v2/encoding_info_test.cpp +++ b/be/test/olap/rowset/segment_v2/encoding_info_test.cpp @@ -38,21 +38,16 @@ TEST_F(EncodingInfoTest, normal) { const auto* type_info = get_scalar_type_info(); const EncodingInfo* encoding_info = nullptr; auto status = EncodingInfo::get(type_info, PLAIN_ENCODING, &encoding_info); - ASSERT_TRUE(status.ok()); - ASSERT_NE(nullptr, encoding_info); + EXPECT_TRUE(status.ok()); + EXPECT_NE(nullptr, encoding_info); } TEST_F(EncodingInfoTest, no_encoding) { const auto* type_info = get_scalar_type_info(); const EncodingInfo* encoding_info = nullptr; auto status = EncodingInfo::get(type_info, DICT_ENCODING, &encoding_info); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp b/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp index f25ff55df9..725c7093d4 100644 --- a/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp @@ -45,7 +45,7 @@ public: size_t n = 1; decoder->next_batch(&n, &column_block_view); - ASSERT_EQ(1, n); + EXPECT_EQ(1, n); *ret = *reinterpret_cast::CppType*>(block.cell_ptr(0)); } @@ -57,16 +57,16 @@ public: PageBuilderType for_page_builder(builder_options); for_page_builder.add(reinterpret_cast(src), &size); OwnedSlice s = for_page_builder.finish(); - ASSERT_EQ(size, for_page_builder.count()); + EXPECT_EQ(size, for_page_builder.count()); LOG(INFO) << "FrameOfReference Encoded size for " << size << " values: " << s.slice().size << ", original size:" << size * sizeof(CppType); PageDecoderOptions decoder_options; PageDecoderType for_page_decoder(s.slice(), decoder_options); Status status = for_page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, for_page_decoder.current_index()); - ASSERT_EQ(size, for_page_decoder.count()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, for_page_decoder.current_index()); + EXPECT_EQ(size, for_page_decoder.count()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -76,8 +76,8 @@ public: ColumnBlockView column_block_view(&block); size_t size_to_fetch = size; status = for_page_decoder.next_batch(&size_to_fetch, &column_block_view); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(size, size_to_fetch); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(size, size_to_fetch); CppType* values = reinterpret_cast(column_block_view.data()); @@ -226,7 +226,7 @@ TEST_F(FrameOfReferencePageTest, TestInt32SequenceBlockEncoderSize) { OwnedSlice s = page_builder.finish(); // body: 4 bytes min value + 128 * 1 /8 packing value = 20 // footer: (1 + 1) * 1 + 1 + 4 = 7 - ASSERT_EQ(27, s.slice().size); + EXPECT_EQ(27, s.slice().size); } TEST_F(FrameOfReferencePageTest, TestFirstLastValue) { @@ -242,10 +242,10 @@ TEST_F(FrameOfReferencePageTest, TestFirstLastValue) { OwnedSlice s = page_builder.finish(); int32_t first_value = -1; page_builder.get_first_value(&first_value); - ASSERT_EQ(0, first_value); + EXPECT_EQ(0, first_value); int32_t last_value = 0; page_builder.get_last_value(&last_value); - ASSERT_EQ(127, last_value); + EXPECT_EQ(127, last_value); } TEST_F(FrameOfReferencePageTest, TestInt32NormalBlockEncoderSize) { @@ -261,38 +261,33 @@ TEST_F(FrameOfReferencePageTest, TestInt32NormalBlockEncoderSize) { OwnedSlice s = page_builder.finish(); // body: 4 bytes min value + 128 * 7 /8 packing value = 116 // footer: (1 + 1) * 1 + 1 + 4 = 7 - ASSERT_EQ(123, s.slice().size); + EXPECT_EQ(123, s.slice().size); } TEST_F(FrameOfReferencePageTest, TestFindBitsOfInt) { int8_t bits_3 = 0x06; - ASSERT_EQ(3, bits(bits_3)); + EXPECT_EQ(3, bits(bits_3)); uint8_t bits_4 = 0x0F; - ASSERT_EQ(4, bits(bits_4)); + EXPECT_EQ(4, bits(bits_4)); int32_t bits_17 = 0x000100FF; - ASSERT_EQ(17, bits(bits_17)); + EXPECT_EQ(17, bits(bits_17)); int64_t bits_33 = 0x00000001FFFFFFFF; - ASSERT_EQ(33, bits(bits_33)); + EXPECT_EQ(33, bits(bits_33)); int128_t bits_0 = 0; - ASSERT_EQ(0, bits(bits_0)); + EXPECT_EQ(0, bits(bits_0)); int128_t bits_127 = numeric_limits::max(); - ASSERT_EQ(127, bits(bits_127)); + EXPECT_EQ(127, bits(bits_127)); uint128_t bits_128 = numeric_limits::max(); - ASSERT_EQ(128, bits(bits_128)); + EXPECT_EQ(128, bits(bits_128)); int128_t bits_65 = ((int128_t)1) << 64; - ASSERT_EQ(65, bits(bits_65)); + EXPECT_EQ(65, bits(bits_65)); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/ordinal_page_index_test.cpp b/be/test/olap/rowset/segment_v2/ordinal_page_index_test.cpp index 55bb5135a3..85b3ea5458 100644 --- a/be/test/olap/rowset/segment_v2/ordinal_page_index_test.cpp +++ b/be/test/olap/rowset/segment_v2/ordinal_page_index_test.cpp @@ -38,13 +38,13 @@ public: void SetUp() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } - ASSERT_TRUE(FileUtils::create_dir(kTestDir).ok()); + EXPECT_TRUE(FileUtils::create_dir(kTestDir).ok()); } void TearDown() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } } }; @@ -64,51 +64,51 @@ TEST_F(OrdinalPageIndexTest, normal) { std::unique_ptr wblock; fs::CreateBlockOptions opts(filename); std::string storage_name; - ASSERT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); + EXPECT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); - ASSERT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); - ASSERT_EQ(ORDINAL_INDEX, index_meta.type()); - ASSERT_FALSE(index_meta.ordinal_index().root_page().is_root_data_page()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); + EXPECT_EQ(ORDINAL_INDEX, index_meta.type()); + EXPECT_FALSE(index_meta.ordinal_index().root_page().is_root_data_page()); + EXPECT_TRUE(wblock->close().ok()); LOG(INFO) << "index page size=" << index_meta.ordinal_index().root_page().root_page().size(); } FilePathDesc path_desc(filename); OrdinalIndexReader index(path_desc, &index_meta.ordinal_index(), 16 * 1024 * 4096 + 1); - ASSERT_TRUE(index.load(true, false).ok()); - ASSERT_EQ(16 * 1024, index.num_data_pages()); - ASSERT_EQ(1, index.get_first_ordinal(0)); - ASSERT_EQ(4096, index.get_last_ordinal(0)); - ASSERT_EQ((16 * 1024 - 1) * 4096 + 1, index.get_first_ordinal(16 * 1024 - 1)); - ASSERT_EQ(16 * 1024 * 4096, index.get_last_ordinal(16 * 1024 - 1)); + EXPECT_TRUE(index.load(true, false).ok()); + EXPECT_EQ(16 * 1024, index.num_data_pages()); + EXPECT_EQ(1, index.get_first_ordinal(0)); + EXPECT_EQ(4096, index.get_last_ordinal(0)); + EXPECT_EQ((16 * 1024 - 1) * 4096 + 1, index.get_first_ordinal(16 * 1024 - 1)); + EXPECT_EQ(16 * 1024 * 4096, index.get_last_ordinal(16 * 1024 - 1)); { auto iter = index.seek_at_or_before(1); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(1, iter.first_ordinal()); - ASSERT_EQ(PagePointer(0, 16 * 1024), iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(1, iter.first_ordinal()); + EXPECT_EQ(PagePointer(0, 16 * 1024), iter.page()); } { auto iter = index.seek_at_or_before(4095); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(1, iter.first_ordinal()); - ASSERT_EQ(PagePointer(0, 16 * 1024), iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(1, iter.first_ordinal()); + EXPECT_EQ(PagePointer(0, 16 * 1024), iter.page()); } { auto iter = index.seek_at_or_before(4098); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(4097, iter.first_ordinal()); - ASSERT_EQ(PagePointer(1 * 16 * 1024, 16 * 1024), iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(4097, iter.first_ordinal()); + EXPECT_EQ(PagePointer(1 * 16 * 1024, 16 * 1024), iter.page()); iter.next(); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(4097 + 4096, iter.first_ordinal()); - ASSERT_EQ(PagePointer(2 * 16 * 1024, 16 * 1024), iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(4097 + 4096, iter.first_ordinal()); + EXPECT_EQ(PagePointer(2 * 16 * 1024, 16 * 1024), iter.page()); } { auto iter = index.seek_at_or_before(0); - ASSERT_FALSE(iter.valid()); + EXPECT_FALSE(iter.valid()); } } @@ -122,46 +122,40 @@ TEST_F(OrdinalPageIndexTest, one_data_page) { ColumnIndexMetaPB index_meta; { // in this case, no index page is written, thus file could be null - ASSERT_TRUE(builder.finish(nullptr, &index_meta).ok()); - ASSERT_EQ(ORDINAL_INDEX, index_meta.type()); - ASSERT_TRUE(index_meta.ordinal_index().root_page().is_root_data_page()); + EXPECT_TRUE(builder.finish(nullptr, &index_meta).ok()); + EXPECT_EQ(ORDINAL_INDEX, index_meta.type()); + EXPECT_TRUE(index_meta.ordinal_index().root_page().is_root_data_page()); PagePointer root_page_pointer(index_meta.ordinal_index().root_page().root_page()); - ASSERT_EQ(data_page_pointer, root_page_pointer); + EXPECT_EQ(data_page_pointer, root_page_pointer); } FilePathDesc path_desc; OrdinalIndexReader index(path_desc, &index_meta.ordinal_index(), num_values); - ASSERT_TRUE(index.load(true, false).ok()); - ASSERT_EQ(1, index.num_data_pages()); - ASSERT_EQ(0, index.get_first_ordinal(0)); - ASSERT_EQ(num_values - 1, index.get_last_ordinal(0)); + EXPECT_TRUE(index.load(true, false).ok()); + EXPECT_EQ(1, index.num_data_pages()); + EXPECT_EQ(0, index.get_first_ordinal(0)); + EXPECT_EQ(num_values - 1, index.get_last_ordinal(0)); { auto iter = index.seek_at_or_before(0); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(0, iter.first_ordinal()); - ASSERT_EQ(num_values - 1, iter.last_ordinal()); - ASSERT_EQ(data_page_pointer, iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(0, iter.first_ordinal()); + EXPECT_EQ(num_values - 1, iter.last_ordinal()); + EXPECT_EQ(data_page_pointer, iter.page()); } { auto iter = index.seek_at_or_before(num_values - 1); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(0, iter.first_ordinal()); - ASSERT_EQ(data_page_pointer, iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(0, iter.first_ordinal()); + EXPECT_EQ(data_page_pointer, iter.page()); } { auto iter = index.seek_at_or_before(num_values); - ASSERT_TRUE(iter.valid()); - ASSERT_EQ(0, iter.first_ordinal()); - ASSERT_EQ(data_page_pointer, iter.page()); + EXPECT_TRUE(iter.valid()); + EXPECT_EQ(0, iter.first_ordinal()); + EXPECT_EQ(data_page_pointer, iter.page()); } } } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/plain_page_test.cpp b/be/test/olap/rowset/segment_v2/plain_page_test.cpp index 3691820853..1f14d0ee58 100644 --- a/be/test/olap/rowset/segment_v2/plain_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/plain_page_test.cpp @@ -55,7 +55,7 @@ public: size_t n = 1; decoder->next_batch(&n, &column_block_view); - ASSERT_EQ(1, n); + EXPECT_EQ(1, n); *ret = *reinterpret_cast::CppType*>(block.cell_ptr(0)); } @@ -73,17 +73,17 @@ public: //check first value and last value CppType first_value; page_builder.get_first_value(&first_value); - ASSERT_EQ(src[0], first_value); + EXPECT_EQ(src[0], first_value); CppType last_value; page_builder.get_last_value(&last_value); - ASSERT_EQ(src[size - 1], last_value); + EXPECT_EQ(src[size - 1], last_value); PageDecoderOptions decoder_options; PageDecoderType page_decoder(s.slice(), decoder_options); Status status = page_decoder.init(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); - ASSERT_EQ(0, page_decoder.current_index()); + EXPECT_EQ(0, page_decoder.current_index()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -93,7 +93,7 @@ public: ColumnBlock block(cvb.get(), &pool); ColumnBlockView column_block_view(&block); status = page_decoder.next_batch(&size, &column_block_view); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); CppType* decoded = reinterpret_cast(block.data()); for (uint i = 0; i < size; i++) { @@ -131,34 +131,34 @@ public: PageDecoderType page_decoder(s.slice(), decoder_options); Status status = page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, page_decoder.current_index()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, page_decoder.current_index()); size_t index = random() % size; CppType seek_value = src[index]; bool exact_match; status = page_decoder.seek_at_or_after_value(&seek_value, &exact_match); EXPECT_EQ(index, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); CppType last_value = src[size - 1]; status = page_decoder.seek_at_or_after_value(&last_value, &exact_match); EXPECT_EQ(size - 1, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); CppType first_value = src[0]; status = page_decoder.seek_at_or_after_value(&first_value, &exact_match); EXPECT_EQ(0, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(exact_match); if (small_than_smallest != nullptr) { status = page_decoder.seek_at_or_after_value(small_than_smallest, &exact_match); EXPECT_EQ(0, page_decoder.current_index()); - ASSERT_TRUE(status.ok()); - ASSERT_FALSE(exact_match); + EXPECT_TRUE(status.ok()); + EXPECT_FALSE(exact_match); } if (bigger_than_biggest != nullptr) { @@ -335,8 +335,3 @@ TEST_F(PlainPageTest, TestBoolPlainPageSeekValue) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/rle_page_test.cpp b/be/test/olap/rowset/segment_v2/rle_page_test.cpp index e146024241..70c14b3f8e 100644 --- a/be/test/olap/rowset/segment_v2/rle_page_test.cpp +++ b/be/test/olap/rowset/segment_v2/rle_page_test.cpp @@ -48,7 +48,7 @@ public: size_t n = 1; decoder->next_batch(&n, &column_block_view); - ASSERT_EQ(1, n); + EXPECT_EQ(1, n); *ret = *reinterpret_cast::CppType*>(block.cell_ptr(0)); } @@ -60,22 +60,22 @@ public: PageBuilderType rle_page_builder(builder_options); rle_page_builder.add(reinterpret_cast(src), &size); OwnedSlice s = rle_page_builder.finish(); - ASSERT_EQ(size, rle_page_builder.count()); + EXPECT_EQ(size, rle_page_builder.count()); //check first value and last value CppType first_value; rle_page_builder.get_first_value(&first_value); - ASSERT_EQ(src[0], first_value); + EXPECT_EQ(src[0], first_value); CppType last_value; rle_page_builder.get_last_value(&last_value); - ASSERT_EQ(src[size - 1], last_value); + EXPECT_EQ(src[size - 1], last_value); PageDecoderOptions decodeder_options; PageDecoderType rle_page_decoder(s.slice(), decodeder_options); Status status = rle_page_decoder.init(); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(0, rle_page_decoder.current_index()); - ASSERT_EQ(size, rle_page_decoder.count()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(0, rle_page_decoder.current_index()); + EXPECT_EQ(size, rle_page_decoder.count()); auto tracker = std::make_shared(); MemPool pool(tracker.get()); @@ -85,8 +85,8 @@ public: ColumnBlockView column_block_view(&block); size_t size_to_fetch = size; status = rle_page_decoder.next_batch(&size_to_fetch, &column_block_view); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(size, size_to_fetch); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(size, size_to_fetch); CppType* values = reinterpret_cast(block.data()); for (uint i = 0; i < size; i++) { @@ -165,7 +165,7 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderSize) { // 4 bytes header // 2 bytes indicate_value(): 0x64 << 1 | 1 = 201 // 4 bytes values - ASSERT_EQ(10, s.slice().size); + EXPECT_EQ(10, s.slice().size); } TEST_F(RlePageTest, TestRleBoolBlockEncoderRandom) { @@ -201,12 +201,7 @@ TEST_F(RlePageTest, TestRleBoolBlockEncoderSize) { // 4 bytes header // 2 bytes indicate_value(): 0x64 << 1 | 1 = 201 // 1 bytes values - ASSERT_EQ(7, s.slice().size); + EXPECT_EQ(7, s.slice().size); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/row_ranges_test.cpp b/be/test/olap/rowset/segment_v2/row_ranges_test.cpp index 800ee21098..3aaa635ea6 100644 --- a/be/test/olap/rowset/segment_v2/row_ranges_test.cpp +++ b/be/test/olap/rowset/segment_v2/row_ranges_test.cpp @@ -34,33 +34,33 @@ TEST_F(RowRangesTest, TestRange) { RowRange range1(10, 20); RowRange range2(15, 25); RowRange range3(30, 40); - ASSERT_TRUE(range1.is_valid()); - ASSERT_EQ(10, range1.from()); - ASSERT_EQ(20, range1.to()); - ASSERT_EQ(10, range1.count()); - ASSERT_TRUE(range1.is_before(range3)); - ASSERT_FALSE(range1.is_after(range2)); - ASSERT_TRUE(range3.is_after(range1)); + EXPECT_TRUE(range1.is_valid()); + EXPECT_EQ(10, range1.from()); + EXPECT_EQ(20, range1.to()); + EXPECT_EQ(10, range1.count()); + EXPECT_TRUE(range1.is_before(range3)); + EXPECT_FALSE(range1.is_after(range2)); + EXPECT_TRUE(range3.is_after(range1)); RowRange tmp; RowRange::range_intersection(range1, range2, &tmp); - ASSERT_TRUE(tmp.is_valid()); - ASSERT_EQ(5, tmp.count()); - ASSERT_TRUE(tmp.is_valid()); + EXPECT_TRUE(tmp.is_valid()); + EXPECT_EQ(5, tmp.count()); + EXPECT_TRUE(tmp.is_valid()); RowRange tmp2; RowRange::range_intersection(range1, range3, &tmp2); - ASSERT_FALSE(tmp2.is_valid()); + EXPECT_FALSE(tmp2.is_valid()); RowRange tmp3; RowRange::range_union(range1, range3, &tmp3); - ASSERT_FALSE(tmp3.is_valid()); + EXPECT_FALSE(tmp3.is_valid()); RowRange range4(0, 0); - ASSERT_FALSE(range4.is_valid()); + EXPECT_FALSE(range4.is_valid()); RowRange range5(20, 25); RowRange tmp4; - ASSERT_FALSE(RowRange::range_intersection(range1, range5, &tmp4)); - ASSERT_TRUE(RowRange::range_union(range1, range5, &tmp4)); - ASSERT_EQ(15, tmp4.count()); - ASSERT_EQ(10, tmp4.from()); - ASSERT_EQ(25, tmp4.to()); + EXPECT_FALSE(RowRange::range_intersection(range1, range5, &tmp4)); + EXPECT_TRUE(RowRange::range_union(range1, range5, &tmp4)); + EXPECT_EQ(15, tmp4.count()); + EXPECT_EQ(10, tmp4.from()); + EXPECT_EQ(25, tmp4.to()); } TEST_F(RowRangesTest, TestRowRanges) { @@ -72,37 +72,37 @@ TEST_F(RowRangesTest, TestRowRanges) { RowRanges row_ranges_merge; RowRanges::ranges_intersection(row_ranges1, row_ranges2, &row_ranges_merge); - ASSERT_EQ(0, row_ranges_merge.count()); - ASSERT_TRUE(row_ranges_merge.is_empty()); + EXPECT_EQ(0, row_ranges_merge.count()); + EXPECT_TRUE(row_ranges_merge.is_empty()); RowRanges row_ranges_merge2; RowRanges::ranges_intersection(row_ranges1, row_ranges3, &row_ranges_merge2); - ASSERT_EQ(5, row_ranges_merge2.count()); - ASSERT_FALSE(row_ranges_merge2.is_empty()); - ASSERT_TRUE(row_ranges_merge2.contain(16, 19)); - ASSERT_EQ(15, row_ranges_merge2.from()); - ASSERT_EQ(20, row_ranges_merge2.to()); - ASSERT_EQ(15, row_ranges_merge2.get_range_from(0)); - ASSERT_EQ(20, row_ranges_merge2.get_range_to(0)); - ASSERT_EQ(5, row_ranges_merge2.get_range_count(0)); + EXPECT_EQ(5, row_ranges_merge2.count()); + EXPECT_FALSE(row_ranges_merge2.is_empty()); + EXPECT_TRUE(row_ranges_merge2.contain(16, 19)); + EXPECT_EQ(15, row_ranges_merge2.from()); + EXPECT_EQ(20, row_ranges_merge2.to()); + EXPECT_EQ(15, row_ranges_merge2.get_range_from(0)); + EXPECT_EQ(20, row_ranges_merge2.get_range_to(0)); + EXPECT_EQ(5, row_ranges_merge2.get_range_count(0)); RowRanges row_ranges_merge3; RowRanges::ranges_intersection(row_ranges1, row_ranges4, &row_ranges_merge3); - ASSERT_EQ(0, row_ranges_merge3.count()); - ASSERT_TRUE(row_ranges_merge3.is_empty()); + EXPECT_EQ(0, row_ranges_merge3.count()); + EXPECT_TRUE(row_ranges_merge3.is_empty()); RowRanges row_ranges_union; RowRanges::ranges_union(row_ranges1, row_ranges2, &row_ranges_union); - ASSERT_EQ(20, row_ranges_union.count()); + EXPECT_EQ(20, row_ranges_union.count()); RowRanges::ranges_union(row_ranges_union, row_ranges4, &row_ranges_union); - ASSERT_EQ(30, row_ranges_union.count()); - ASSERT_FALSE(row_ranges_union.is_empty()); - ASSERT_TRUE(row_ranges_union.contain(16, 19)); - ASSERT_EQ(10, row_ranges_union.from()); - ASSERT_EQ(50, row_ranges_union.to()); - ASSERT_EQ(10, row_ranges_union.get_range_from(0)); - ASSERT_EQ(30, row_ranges_union.get_range_to(0)); - ASSERT_EQ(20, row_ranges_union.get_range_count(0)); + EXPECT_EQ(30, row_ranges_union.count()); + EXPECT_FALSE(row_ranges_union.is_empty()); + EXPECT_TRUE(row_ranges_union.contain(16, 19)); + EXPECT_EQ(10, row_ranges_union.from()); + EXPECT_EQ(50, row_ranges_union.to()); + EXPECT_EQ(10, row_ranges_union.get_range_from(0)); + EXPECT_EQ(30, row_ranges_union.get_range_to(0)); + EXPECT_EQ(20, row_ranges_union.get_range_count(0)); } TEST_F(RowRangesTest, TestRangesToRoaring) { @@ -113,31 +113,26 @@ TEST_F(RowRangesTest, TestRangesToRoaring) { RowRanges row_ranges4 = RowRanges::create_single(40, 50); roaring::Roaring row_bitmap = RowRanges::ranges_to_roaring(row_ranges1); - ASSERT_EQ(row_ranges1.count(), row_bitmap.cardinality()); + EXPECT_EQ(row_ranges1.count(), row_bitmap.cardinality()); row_bitmap = RowRanges::ranges_to_roaring(row_ranges3); - ASSERT_EQ(row_ranges3.count(), row_bitmap.cardinality()); + EXPECT_EQ(row_ranges3.count(), row_bitmap.cardinality()); RowRanges row_ranges_merge; RowRanges::ranges_intersection(row_ranges1, row_ranges2, &row_ranges_merge); row_bitmap = RowRanges::ranges_to_roaring(row_ranges_merge); - ASSERT_EQ(row_ranges_merge.count(), row_bitmap.cardinality()); + EXPECT_EQ(row_ranges_merge.count(), row_bitmap.cardinality()); RowRanges row_ranges_merge2; RowRanges::ranges_intersection(row_ranges1, row_ranges3, &row_ranges_merge2); row_bitmap = RowRanges::ranges_to_roaring(row_ranges_merge2); - ASSERT_EQ(row_ranges_merge2.count(), row_bitmap.cardinality()); + EXPECT_EQ(row_ranges_merge2.count(), row_bitmap.cardinality()); RowRanges row_ranges_union; RowRanges::ranges_union(row_ranges1, row_ranges2, &row_ranges_union); row_bitmap = RowRanges::ranges_to_roaring(row_ranges_union); - ASSERT_EQ(row_ranges_union.count(), row_bitmap.cardinality()); + EXPECT_EQ(row_ranges_union.count(), row_bitmap.cardinality()); } } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/segment_test.cpp b/be/test/olap/rowset/segment_v2/segment_test.cpp index d8f16e22f4..5ea303aabb 100644 --- a/be/test/olap/rowset/segment_v2/segment_test.cpp +++ b/be/test/olap/rowset/segment_v2/segment_test.cpp @@ -26,6 +26,7 @@ #include "common/logging.h" #include "gutil/strings/substitute.h" #include "olap/comparison_predicate.h" +#include "olap/data_dir.h" #include "olap/fs/block_manager.h" #include "olap/fs/fs_util.h" #include "olap/in_list_predicate.h" @@ -40,9 +41,8 @@ #include "olap/types.h" #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" - namespace doris { namespace segment_v2 { @@ -74,14 +74,14 @@ class SegmentReaderWriterTest : public ::testing::Test { protected: void SetUp() override { if (FileUtils::check_exist(kSegmentDir)) { - ASSERT_TRUE(FileUtils::remove_all(kSegmentDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kSegmentDir).ok()); } - ASSERT_TRUE(FileUtils::create_dir(kSegmentDir).ok()); + EXPECT_TRUE(FileUtils::create_dir(kSegmentDir).ok()); } void TearDown() override { if (FileUtils::check_exist(kSegmentDir)) { - ASSERT_TRUE(FileUtils::remove_all(kSegmentDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kSegmentDir).ok()); } } @@ -114,14 +114,16 @@ protected: fs::CreateBlockOptions block_opts(filename); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(block_opts, &wblock); - ASSERT_TRUE(st.ok()); - SegmentWriter writer(wblock.get(), 0, &build_schema, opts); + EXPECT_TRUE(st.ok()); + DataDir data_dir(kSegmentDir); + data_dir.init(); + SegmentWriter writer(wblock.get(), 0, &build_schema, &data_dir, opts); st = writer.init(10); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowCursor row; auto olap_st = row.init(build_schema); - ASSERT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(OLAP_SUCCESS, olap_st); for (size_t rid = 0; rid < nrows; ++rid) { for (int cid = 0; cid < build_schema.num_columns(); ++cid) { @@ -129,19 +131,19 @@ protected: RowCursorCell cell = row.cell(cid); generator(rid, cid, row_block_id, cell); } - ASSERT_TRUE(writer.append_row(row).ok()); + EXPECT_TRUE(writer.append_row(row).ok()); } uint64_t file_size, index_size; st = writer.finalize(&file_size, &index_size); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(wblock->close().ok()); FilePathDesc path_desc; path_desc.filepath = filename; st = Segment::open(path_desc, 0, &query_schema, res); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(nrows, (*res)->num_rows()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(nrows, (*res)->num_rows()); } private: @@ -177,9 +179,9 @@ TEST_F(SegmentReaderWriterTest, normal) { while (left > 0) { int rows_read = left > 1024 ? 1024 : left; block.clear(); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -187,8 +189,8 @@ TEST_F(SegmentReaderWriterTest, normal) { auto column_block = block.column_block(j); for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); } } rowid += rows_read; @@ -226,12 +228,12 @@ TEST_F(SegmentReaderWriterTest, normal) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 100); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(11, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(11, block.num_rows()); auto column_block = block.column_block(0); for (int i = 0; i < 11; ++i) { - ASSERT_EQ(100 + i * 10, *(int*)column_block.cell_ptr(i)); + EXPECT_EQ(100 + i * 10, *(int*)column_block.cell_ptr(i)); } } // test seek, key @@ -252,8 +254,8 @@ TEST_F(SegmentReaderWriterTest, normal) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 100); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test seek, key (-2, -1) { @@ -281,8 +283,8 @@ TEST_F(SegmentReaderWriterTest, normal) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 100); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } } } @@ -315,15 +317,15 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) { read_opts.stats = &stats; std::unique_ptr iter; - ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); + EXPECT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); RowBlockV2 block(read_schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_TRUE(iter->is_lazy_materialization_read()); - ASSERT_EQ(1, block.selected_size()); - ASSERT_EQ(99, stats.rows_vec_cond_filtered); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_TRUE(iter->is_lazy_materialization_read()); + EXPECT_EQ(1, block.selected_size()); + EXPECT_EQ(99, stats.rows_vec_cond_filtered); auto row = block.row(block.selection_vector()[0]); - ASSERT_EQ("[3,30]", row.debug_string()); + EXPECT_EQ("[3,30]", row.debug_string()); } { // lazy disabled when all return columns have predicates: @@ -339,15 +341,15 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) { read_opts.stats = &stats; std::unique_ptr iter; - ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); + EXPECT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); RowBlockV2 block(read_schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_FALSE(iter->is_lazy_materialization_read()); - ASSERT_EQ(1, block.selected_size()); - ASSERT_EQ(99, stats.rows_vec_cond_filtered); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_FALSE(iter->is_lazy_materialization_read()); + EXPECT_EQ(1, block.selected_size()); + EXPECT_EQ(99, stats.rows_vec_cond_filtered); auto row = block.row(block.selection_vector()[0]); - ASSERT_EQ("[10,100]", row.debug_string()); + EXPECT_EQ("[10,100]", row.debug_string()); } { // lazy disabled when no predicate: @@ -359,15 +361,15 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) { read_opts.stats = &stats; std::unique_ptr iter; - ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); + EXPECT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); RowBlockV2 block(read_schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_FALSE(iter->is_lazy_materialization_read()); - ASSERT_EQ(100, block.selected_size()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_FALSE(iter->is_lazy_materialization_read()); + EXPECT_EQ(100, block.selected_size()); for (int i = 0; i < block.selected_size(); ++i) { auto row = block.row(block.selection_vector()[i]); - ASSERT_EQ(strings::Substitute("[$0]", i * 10), row.debug_string()); + EXPECT_EQ(strings::Substitute("[$0]", i * 10), row.debug_string()); } } } @@ -377,7 +379,7 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) { shared_ptr segment; SegmentWriterOptions write_opts; build_segment(write_opts, tablet_schema, tablet_schema, 100, data_gen, &segment); - ASSERT_TRUE(column_contains_index(segment->footer().columns(0), BITMAP_INDEX)); + EXPECT_TRUE(column_contains_index(segment->footer().columns(0), BITMAP_INDEX)); { // lazy disabled when all predicates are removed by bitmap index: // select c1, c2 where c2 = 30; @@ -391,16 +393,16 @@ TEST_F(SegmentReaderWriterTest, LazyMaterialization) { read_opts.stats = &stats; std::unique_ptr iter; - ASSERT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); + EXPECT_TRUE(segment->new_iterator(read_schema, read_opts, &iter).ok()); RowBlockV2 block(read_schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_FALSE(iter->is_lazy_materialization_read()); - ASSERT_EQ(1, block.selected_size()); - ASSERT_EQ(99, stats.rows_bitmap_index_filtered); - ASSERT_EQ(0, stats.rows_vec_cond_filtered); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_FALSE(iter->is_lazy_materialization_read()); + EXPECT_EQ(1, block.selected_size()); + EXPECT_EQ(99, stats.rows_bitmap_index_filtered); + EXPECT_EQ(0, stats.rows_vec_cond_filtered); auto row = block.row(block.selection_vector()[0]); - ASSERT_EQ("[20,200]", row.debug_string()); + EXPECT_EQ("[20,200]", row.debug_string()); } } } @@ -446,7 +448,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -457,8 +459,8 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { RowBlockV2 block(schema, 1); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // scan all rows { @@ -469,7 +471,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -487,9 +489,9 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { while (left > 0) { int rows_read = left > 1024 ? 1024 : left; block.clear(); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -497,16 +499,16 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { auto column_block = block.column_block(j); for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)) + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)) << "rid:" << rid << ", i:" << i; } } rowid += rows_read; } - ASSERT_EQ(16 * 1024, rowid); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_EQ(16 * 1024, rowid); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test zone map with query predicate an delete predicate { @@ -518,7 +520,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); // the second page read will be pruned by the following delete predicate TCondition delete_condition; @@ -528,7 +530,7 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { delete_condition.__set_condition_values(vals2); std::shared_ptr delete_conditions(new Conditions()); delete_conditions->set_tablet_schema(&tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, delete_conditions->append_condition(delete_condition)); + EXPECT_EQ(OLAP_SUCCESS, delete_conditions->append_condition(delete_condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -548,9 +550,9 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { int rows_read = left > 1024 ? 1024 : left; block.clear(); auto s = iter->next_batch(&block); - ASSERT_TRUE(s.ok()) << s.to_string(); - ASSERT_EQ(rows_read, block.num_rows()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_TRUE(s.ok()) << s.to_string(); + EXPECT_EQ(rows_read, block.num_rows()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -558,16 +560,16 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { auto column_block = block.column_block(j); for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)) + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)) << "rid:" << rid << ", i:" << i; } } rowid += rows_read; } - ASSERT_EQ(16 * 1024, rowid); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_EQ(16 * 1024, rowid); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test bloom filter { @@ -581,14 +583,14 @@ TEST_F(SegmentReaderWriterTest, TestIndex) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(&tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); read_opts.conditions = conditions.get(); std::unique_ptr iter; segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } } } @@ -619,14 +621,16 @@ TEST_F(SegmentReaderWriterTest, estimate_segment_size) { fs::CreateBlockOptions wblock_opts(fname); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(wblock_opts, &wblock); - ASSERT_TRUE(st.ok()) << st.to_string(); - SegmentWriter writer(wblock.get(), 0, tablet_schema.get(), opts); + EXPECT_TRUE(st.ok()) << st.to_string(); + DataDir data_dir(dname); + data_dir.init(); + SegmentWriter writer(wblock.get(), 0, tablet_schema.get(), &data_dir, opts); st = writer.init(10); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); RowCursor row; auto olap_st = row.init(*tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(OLAP_SUCCESS, olap_st); // 0, 1, 2, 3 // 10, 11, 12, 13 @@ -645,13 +649,13 @@ TEST_F(SegmentReaderWriterTest, estimate_segment_size) { uint64_t file_size = 0; uint64_t index_size; - ASSERT_TRUE(writer.finalize(&file_size, &index_size).ok()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(writer.finalize(&file_size, &index_size).ok()); + EXPECT_TRUE(wblock->close().ok()); file_size = std::filesystem::file_size(fname); LOG(INFO) << "segment file size is:" << file_size; - ASSERT_NE(segment_size, 0); + EXPECT_NE(segment_size, 0); FileUtils::remove_all(dname); } @@ -688,9 +692,9 @@ TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) { while (left > 0) { int rows_read = left > 1024 ? 1024 : left; block.clear(); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -699,10 +703,10 @@ TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) { for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; if (cid == 4) { - ASSERT_TRUE(column_block.is_null(i)); + EXPECT_TRUE(column_block.is_null(i)); } else { - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); } } } @@ -738,8 +742,8 @@ TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) { while (left > 0) { int rows_read = left > 1024 ? 1024 : left; block.clear(); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -748,11 +752,11 @@ TEST_F(SegmentReaderWriterTest, TestDefaultValueColumn) { for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; if (cid == 4) { - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(10086, *(int*)column_block.cell_ptr(i)); + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(10086, *(int*)column_block.cell_ptr(i)); } else { - ASSERT_FALSE(column_block.is_null(i)); - ASSERT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); + EXPECT_FALSE(column_block.is_null(i)); + EXPECT_EQ(rid * 10 + cid, *(int*)column_block.cell_ptr(i)); } } } @@ -790,14 +794,16 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { fs::CreateBlockOptions wblock_opts(fname); std::string storage_name; Status st = fs::fs_util::block_manager(storage_name)->create_block(wblock_opts, &wblock); - ASSERT_TRUE(st.ok()); - SegmentWriter writer(wblock.get(), 0, tablet_schema.get(), opts); + EXPECT_TRUE(st.ok()); + DataDir data_dir(dname); + data_dir.init(); + SegmentWriter writer(wblock.get(), 0, tablet_schema.get(), &data_dir, opts); st = writer.init(10); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RowCursor row; auto olap_st = row.init(*tablet_schema); - ASSERT_EQ(OLAP_SUCCESS, olap_st); + EXPECT_EQ(OLAP_SUCCESS, olap_st); // 0, 1, 2, 3 // 10, 11, 12, 13 @@ -812,21 +818,21 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { tablet_schema->_cols[j]._length); } Status status = writer.append_row(row); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } uint64_t file_size = 0; uint64_t index_size; - ASSERT_TRUE(writer.finalize(&file_size, &index_size).ok()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(writer.finalize(&file_size, &index_size).ok()); + EXPECT_TRUE(wblock->close().ok()); { std::shared_ptr segment; FilePathDesc path_desc; path_desc.filepath = fname; st = Segment::open(path_desc, 0, tablet_schema.get(), &segment); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(4096, segment->num_rows()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(4096, segment->num_rows()); Schema schema(*tablet_schema); OlapReaderStatistics stats; // scan all rows @@ -845,9 +851,9 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { int rows_read = left > 1024 ? 1024 : left; block.clear(); st = iter->next_batch(&block); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -855,7 +861,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { auto column_block = block.column_block(j); for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; - ASSERT_FALSE(column_block.is_null(i)); + EXPECT_FALSE(column_block.is_null(i)); const Slice* actual = reinterpret_cast(column_block.cell_ptr(i)); @@ -863,7 +869,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { set_column_value_by_type(tablet_schema->_cols[j]._type, rid * 10 + cid, reinterpret_cast(&expect), &pool, tablet_schema->_cols[j]._length); - ASSERT_EQ(expect.to_string(), actual->to_string()); + EXPECT_EQ(expect.to_string(), actual->to_string()); } } rowid += rows_read; @@ -891,8 +897,8 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { RowBlockV2 block(schema, 100); st = iter->next_batch(&block); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test seek, key (-2, -1) @@ -924,8 +930,8 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { RowBlockV2 block(schema, 100); st = iter->next_batch(&block); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test char zone_map query hit;should read whole page @@ -937,7 +943,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(tablet_schema.get()); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -954,9 +960,9 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { int rows_read = left > 1024 ? 1024 : left; block.clear(); st = iter->next_batch(&block); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(DEL_NOT_SATISFIED, block.delete_state()); - ASSERT_EQ(rows_read, block.num_rows()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(DEL_NOT_SATISFIED, block.delete_state()); + EXPECT_EQ(rows_read, block.num_rows()); left -= rows_read; for (int j = 0; j < block.schema()->column_ids().size(); ++j) { @@ -964,7 +970,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { auto column_block = block.column_block(j); for (int i = 0; i < rows_read; ++i) { int rid = rowid + i; - ASSERT_FALSE(column_block.is_null(i)); + EXPECT_FALSE(column_block.is_null(i)); const Slice* actual = reinterpret_cast(column_block.cell_ptr(i)); @@ -972,17 +978,17 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { set_column_value_by_type(tablet_schema->_cols[j]._type, rid * 10 + cid, reinterpret_cast(&expect), &pool, tablet_schema->_cols[j]._length); - ASSERT_EQ(expect.to_string(), actual->to_string()) + EXPECT_EQ(expect.to_string(), actual->to_string()) << "rid:" << rid << ", i:" << i; ; } } rowid += rows_read; } - ASSERT_EQ(4 * 1024, rowid); + EXPECT_EQ(4 * 1024, rowid); st = iter->next_batch(&block); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } // test char zone_map query miss;col < -1 @@ -994,7 +1000,7 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { condition.__set_condition_values(vals); std::shared_ptr conditions(new Conditions()); conditions->set_tablet_schema(tablet_schema.get()); - ASSERT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); + EXPECT_EQ(OLAP_SUCCESS, conditions->append_condition(condition)); StorageReadOptions read_opts; read_opts.stats = &stats; @@ -1006,8 +1012,8 @@ TEST_F(SegmentReaderWriterTest, TestStringDict) { RowBlockV2 block(schema, 1024); st = iter->next_batch(&block); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(0, block.num_rows()); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(0, block.num_rows()); } } @@ -1022,8 +1028,8 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { SegmentWriterOptions opts; shared_ptr segment; build_segment(opts, tablet_schema, tablet_schema, 4096, DefaultIntGenerator, &segment); - ASSERT_TRUE(column_contains_index(segment->footer().columns(0), BITMAP_INDEX)); - ASSERT_TRUE(column_contains_index(segment->footer().columns(1), BITMAP_INDEX)); + EXPECT_TRUE(column_contains_index(segment->footer().columns(0), BITMAP_INDEX)); + EXPECT_TRUE(column_contains_index(segment->footer().columns(1), BITMAP_INDEX)); { Schema schema(tablet_schema); @@ -1043,9 +1049,9 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(block.num_rows(), 1); - ASSERT_EQ(read_opts.stats->raw_rows_read, 1); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(block.num_rows(), 1); + EXPECT_EQ(read_opts.stats->raw_rows_read, 1); } // test where v1=10 and v2=11 @@ -1065,9 +1071,9 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(block.num_rows(), 1); - ASSERT_EQ(read_opts.stats->raw_rows_read, 1); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(block.num_rows(), 1); + EXPECT_EQ(read_opts.stats->raw_rows_read, 1); } // test where v1=10 and v2=15 @@ -1087,8 +1093,8 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 1024); - ASSERT_FALSE(iter->next_batch(&block).ok()); - ASSERT_EQ(read_opts.stats->raw_rows_read, 0); + EXPECT_FALSE(iter->next_batch(&block).ok()); + EXPECT_EQ(read_opts.stats->raw_rows_read, 0); } // test where v1 in (10,20,1) @@ -1111,8 +1117,8 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { segment->new_iterator(schema, read_opts, &iter); RowBlockV2 block(schema, 1024); - ASSERT_TRUE(iter->next_batch(&block).ok()); - ASSERT_EQ(read_opts.stats->raw_rows_read, 2); + EXPECT_TRUE(iter->next_batch(&block).ok()); + EXPECT_EQ(read_opts.stats->raw_rows_read, 2); } // test where v1 not in (10,20) @@ -1140,7 +1146,7 @@ TEST_F(SegmentReaderWriterTest, TestBitmapPredicate) { block.clear(); st = iter->next_batch(&block); } while (st.ok()); - ASSERT_EQ(read_opts.stats->raw_rows_read, 4094); + EXPECT_EQ(read_opts.stats->raw_rows_read, 4094); } } } @@ -1154,20 +1160,14 @@ TEST_F(SegmentReaderWriterTest, TestBloomFilterIndexUniqueModel) { SegmentWriterOptions opts1; shared_ptr seg1; build_segment(opts1, schema, schema, 100, DefaultIntGenerator, &seg1); - ASSERT_TRUE(column_contains_index(seg1->footer().columns(3), BLOOM_FILTER_INDEX)); + EXPECT_TRUE(column_contains_index(seg1->footer().columns(3), BLOOM_FILTER_INDEX)); // for base segment SegmentWriterOptions opts2; shared_ptr seg2; build_segment(opts2, schema, schema, 100, DefaultIntGenerator, &seg2); - ASSERT_TRUE(column_contains_index(seg2->footer().columns(3), BLOOM_FILTER_INDEX)); + EXPECT_TRUE(column_contains_index(seg2->footer().columns(3), BLOOM_FILTER_INDEX)); } } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/segment_v2/zone_map_index_test.cpp b/be/test/olap/rowset/segment_v2/zone_map_index_test.cpp index 3f41ee9aaa..1aa71e4e32 100644 --- a/be/test/olap/rowset/segment_v2/zone_map_index_test.cpp +++ b/be/test/olap/rowset/segment_v2/zone_map_index_test.cpp @@ -39,13 +39,13 @@ public: void SetUp() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } - ASSERT_TRUE(FileUtils::create_dir(kTestDir).ok()); + EXPECT_TRUE(FileUtils::create_dir(kTestDir).ok()); } void TearDown() override { if (FileUtils::check_exist(kTestDir)) { - ASSERT_TRUE(FileUtils::remove_all(kTestDir).ok()); + EXPECT_TRUE(FileUtils::remove_all(kTestDir).ok()); } } @@ -76,30 +76,30 @@ public: std::unique_ptr wblock; fs::CreateBlockOptions opts(filename); std::string storage_name; - ASSERT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); - ASSERT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); - ASSERT_EQ(ZONE_MAP_INDEX, index_meta.type()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); + EXPECT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); + EXPECT_EQ(ZONE_MAP_INDEX, index_meta.type()); + EXPECT_TRUE(wblock->close().ok()); } ZoneMapIndexReader column_zone_map(filename, &index_meta.zone_map_index()); Status status = column_zone_map.load(true, false); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(3, column_zone_map.num_pages()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(3, column_zone_map.num_pages()); const std::vector& zone_maps = column_zone_map.page_zone_maps(); - ASSERT_EQ(3, zone_maps.size()); - ASSERT_EQ("aaaa", zone_maps[0].min()); - ASSERT_EQ("ffff", zone_maps[0].max()); - ASSERT_EQ(false, zone_maps[0].has_null()); - ASSERT_EQ(true, zone_maps[0].has_not_null()); + EXPECT_EQ(3, zone_maps.size()); + EXPECT_EQ("aaaa", zone_maps[0].min()); + EXPECT_EQ("ffff", zone_maps[0].max()); + EXPECT_EQ(false, zone_maps[0].has_null()); + EXPECT_EQ(true, zone_maps[0].has_not_null()); - ASSERT_EQ("aaaaa", zone_maps[1].min()); - ASSERT_EQ("fffff", zone_maps[1].max()); - ASSERT_EQ(true, zone_maps[1].has_null()); - ASSERT_EQ(true, zone_maps[1].has_not_null()); + EXPECT_EQ("aaaaa", zone_maps[1].min()); + EXPECT_EQ("fffff", zone_maps[1].max()); + EXPECT_EQ(true, zone_maps[1].has_null()); + EXPECT_EQ(true, zone_maps[1].has_not_null()); - ASSERT_EQ(true, zone_maps[2].has_null()); - ASSERT_EQ(false, zone_maps[2].has_not_null()); + EXPECT_EQ(true, zone_maps[2].has_null()); + EXPECT_EQ(false, zone_maps[2].has_not_null()); } void test_cut_zone_map(std::string testname, Field* field) { @@ -121,27 +121,27 @@ public: std::unique_ptr wblock; fs::CreateBlockOptions opts(filename); std::string storage_name; - ASSERT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); - ASSERT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); - ASSERT_EQ(ZONE_MAP_INDEX, index_meta.type()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); + EXPECT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); + EXPECT_EQ(ZONE_MAP_INDEX, index_meta.type()); + EXPECT_TRUE(wblock->close().ok()); } ZoneMapIndexReader column_zone_map(filename, &index_meta.zone_map_index()); Status status = column_zone_map.load(true, false); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(1, column_zone_map.num_pages()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(1, column_zone_map.num_pages()); const std::vector& zone_maps = column_zone_map.page_zone_maps(); - ASSERT_EQ(1, zone_maps.size()); + EXPECT_EQ(1, zone_maps.size()); char value[512]; memset(value, 'a', 512); - ASSERT_EQ(value, zone_maps[0].min()); + EXPECT_EQ(value, zone_maps[0].min()); memset(value, 'f', 512); value[511] += 1; - ASSERT_EQ(value, zone_maps[0].max()); - ASSERT_EQ(false, zone_maps[0].has_null()); - ASSERT_EQ(true, zone_maps[0].has_not_null()); + EXPECT_EQ(value, zone_maps[0].max()); + EXPECT_EQ(false, zone_maps[0].has_null()); + EXPECT_EQ(true, zone_maps[0].has_not_null()); } }; @@ -172,31 +172,31 @@ TEST_F(ColumnZoneMapTest, NormalTestIntPage) { std::unique_ptr wblock; fs::CreateBlockOptions opts({filename}); std::string storage_name; - ASSERT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); - ASSERT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); - ASSERT_EQ(ZONE_MAP_INDEX, index_meta.type()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(fs::fs_util::block_manager(storage_name)->create_block(opts, &wblock).ok()); + EXPECT_TRUE(builder.finish(wblock.get(), &index_meta).ok()); + EXPECT_EQ(ZONE_MAP_INDEX, index_meta.type()); + EXPECT_TRUE(wblock->close().ok()); } ZoneMapIndexReader column_zone_map(filename, &index_meta.zone_map_index()); Status status = column_zone_map.load(true, false); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(3, column_zone_map.num_pages()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(3, column_zone_map.num_pages()); const std::vector& zone_maps = column_zone_map.page_zone_maps(); - ASSERT_EQ(3, zone_maps.size()); + EXPECT_EQ(3, zone_maps.size()); - ASSERT_EQ(std::to_string(1), zone_maps[0].min()); - ASSERT_EQ(std::to_string(22), zone_maps[0].max()); - ASSERT_EQ(false, zone_maps[0].has_null()); - ASSERT_EQ(true, zone_maps[0].has_not_null()); + EXPECT_EQ(std::to_string(1), zone_maps[0].min()); + EXPECT_EQ(std::to_string(22), zone_maps[0].max()); + EXPECT_EQ(false, zone_maps[0].has_null()); + EXPECT_EQ(true, zone_maps[0].has_not_null()); - ASSERT_EQ(std::to_string(2), zone_maps[1].min()); - ASSERT_EQ(std::to_string(31), zone_maps[1].max()); - ASSERT_EQ(true, zone_maps[1].has_null()); - ASSERT_EQ(true, zone_maps[1].has_not_null()); + EXPECT_EQ(std::to_string(2), zone_maps[1].min()); + EXPECT_EQ(std::to_string(31), zone_maps[1].max()); + EXPECT_EQ(true, zone_maps[1].has_null()); + EXPECT_EQ(true, zone_maps[1].has_not_null()); - ASSERT_EQ(true, zone_maps[2].has_null()); - ASSERT_EQ(false, zone_maps[2].has_not_null()); + EXPECT_EQ(true, zone_maps[2].has_null()); + EXPECT_EQ(false, zone_maps[2].has_not_null()); delete field; } @@ -227,9 +227,3 @@ TEST_F(ColumnZoneMapTest, ZoneMapCut) { } // namespace segment_v2 } // namespace doris - -int main(int argc, char** argv) { - doris::StoragePageCache::create_global_cache(1 << 30, 10); - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/rowset/unique_rowset_id_generator_test.cpp b/be/test/olap/rowset/unique_rowset_id_generator_test.cpp index 41e51f31af..8270ad5feb 100644 --- a/be/test/olap/rowset/unique_rowset_id_generator_test.cpp +++ b/be/test/olap/rowset/unique_rowset_id_generator_test.cpp @@ -21,10 +21,10 @@ #include +#include "testutil/test_util.h" #include "util/pretty_printer.h" #include "util/runtime_profile.h" #include "util/threadpool.h" -#include "test_util/test_util.h" namespace doris { class UniqueRowsetIdGeneratorTest : public testing::Test {}; @@ -35,22 +35,22 @@ TEST_F(UniqueRowsetIdGeneratorTest, RowsetIdFormatTest) { hi <<= 56; RowsetId rowset_id; rowset_id.init(123); - ASSERT_EQ(rowset_id.version, 1); - ASSERT_EQ(rowset_id.hi, 123 + hi); - ASSERT_EQ(rowset_id.mi, 0); - ASSERT_EQ(rowset_id.lo, 0); - ASSERT_EQ(std::string("123"), rowset_id.to_string()); + EXPECT_EQ(rowset_id.version, 1); + EXPECT_EQ(rowset_id.hi, 123 + hi); + EXPECT_EQ(rowset_id.mi, 0); + EXPECT_EQ(rowset_id.lo, 0); + EXPECT_EQ(std::string("123"), rowset_id.to_string()); } { int64_t hi = 1; // version hi <<= 56; RowsetId rowset_id; rowset_id.init("123"); - ASSERT_EQ(rowset_id.version, 1); - ASSERT_EQ(rowset_id.hi, 123 + hi); - ASSERT_EQ(rowset_id.mi, 0); - ASSERT_EQ(rowset_id.lo, 0); - ASSERT_EQ(std::string("123"), rowset_id.to_string()); + EXPECT_EQ(rowset_id.version, 1); + EXPECT_EQ(rowset_id.hi, 123 + hi); + EXPECT_EQ(rowset_id.mi, 0); + EXPECT_EQ(rowset_id.lo, 0); + EXPECT_EQ(std::string("123"), rowset_id.to_string()); } { @@ -59,9 +59,9 @@ TEST_F(UniqueRowsetIdGeneratorTest, RowsetIdFormatTest) { const std::string rowset_id_v2("0200000000000003c04f58d989cab2f2efd45faa20449189"); RowsetId rowset_id; rowset_id.init(rowset_id_v2); - ASSERT_EQ(rowset_id.version, 2); - ASSERT_EQ(rowset_id.hi, 3 + hi); - ASSERT_EQ(std::string(rowset_id_v2), rowset_id.to_string()); + EXPECT_EQ(rowset_id.version, 2); + EXPECT_EQ(rowset_id.hi, 3 + hi); + EXPECT_EQ(std::string(rowset_id_v2), rowset_id.to_string()); } } @@ -72,29 +72,29 @@ TEST_F(UniqueRowsetIdGeneratorTest, GenerateIdTest) { hi <<= 56; RowsetId rowset_id = id_generator.next_id(); // hi == 1 - ASSERT_EQ(rowset_id.hi, hi + 1); - ASSERT_EQ(rowset_id.version, 2); + EXPECT_EQ(rowset_id.hi, hi + 1); + EXPECT_EQ(rowset_id.version, 2); rowset_id = id_generator.next_id(); // hi == 2 - ASSERT_EQ(rowset_id.hi, hi + 2); - ASSERT_EQ(rowset_id.version, 2); - ASSERT_EQ(backend_uid.lo, rowset_id.lo); - ASSERT_EQ(backend_uid.hi, rowset_id.mi); - ASSERT_NE(rowset_id.hi, 0); + EXPECT_EQ(rowset_id.hi, hi + 2); + EXPECT_EQ(rowset_id.version, 2); + EXPECT_EQ(backend_uid.lo, rowset_id.lo); + EXPECT_EQ(backend_uid.hi, rowset_id.mi); + EXPECT_NE(rowset_id.hi, 0); bool in_use = id_generator.id_in_use(rowset_id); - ASSERT_TRUE(in_use); + EXPECT_TRUE(in_use); id_generator.release_id(rowset_id); in_use = id_generator.id_in_use(rowset_id); - ASSERT_FALSE(in_use); + EXPECT_FALSE(in_use); int64_t high = rowset_id.hi + 1; rowset_id = id_generator.next_id(); // hi == 3 - ASSERT_EQ(rowset_id.hi, high); + EXPECT_EQ(rowset_id.hi, high); in_use = id_generator.id_in_use(rowset_id); - ASSERT_TRUE(in_use); + EXPECT_TRUE(in_use); std::string rowset_mid_str = rowset_id.to_string().substr(16, 16); std::string backend_mid_str = backend_uid.to_string().substr(0, 16); - ASSERT_EQ(rowset_mid_str, backend_mid_str); + EXPECT_EQ(rowset_mid_str, backend_mid_str); } TEST_F(UniqueRowsetIdGeneratorTest, GenerateIdBenchmark) { @@ -108,13 +108,13 @@ TEST_F(UniqueRowsetIdGeneratorTest, GenerateIdBenchmark) { .set_min_threads(kNumThreads) .set_max_threads(kNumThreads) .build(&pool); - ASSERT_TRUE(s.ok()) << s.to_string(); + EXPECT_TRUE(s.ok()) << s.to_string(); int64_t cost_ns = 0; { SCOPED_RAW_TIMER(&cost_ns); for (int i = 0; i < kNumThreads; i++) { - ASSERT_TRUE(pool->submit_func([&id_generator, kIdPerThread]() { + EXPECT_TRUE(pool->submit_func([&id_generator, kIdPerThread]() { for (int i = 0; i < kIdPerThread; ++i) { id_generator.next_id(); } @@ -126,15 +126,7 @@ TEST_F(UniqueRowsetIdGeneratorTest, GenerateIdBenchmark) { int64_t hi = 2; // version hi <<= 56; RowsetId last_id = id_generator.next_id(); - ASSERT_EQ(last_id.hi, hi + kNumThreads * kIdPerThread + 1); - std::cout << "Generate " << kNumThreads * kIdPerThread << " rowset ids cost " - << PrettyPrinter::print(cost_ns, TUnit::TIME_NS) << std::endl; + EXPECT_EQ(last_id.hi, hi + kNumThreads * kIdPerThread + 1); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/run_length_byte_test.cpp b/be/test/olap/run_length_byte_test.cpp index d8e02bba33..a7c2473dab 100644 --- a/be/test/olap/run_length_byte_test.cpp +++ b/be/test/olap/run_length_byte_test.cpp @@ -36,26 +36,26 @@ TEST(TestStream, UncompressOutStream) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); out_stream->write(0x5a); out_stream->flush(); - ASSERT_EQ(out_stream->get_stream_length(), sizeof(StreamHead) + 1); + EXPECT_EQ(out_stream->get_stream_length(), sizeof(StreamHead) + 1); - ASSERT_EQ(out_stream->output_buffers().size(), 1); + EXPECT_EQ(out_stream->output_buffers().size(), 1); std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_EQ((*it)->position(), 0); + EXPECT_EQ((*it)->position(), 0); StreamHead head; (*it)->get((char*)&head, sizeof(head)); - ASSERT_EQ(head.type, StreamHead::UNCOMPRESSED); - ASSERT_EQ(head.length, 1); + EXPECT_EQ(head.type, StreamHead::UNCOMPRESSED); + EXPECT_EQ(head.length, 1); char data; - ASSERT_EQ(OLAP_SUCCESS, (*it)->get((char*)&data)); - ASSERT_EQ(0x5A, data); - ASSERT_NE(OLAP_SUCCESS, (*it)->get((char*)&data)); + EXPECT_EQ(OLAP_SUCCESS, (*it)->get((char*)&data)); + EXPECT_EQ(0x5A, data); + EXPECT_NE(OLAP_SUCCESS, (*it)->get((char*)&data)); SAFE_DELETE(out_stream); } @@ -64,8 +64,8 @@ TEST(TestStream, UncompressOutStream2) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { out_stream->write(0x5a); @@ -74,9 +74,9 @@ TEST(TestStream, UncompressOutStream2) { out_stream->flush(); uint64_t stream_length = sizeof(StreamHead) * 2 + OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + 1; - ASSERT_EQ(out_stream->get_stream_length(), stream_length); + EXPECT_EQ(out_stream->get_stream_length(), stream_length); - ASSERT_EQ(out_stream->output_buffers().size(), 2); + EXPECT_EQ(out_stream->output_buffers().size(), 2); std::vector inputs; for (const auto& it : out_stream->output_buffers()) { @@ -92,15 +92,15 @@ TEST(TestStream, UncompressOutStream2) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE - 1; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -113,8 +113,8 @@ TEST(TestStream, UncompressOutStream3) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { out_stream->write(0x5a); @@ -124,9 +124,9 @@ TEST(TestStream, UncompressOutStream3) { out_stream->flush(); uint64_t stream_length = sizeof(StreamHead) * 2 + OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + 2; - ASSERT_EQ(out_stream->get_stream_length(), stream_length); + EXPECT_EQ(out_stream->get_stream_length(), stream_length); - ASSERT_EQ(out_stream->output_buffers().size(), 2); + EXPECT_EQ(out_stream->output_buffers().size(), 2); std::vector inputs; for (const auto& it : out_stream->output_buffers()) { @@ -142,16 +142,16 @@ TEST(TestStream, UncompressOutStream3) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -164,8 +164,8 @@ TEST(TestStream, UncompressInStream) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); out_stream->write(0x5a); out_stream->flush(); @@ -173,7 +173,7 @@ TEST(TestStream, UncompressInStream) { // read data std::vector inputs; const auto& it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); inputs.push_back(StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity())); std::vector offsets; @@ -183,10 +183,10 @@ TEST(TestStream, UncompressInStream) { out_stream->get_total_buffer_size()); SAFE_DELETE(out_stream); - ASSERT_EQ(in_stream->available(), 1); + EXPECT_EQ(in_stream->available(), 1); char data; - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -199,8 +199,8 @@ TEST(TestStream, CompressOutStream) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); char* write_data = new char[OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE]; memset(write_data, 0x5a, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); @@ -208,17 +208,17 @@ TEST(TestStream, CompressOutStream) { out_stream->write(write_data, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); out_stream->flush(); - //ASSERT_EQ(out_stream->get_stream_length(), sizeof(StreamHead) + 2); + //EXPECT_EQ(out_stream->get_stream_length(), sizeof(StreamHead) + 2); - //ASSERT_EQ(out_stream->output_buffers().size(), 1); + //EXPECT_EQ(out_stream->output_buffers().size(), 1); std::vector::const_iterator it = out_stream->output_buffers().begin(); StreamHead head; (*it)->get((char*)&head, sizeof(head)); - ASSERT_EQ(head.type, StreamHead::COMPRESSED); + EXPECT_EQ(head.type, StreamHead::COMPRESSED); // if lzo, this should be 49 - ASSERT_EQ(51, head.length); + EXPECT_EQ(51, head.length); SAFE_DELETE_ARRAY(write_data); SAFE_DELETE(out_stream); @@ -228,8 +228,8 @@ TEST(TestStream, CompressOutStream2) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { out_stream->write(0x5a); @@ -251,13 +251,13 @@ TEST(TestStream, CompressOutStream2) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -270,8 +270,8 @@ TEST(TestStream, CompressOutStream3) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { out_stream->write(0x5a); @@ -297,15 +297,15 @@ TEST(TestStream, CompressOutStream3) { char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < sizeof(write_data); i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, write_data[i]); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, write_data[i]); } - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -318,8 +318,8 @@ TEST(TestStream, CompressOutStream3) { TEST(TestStream, CompressOutStream4) { // write data OutStream* out_stream = new (std::nothrow) OutStream(18, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); for (int32_t i = 0; i < 15; i++) { out_stream->write(0x5a); @@ -348,21 +348,21 @@ TEST(TestStream, CompressOutStream4) { char data; for (int32_t i = 0; i < 15; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 12; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 6; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, i); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, i); } - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(in_stream); SAFE_DELETE(out_stream); @@ -374,8 +374,8 @@ TEST(TestStream, CompressOutStream4) { TEST(TestStream, CompressMassOutStream) { // write data OutStream* out_stream = new (std::nothrow) OutStream(100, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); for (int32_t i = 0; i < 100; i++) { out_stream->write(0x5a); @@ -402,15 +402,15 @@ TEST(TestStream, CompressMassOutStream) { char data; for (int32_t i = 0; i < 100; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } for (int32_t i = 0; i < 100; i++) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, i); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, i); } - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -422,8 +422,8 @@ TEST(TestStream, CompressInStream) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor != nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor != nullptr); char* write_data = new char[OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE]; memset(write_data, 0x5a, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); @@ -434,7 +434,7 @@ TEST(TestStream, CompressInStream) { // read data std::vector inputs; std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); StorageByteBuffer* tmp_byte_buffer = StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity()); inputs.push_back(tmp_byte_buffer); @@ -444,15 +444,15 @@ TEST(TestStream, CompressInStream) { InStream* in_stream = new (std::nothrow) InStream(&inputs, offsets, out_stream->get_stream_length(), lz4_decompress, out_stream->get_total_buffer_size()); - ASSERT_EQ(in_stream->available(), OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); + EXPECT_EQ(in_stream->available(), OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); char data; for (int32_t i = 0; i < OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE - 1; ++i) { - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); } - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5a); - ASSERT_NE(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5a); + EXPECT_NE(in_stream->read(&data), OLAP_SUCCESS); SAFE_DELETE_ARRAY(write_data); SAFE_DELETE(out_stream); @@ -466,23 +466,23 @@ TEST(TestStream, SeekUncompress) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); out_stream->write(0x5a); PositionEntryWriter index_entry; out_stream->get_position(&index_entry); out_stream->write(0x5b); - ASSERT_EQ(index_entry.positions_count(), 2); - ASSERT_EQ(index_entry.positions(0), 0); - ASSERT_EQ(index_entry.positions(1), 1); + EXPECT_EQ(index_entry.positions_count(), 2); + EXPECT_EQ(index_entry.positions(0), 0); + EXPECT_EQ(index_entry.positions(1), 1); out_stream->flush(); // read data std::vector inputs; std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); StorageByteBuffer* tmp_byte_buffer = StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity()); inputs.push_back(tmp_byte_buffer); @@ -492,7 +492,7 @@ TEST(TestStream, SeekUncompress) { InStream* in_stream = new (std::nothrow) InStream(&inputs, offsets, out_stream->get_stream_length(), nullptr, out_stream->get_total_buffer_size()); - ASSERT_EQ(in_stream->available(), 2); + EXPECT_EQ(in_stream->available(), 2); char buffer[256]; index_entry.write_to_buffer(buffer); @@ -504,14 +504,14 @@ TEST(TestStream, SeekUncompress) { entry.attach(buffer); PositionProvider position(&entry); - ASSERT_EQ(entry.positions_count(), 2); - ASSERT_EQ(entry.positions(0), 0); - ASSERT_EQ(entry.positions(1), 1); + EXPECT_EQ(entry.positions_count(), 2); + EXPECT_EQ(entry.positions(0), 0); + EXPECT_EQ(entry.positions(1), 1); in_stream->seek(&position); char data; - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5b); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5b); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -523,8 +523,8 @@ TEST(TestStream, SkipUncompress) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(out_stream != nullptr); - ASSERT_TRUE(out_stream->_compressor == nullptr); + EXPECT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream->_compressor == nullptr); char write_data[] = {0x5a, 0x5b, 0x5c, 0x5d}; for (int32_t i = 0; i < sizeof(write_data); i++) { @@ -536,7 +536,7 @@ TEST(TestStream, SkipUncompress) { // read data std::vector inputs; std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); StorageByteBuffer* tmp_byte_buffer = StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity()); inputs.push_back(tmp_byte_buffer); @@ -546,11 +546,11 @@ TEST(TestStream, SkipUncompress) { InStream* in_stream = new (std::nothrow) InStream(&inputs, offsets, out_stream->get_stream_length(), nullptr, out_stream->get_total_buffer_size()); - ASSERT_EQ(in_stream->available(), sizeof(write_data) + 1); + EXPECT_EQ(in_stream->available(), sizeof(write_data) + 1); in_stream->skip(sizeof(write_data) - 1); char data; - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, write_data[sizeof(write_data) - 1]); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, write_data[sizeof(write_data) - 1]); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -562,7 +562,7 @@ TEST(TestStream, SeekCompress) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream != nullptr); for (int32_t i = 0; i < 10; i++) { out_stream->write(0x5a); @@ -571,15 +571,15 @@ TEST(TestStream, SeekCompress) { PositionEntryWriter index_entry; out_stream->get_position(&index_entry); out_stream->write(0x5b); - ASSERT_EQ(index_entry.positions_count(), 2); - ASSERT_EQ(index_entry.positions(0), 0); - ASSERT_EQ(index_entry.positions(1), 10); + EXPECT_EQ(index_entry.positions_count(), 2); + EXPECT_EQ(index_entry.positions(0), 0); + EXPECT_EQ(index_entry.positions(1), 10); out_stream->flush(); // read data std::vector inputs; std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); StorageByteBuffer* tmp_byte_buffer = StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity()); inputs.push_back(tmp_byte_buffer); @@ -589,7 +589,7 @@ TEST(TestStream, SeekCompress) { InStream* in_stream = new (std::nothrow) InStream(&inputs, offsets, out_stream->get_stream_length(), lz4_decompress, out_stream->get_total_buffer_size()); - //ASSERT_EQ(in_stream->available(), 2); + //EXPECT_EQ(in_stream->available(), 2); char buffer[256]; index_entry.write_to_buffer(buffer); StreamIndexHeader header; @@ -602,8 +602,8 @@ TEST(TestStream, SeekCompress) { PositionProvider position(&entry); in_stream->seek(&position); char data; - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5b); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5b); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); for (auto input : inputs) { @@ -615,7 +615,7 @@ TEST(TestStream, SkipCompress) { // write data OutStream* out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, lz4_compress); - ASSERT_TRUE(out_stream != nullptr); + EXPECT_TRUE(out_stream != nullptr); for (int32_t i = 0; i < 10; i++) { out_stream->write(0x5a); @@ -626,7 +626,7 @@ TEST(TestStream, SkipCompress) { // read data std::vector inputs; std::vector::const_iterator it = out_stream->output_buffers().begin(); - ASSERT_NE(it, out_stream->output_buffers().end()); + EXPECT_NE(it, out_stream->output_buffers().end()); StorageByteBuffer* tmp_byte_buffer = StorageByteBuffer::reference_buffer(*it, 0, (*it)->capacity()); inputs.push_back(tmp_byte_buffer); @@ -639,8 +639,8 @@ TEST(TestStream, SkipCompress) { in_stream->skip(10); char data; - ASSERT_EQ(in_stream->read(&data), OLAP_SUCCESS); - ASSERT_EQ(data, 0x5e); + EXPECT_EQ(in_stream->read(&data), OLAP_SUCCESS); + EXPECT_EQ(data, 0x5e); SAFE_DELETE(out_stream); SAFE_DELETE(in_stream); @@ -656,12 +656,12 @@ public: virtual ~TestRunLengthByte() {} virtual void SetUp() { - ASSERT_EQ(system("mkdir -p ./ut_dir"), 0); - ASSERT_EQ(system("rm -rf ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); + EXPECT_EQ(system("rm -rf ./ut_dir/tmp_file"), 0); _out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(_out_stream != nullptr); + EXPECT_TRUE(_out_stream != nullptr); _writer = new (std::nothrow) RunLengthByteWriter(_out_stream); - ASSERT_TRUE(_writer != nullptr); + EXPECT_TRUE(_writer != nullptr); } virtual void TearDown() { @@ -673,26 +673,26 @@ public: } void CreateReader() { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - ASSERT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(OLAP_SUCCESS, _stream->init()); _reader = new (std::nothrow) RunLengthByteReader(_stream); - ASSERT_TRUE(_reader != nullptr); + EXPECT_TRUE(_reader != nullptr); } RunLengthByteReader* _reader; @@ -711,12 +711,12 @@ TEST_F(TestRunLengthByte, ReadWriteOneByte) { _writer->flush(); CreateReader(); - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); char value = 0xff; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0X5A); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0X5A); - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthByte, ReadWriteMultiBytes) { @@ -729,19 +729,19 @@ TEST_F(TestRunLengthByte, ReadWriteMultiBytes) { _writer->flush(); // the stream contain head, control byte and four byte literal - ASSERT_EQ(_out_stream->get_stream_length(), sizeof(StreamHead) + 1 + 4); + EXPECT_EQ(_out_stream->get_stream_length(), sizeof(StreamHead) + 1 + 4); // read data CreateReader(); for (int32_t i = 0; i < sizeof(write_data); i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); char value = 0xff; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthByte, ReadWriteSameBytes) { @@ -754,19 +754,19 @@ TEST_F(TestRunLengthByte, ReadWriteSameBytes) { _writer->flush(); // the stream contain head, control byte(4-3) and one byte literal - ASSERT_EQ(_out_stream->get_stream_length(), sizeof(StreamHead) + 1 + 1); + EXPECT_EQ(_out_stream->get_stream_length(), sizeof(StreamHead) + 1 + 1); // read data CreateReader(); for (int32_t i = 0; i < sizeof(write_data); i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); char value = 0xff; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthByte, Seek) { @@ -801,14 +801,14 @@ TEST_F(TestRunLengthByte, Seek) { PositionProvider position(&entry); _reader->seek(&position); char value = 0xff; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0x5e); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0x5f); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0x60); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0x61); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0x5e); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0x5f); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0x60); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0x61); } TEST_F(TestRunLengthByte, Skip) { @@ -825,24 +825,10 @@ TEST_F(TestRunLengthByte, Skip) { _reader->skip(sizeof(write_data) - 1); char value = 0xff; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[sizeof(write_data) - 1]); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 0x5e); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[sizeof(write_data) - 1]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 0x5e); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/run_length_integer_test.cpp b/be/test/olap/run_length_integer_test.cpp index 0f4d49a836..5a70e121a4 100644 --- a/be/test/olap/run_length_integer_test.cpp +++ b/be/test/olap/run_length_integer_test.cpp @@ -35,12 +35,12 @@ public: virtual ~TestRunLengthUnsignInteger() {} virtual void SetUp() { - ASSERT_EQ(system("mkdir -p ./ut_dir"), 0); - ASSERT_EQ(system("rm -rf ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); + EXPECT_EQ(system("rm -rf ./ut_dir/tmp_file"), 0); _out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(_out_stream != nullptr); + EXPECT_TRUE(_out_stream != nullptr); _writer = new (std::nothrow) RunLengthIntegerWriter(_out_stream, false); - ASSERT_TRUE(_writer != nullptr); + EXPECT_TRUE(_writer != nullptr); } virtual void TearDown() { @@ -52,26 +52,26 @@ public: } void CreateReader() { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - ASSERT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(OLAP_SUCCESS, _stream->init()); _reader = new (std::nothrow) RunLengthIntegerReader(_stream, false); - ASSERT_TRUE(_reader != nullptr); + EXPECT_TRUE(_reader != nullptr); } RunLengthIntegerReader* _reader; @@ -87,47 +87,47 @@ public: TEST_F(TestRunLengthUnsignInteger, ReadWriteOneInteger) { // write data - ASSERT_EQ(OLAP_SUCCESS, _writer->write(100)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(100)); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 100); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 100); - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, ReadWriteMultiInteger) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, seek) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } PositionEntryWriter index_entry; @@ -138,7 +138,7 @@ TEST_F(TestRunLengthUnsignInteger, seek) { _writer->write(109); _writer->write(110); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); @@ -151,140 +151,140 @@ TEST_F(TestRunLengthUnsignInteger, seek) { PositionProvider position(&entry); _reader->seek(&position); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 107); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 108); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 109); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 110); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 107); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 108); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 109); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 110); } TEST_F(TestRunLengthUnsignInteger, skip) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); _reader->skip(2); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 105); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 106); - ASSERT_NE(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 105); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 106); + EXPECT_NE(OLAP_SUCCESS, _reader->next(&value)); } TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding) { // write data int64_t write_data[] = {100, 100, 100, 100}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding2) { // write data int64_t write_data[] = {876012345678912, 876012345678912, 876012345678912, 876012345678912}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, ShortRepeatEncoding3) { // write data int64_t write_data[] = {876012345678912}; for (int32_t i = 0; i < 1; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 1; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, DirectEncoding) { // write data int64_t write_data[] = {1703, 6054, 8760, 902}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, DirectEncoding2) { // write data int64_t write_data[] = {1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8}; for (int32_t i = 0; i < 10; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 10; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding1) { @@ -293,21 +293,21 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding1) { 1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, 90982, 9, 223234, 5, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 20; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding2) { @@ -316,21 +316,21 @@ TEST_F(TestRunLengthUnsignInteger, PatchedBaseEncoding2) { 1703, 6054, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, 90982, 9, 223234, 5, 876012345678912, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 20; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } class TestRunLengthSignInteger : public testing::Test { @@ -340,12 +340,12 @@ public: virtual ~TestRunLengthSignInteger() {} virtual void SetUp() { - ASSERT_EQ(system("mkdir -p ./ut_dir"), 0); - ASSERT_EQ(system("rm ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); + EXPECT_EQ(system("rm ./ut_dir/tmp_file"), 0); _out_stream = new (std::nothrow) OutStream(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, nullptr); - ASSERT_TRUE(_out_stream != nullptr); + EXPECT_TRUE(_out_stream != nullptr); _writer = new (std::nothrow) RunLengthIntegerWriter(_out_stream, true); - ASSERT_TRUE(_writer != nullptr); + EXPECT_TRUE(_writer != nullptr); } virtual void TearDown() { @@ -357,26 +357,26 @@ public: } void CreateReader() { - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); _out_stream->write_to_file(&helper, 0); helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode(_file_path.c_str(), O_RDONLY, S_IRUSR | S_IWUSR)); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); _stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, 0, helper.length(), nullptr, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE, &_stats); - ASSERT_EQ(OLAP_SUCCESS, _stream->init()); + EXPECT_EQ(OLAP_SUCCESS, _stream->init()); _reader = new (std::nothrow) RunLengthIntegerReader(_stream, true); - ASSERT_TRUE(_reader != nullptr); + EXPECT_TRUE(_reader != nullptr); } RunLengthIntegerReader* _reader; @@ -391,63 +391,63 @@ public: TEST_F(TestRunLengthSignInteger, ReadWriteOneInteger) { // write data - ASSERT_EQ(OLAP_SUCCESS, _writer->write(100)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(100)); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 100); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 100); - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, ReadWriteOneInteger2) { // write data - ASSERT_EQ(OLAP_SUCCESS, _writer->write(1234567800)); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(1234567800)); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 1234567800); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 1234567800); - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, ReadWriteMultiInteger) { // write data int64_t write_data[] = {100, 101, 104, 107}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, seek) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } PositionEntryWriter index_entry; @@ -458,7 +458,7 @@ TEST_F(TestRunLengthSignInteger, seek) { _writer->write(109); _writer->write(110); - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); @@ -471,95 +471,95 @@ TEST_F(TestRunLengthSignInteger, seek) { PositionProvider position(&entry); _reader->seek(&position); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 107); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 108); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 109); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 110); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 107); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 108); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 109); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 110); } TEST_F(TestRunLengthSignInteger, skip) { // write data int64_t write_data[] = {100, 102, 105, 106}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); _reader->skip(2); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 105); - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, 106); - ASSERT_NE(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 105); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, 106); + EXPECT_NE(OLAP_SUCCESS, _reader->next(&value)); } TEST_F(TestRunLengthSignInteger, ShortRepeatEncoding) { // write data int64_t write_data[] = {-100, -100, -100, -100}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, DirectEncoding) { // write data int64_t write_data[] = {-1703, -6054, -8760, -902}; for (int32_t i = 0; i < 4; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 4; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthUnsignInteger, ReadWriteMassInteger) { // write data for (int64_t i = 0; i < 100000; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(i)); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(i)); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int64_t i = 0; i < 100000; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, i); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, i); } } @@ -569,21 +569,21 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding1) { 1703, 6054, -876012345678912, 902, 9292, 184932, 873624, 827364, 999, 8, 1, 3323, 432232523, -90982, 9, 223234, 5, 44, 5, 3}; for (int32_t i = 0; i < 20; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 20; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding2) { @@ -592,21 +592,21 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding2) { -1703, -6054, -876012345678912, -902, -9292, -184932, -873624, -827364, -999, -8, -1, -3323, -432232523, -90982, -9, -223234, -5, -44, -5, -3}; for (int32_t i = 0; i < 20; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 20; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } // case for T in [if ((base & mask) != 0)] @@ -616,21 +616,21 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding3) { 1703, 6054, 876012345678912, 902, 9292, 184932, 873624, 827364, 999, 888, -300, 3323, 432232523, -90982, 450, 223234, 690, 444, 555, 333}; for (int32_t i = 0; i < 20; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 20; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } // test fo gap > 255 @@ -919,21 +919,21 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding4) { 876012345678912}; for (int32_t i = 0; i < 281; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 281; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } // test for [if (max_gap == 511)] @@ -994,21 +994,21 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding5) { 3323, 876012345678912}; for (int32_t i = 0; i < 512; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 512; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } // this case use to test large negative number. @@ -1028,43 +1028,43 @@ TEST_F(TestRunLengthSignInteger, PatchedBaseEncoding6) { -15605417571528704, -15605417571528704, -13322895849418752, -13322895849418752, -15605417571528704, -13322895849418752}; for (int32_t i = 0; i < 30; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 30; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows1) { // write data int64_t write_data[] = {4513343538618202711, 2911390882471569739, -9181829309989854913}; for (int32_t i = 0; i < 3; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 3; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows2) { @@ -1459,29 +1459,21 @@ TEST_F(TestRunLengthSignInteger, DirectEncodingForDeltaOverflows2) { 9223372036854775807}; for (int32_t i = 0; i < 388; i++) { - ASSERT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); + EXPECT_EQ(OLAP_SUCCESS, _writer->write(write_data[i])); } - ASSERT_EQ(OLAP_SUCCESS, _writer->flush()); + EXPECT_EQ(OLAP_SUCCESS, _writer->flush()); // read data CreateReader(); for (int32_t i = 0; i < 388; i++) { - ASSERT_TRUE(_reader->has_next()); + EXPECT_TRUE(_reader->has_next()); int64_t value = 0; - ASSERT_EQ(OLAP_SUCCESS, _reader->next(&value)); - ASSERT_EQ(value, write_data[i]); + EXPECT_EQ(OLAP_SUCCESS, _reader->next(&value)); + EXPECT_EQ(value, write_data[i]); } - ASSERT_FALSE(_reader->has_next()); + EXPECT_FALSE(_reader->has_next()); } } // namespace doris - -int main(int argc, char** argv) { - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/schema_change_test.cpp b/be/test/olap/schema_change_test.cpp index f5b88d7b2e..c3a4a7fb8f 100644 --- a/be/test/olap/schema_change_test.cpp +++ b/be/test/olap/schema_change_test.cpp @@ -59,7 +59,7 @@ public: _offsets.push_back(0); _stream_factory = new (std::nothrow) OutStreamFactory(COMPRESS_LZ4, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE); - ASSERT_TRUE(_stream_factory != nullptr); + EXPECT_TRUE(_stream_factory != nullptr); config::column_dictionary_key_ratio_threshold = 30; config::column_dictionary_key_size_threshold = 1000; } @@ -85,8 +85,8 @@ public: void create_column_writer(const TabletSchema& tablet_schema) { _column_writer = ColumnWriter::create(0, tablet_schema, _stream_factory, 1024, BLOOM_FILTER_DEFAULT_FPP); - ASSERT_TRUE(_column_writer != nullptr); - ASSERT_EQ(_column_writer->init(), OLAP_SUCCESS); + EXPECT_TRUE(_column_writer != nullptr); + EXPECT_EQ(_column_writer->init(), OLAP_SUCCESS); } void create_column_reader(const TabletSchema& tablet_schema) { @@ -107,12 +107,12 @@ public: _column_reader = ColumnReader::create(0, tablet_schema, included, segment_included, encodings); - ASSERT_TRUE(_column_reader != nullptr); + EXPECT_TRUE(_column_reader != nullptr); - ASSERT_EQ(system("mkdir -p ./ut_dir"), 0); - ASSERT_EQ(system("rm -f ./ut_dir/tmp_file"), 0); + EXPECT_EQ(system("mkdir -p ./ut_dir"), 0); + EXPECT_EQ(system("rm -f ./ut_dir/tmp_file"), 0); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode("./ut_dir/tmp_file", O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR)); std::vector off; @@ -142,10 +142,10 @@ public: } else if (stream_name.kind() == StreamInfoMessage::LENGTH) { buffers = &_length_buffers; } else { - ASSERT_TRUE(false); + EXPECT_TRUE(false); } - ASSERT_TRUE(buffers != nullptr); + EXPECT_TRUE(buffers != nullptr); off.push_back(helper.tell()); out_stream->write_to_file(&helper, 0); length.push_back(out_stream->get_stream_length()); @@ -154,13 +154,13 @@ public: } helper.close(); - ASSERT_EQ(OLAP_SUCCESS, + EXPECT_EQ(OLAP_SUCCESS, helper.open_with_mode("./ut_dir/tmp_file", O_RDONLY, S_IRUSR | S_IWUSR)); SAFE_DELETE(_shared_buffer); _shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead)); - ASSERT_TRUE(_shared_buffer != nullptr); + EXPECT_TRUE(_shared_buffer != nullptr); for (auto in_stream : _map_in_streams) { delete in_stream.second; @@ -171,11 +171,11 @@ public: ReadOnlyFileStream* in_stream = new (std::nothrow) ReadOnlyFileStream(&helper, &_shared_buffer, off[i], length[i], lz4_decompress, buffer_size[i], &_stats); - ASSERT_EQ(OLAP_SUCCESS, in_stream->init()); + EXPECT_EQ(OLAP_SUCCESS, in_stream->init()); _map_in_streams[name[i]] = in_stream; } - ASSERT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), + EXPECT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats), OLAP_SUCCESS); } @@ -195,7 +195,7 @@ public: } void create_and_save_last_position() { - ASSERT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS); } template @@ -216,9 +216,9 @@ public: write_row.set_field_content(0, reinterpret_cast(&val), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); helper.close(); TabletSchema dst_tablet_schema; @@ -229,19 +229,19 @@ public: read_row.init(dst_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); - ASSERT_EQ(st, expected_st); + EXPECT_EQ(st, expected_st); if (st == OLAP_SUCCESS) { std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_TRUE(dst_str.compare(0, expected_val.size(), expected_val) == 0); + EXPECT_TRUE(dst_str.compare(0, expected_val.size(), expected_val) == 0); } const auto* tp = get_scalar_type_info(); st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); } void test_convert_from_varchar(const std::string& type_name, int type_size, @@ -260,9 +260,9 @@ public: write_row.set_field_content(0, reinterpret_cast(&normal_str), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); helper.close(); TabletSchema converted_tablet_schema; @@ -273,19 +273,19 @@ public: read_row.init(converted_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); - ASSERT_EQ(st, expected_st); + EXPECT_EQ(st, expected_st); if (st == OLAP_SUCCESS) { std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_TRUE(dst_str.compare(0, value.size(), value) == 0); + EXPECT_TRUE(dst_str.compare(0, value.size(), value) == 0); } const auto* tp = get_scalar_type_info(); st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); } ColumnWriter* _column_writer; @@ -326,16 +326,16 @@ TEST_F(TestColumn, ConvertFloatToDouble) { write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); value = 3.234; write_row.set_field_content(0, reinterpret_cast(&value), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data TabletSchema convert_tablet_schema; @@ -344,7 +344,7 @@ TEST_F(TestColumn, ConvertFloatToDouble) { RowCursor read_row; read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); //float val1 = *reinterpret_cast(read_row.cell_ptr(0)); @@ -355,12 +355,12 @@ TEST_F(TestColumn, ConvertFloatToDouble) { sprintf(buf, "%f", val2); char* tg; double v2 = strtod(buf, &tg); - ASSERT_EQ(v2, 1.234); + EXPECT_EQ(v2, 1.234); //test not support type const auto* tp = get_scalar_type_info(); OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); } TEST_F(TestColumn, ConvertDatetimeToDate) { @@ -382,10 +382,10 @@ TEST_F(TestColumn, ConvertDatetimeToDate) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // read data TabletSchema convert_tablet_schema; @@ -395,16 +395,16 @@ TEST_F(TestColumn, ConvertDatetimeToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_TRUE(strncmp(dest_string.c_str(), "2019-11-25", strlen("2019-11-25")) == 0); + EXPECT_TRUE(strncmp(dest_string.c_str(), "2019-11-25", strlen("2019-11-25")) == 0); //test not support type const auto* tp = get_scalar_type_info(); OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); } TEST_F(TestColumn, ConvertDateToDatetime) { @@ -427,10 +427,10 @@ TEST_F(TestColumn, ConvertDateToDatetime) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header_message; - ASSERT_EQ(_column_writer->finalize(&header_message), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header_message), OLAP_SUCCESS); TabletSchema convert_tablet_schema; set_tablet_schema("DateTimeColumn", "DATETIME", "REPLACE", 8, false, false, @@ -439,17 +439,17 @@ TEST_F(TestColumn, ConvertDateToDatetime) { RowCursor read_row; read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.set_field_content(0, data, _mem_pool.get()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_TRUE(dest_string.compare("2019-12-04 00:00:00") == 0); + EXPECT_TRUE(dest_string.compare("2019-12-04 00:00:00") == 0); //test not support type const auto* tp = get_scalar_type_info(); OLAPStatus st = read_row.convert_from(0, data, tp, _mem_pool.get()); - ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); } TEST_F(TestColumn, ConvertIntToDate) { @@ -469,10 +469,10 @@ TEST_F(TestColumn, ConvertIntToDate) { write_row.set_field_content(0, reinterpret_cast(&time_val), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); TabletSchema convert_tablet_schema; set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema); @@ -482,16 +482,16 @@ TEST_F(TestColumn, ConvertIntToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_TRUE(strncmp(dest_string.c_str(), "2019-12-05", strlen("2019-12-05")) == 0); + EXPECT_TRUE(strncmp(dest_string.c_str(), "2019-12-05", strlen("2019-12-05")) == 0); //test not support type const auto* tp = get_scalar_type_info(); OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); + EXPECT_TRUE(st == OLAP_ERR_INVALID_SCHEMA); } TEST_F(TestColumn, ConvertVarcharToDate) { @@ -516,10 +516,10 @@ TEST_F(TestColumn, ConvertVarcharToDate) { write_row.set_field_content(0, reinterpret_cast(&src_str), _mem_pool.get()); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); // because file_helper is reused in this case, we should close it. helper.close(); @@ -530,12 +530,11 @@ TEST_F(TestColumn, ConvertVarcharToDate) { read_row.init(convert_tablet_schema); _col_vector.reset(new ColumnVector()); - ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); + EXPECT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS); char* data = reinterpret_cast(_col_vector->col_data()); - read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), - _mem_pool.get()); + read_row.convert_from(0, data, write_row.column_schema(0)->type_info(), _mem_pool.get()); std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0)); - ASSERT_EQ(expected_val, dst_str); + EXPECT_EQ(expected_val, dst_str); } helper.close(); TabletSchema convert_tablet_schema; @@ -547,7 +546,7 @@ TEST_F(TestColumn, ConvertVarcharToDate) { //test not support type const auto* tp = get_scalar_type_info(); OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp, _mem_pool.get()); - ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA); + EXPECT_EQ(st, OLAP_ERR_INVALID_SCHEMA); } TEST_F(TestColumn, ConvertVarcharToTinyInt1) { @@ -944,9 +943,9 @@ TEST_F(TestColumn, ConvertIntToBitmap) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; @@ -997,7 +996,7 @@ TEST_F(TestColumn, ConvertIntToBitmap) { auto dst_slice = reinterpret_cast(mv_row_cursor.cell_ptr(1)); BitmapValue bitmapValue(dst_slice->data); - ASSERT_EQ(bitmapValue.cardinality(), 1); + EXPECT_EQ(bitmapValue.cardinality(), 1); } TEST_F(TestColumn, ConvertCharToHLL) { @@ -1027,9 +1026,9 @@ TEST_F(TestColumn, ConvertCharToHLL) { write_row.from_tuple(tuple); block.set_row(0, write_row); block.finalize(1); - ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; @@ -1080,7 +1079,7 @@ TEST_F(TestColumn, ConvertCharToHLL) { auto dst_slice = reinterpret_cast(mv_row_cursor.cell_ptr(1)); HyperLogLog hll(*dst_slice); - ASSERT_EQ(hll.estimate_cardinality(), 1); + EXPECT_EQ(hll.estimate_cardinality(), 1); } TEST_F(TestColumn, ConvertCharToCount) { @@ -1110,7 +1109,7 @@ TEST_F(TestColumn, ConvertCharToCount) { block.finalize(1); ColumnDataHeaderMessage header; - ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); + EXPECT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS); //Materialized View tablet schema TabletSchemaPB mv_tablet_schema_pb; @@ -1160,20 +1159,6 @@ TEST_F(TestColumn, ConvertCharToCount) { mutable_block.get_row(0, &mv_row_cursor); auto dst = mv_row_cursor.cell_ptr(1); - ASSERT_EQ(*(int64_t*)dst, 1); + EXPECT_EQ(*(int64_t*)dst, 1); } } // namespace doris - -int main(int argc, char** argv) { - std::string conf_file = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conf_file.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - doris::MemInfo::init(); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/olap/selection_vector_test.cpp b/be/test/olap/selection_vector_test.cpp index 969be4e0d7..59abfe5fdf 100644 --- a/be/test/olap/selection_vector_test.cpp +++ b/be/test/olap/selection_vector_test.cpp @@ -25,22 +25,17 @@ class SelectionVectorTest : public testing::Test {}; TEST_F(SelectionVectorTest, Normal) { SelectionVector sel_vel(10); - ASSERT_EQ(10, sel_vel.nrows()); + EXPECT_EQ(10, sel_vel.nrows()); sel_vel.set_all_true(); - ASSERT_EQ(" 0: 11111111 11 \n", sel_vel.to_string()); + EXPECT_EQ(" 0: 11111111 11 \n", sel_vel.to_string()); sel_vel.set_all_false(); - ASSERT_EQ(" 0: 00000000 00 \n", sel_vel.to_string()); + EXPECT_EQ(" 0: 00000000 00 \n", sel_vel.to_string()); sel_vel.set_row_selected(7); - ASSERT_TRUE(sel_vel.is_row_selected(7)); - ASSERT_TRUE(sel_vel.any_selected()); - ASSERT_EQ(" 0: 00000001 00 \n", sel_vel.to_string()); + EXPECT_TRUE(sel_vel.is_row_selected(7)); + EXPECT_TRUE(sel_vel.any_selected()); + EXPECT_EQ(" 0: 00000001 00 \n", sel_vel.to_string()); sel_vel.clear_bit(7); - ASSERT_EQ(" 0: 00000000 00 \n", sel_vel.to_string()); + EXPECT_EQ(" 0: 00000000 00 \n", sel_vel.to_string()); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/serialize_test.cpp b/be/test/olap/serialize_test.cpp index c52bab7387..65a13fe245 100644 --- a/be/test/olap/serialize_test.cpp +++ b/be/test/olap/serialize_test.cpp @@ -29,119 +29,119 @@ public: }; TEST_F(SerializeTest, get_closet_fixed_bits) { - ASSERT_EQ(1, get_closet_fixed_bits(0)); + EXPECT_EQ(1, get_closet_fixed_bits(0)); for (int i = 1; i <= 24; ++i) { - ASSERT_EQ(i, get_closet_fixed_bits(i)); + EXPECT_EQ(i, get_closet_fixed_bits(i)); } for (int i = 25; i <= 26; ++i) { - ASSERT_EQ(26, get_closet_fixed_bits(i)); + EXPECT_EQ(26, get_closet_fixed_bits(i)); } for (int i = 27; i <= 28; ++i) { - ASSERT_EQ(28, get_closet_fixed_bits(i)); + EXPECT_EQ(28, get_closet_fixed_bits(i)); } for (int i = 29; i <= 30; ++i) { - ASSERT_EQ(30, get_closet_fixed_bits(i)); + EXPECT_EQ(30, get_closet_fixed_bits(i)); } for (int i = 31; i <= 32; ++i) { - ASSERT_EQ(32, get_closet_fixed_bits(i)); + EXPECT_EQ(32, get_closet_fixed_bits(i)); } for (int i = 33; i <= 40; ++i) { - ASSERT_EQ(40, get_closet_fixed_bits(i)); + EXPECT_EQ(40, get_closet_fixed_bits(i)); } for (int i = 41; i <= 48; ++i) { - ASSERT_EQ(48, get_closet_fixed_bits(i)); + EXPECT_EQ(48, get_closet_fixed_bits(i)); } for (int i = 49; i <= 56; ++i) { - ASSERT_EQ(56, get_closet_fixed_bits(i)); + EXPECT_EQ(56, get_closet_fixed_bits(i)); } for (int i = 57; i <= 64; ++i) { - ASSERT_EQ(64, get_closet_fixed_bits(i)); + EXPECT_EQ(64, get_closet_fixed_bits(i)); } } TEST_F(SerializeTest, find_closet_num_bits) { - ASSERT_EQ(1, find_closet_num_bits(0)); + EXPECT_EQ(1, find_closet_num_bits(0)); for (int i = 1; i <= 24; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(i, find_closet_num_bits(val)); + EXPECT_EQ(i, find_closet_num_bits(val)); } for (int i = 25; i <= 26; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(26, find_closet_num_bits(val)); + EXPECT_EQ(26, find_closet_num_bits(val)); } for (int i = 27; i <= 28; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(28, find_closet_num_bits(val)); + EXPECT_EQ(28, find_closet_num_bits(val)); } for (int i = 29; i <= 30; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(30, find_closet_num_bits(val)); + EXPECT_EQ(30, find_closet_num_bits(val)); } for (int i = 31; i <= 32; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(32, find_closet_num_bits(val)); + EXPECT_EQ(32, find_closet_num_bits(val)); } for (int i = 33; i <= 40; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(40, find_closet_num_bits(val)); + EXPECT_EQ(40, find_closet_num_bits(val)); } for (int i = 41; i <= 48; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(48, find_closet_num_bits(val)); + EXPECT_EQ(48, find_closet_num_bits(val)); } for (int i = 49; i <= 56; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(56, find_closet_num_bits(val)); + EXPECT_EQ(56, find_closet_num_bits(val)); } for (int i = 57; i <= 64; ++i) { uint64_t val = (1l << (i - 1)); - ASSERT_EQ(64, find_closet_num_bits(val)); + EXPECT_EQ(64, find_closet_num_bits(val)); } } TEST_F(SerializeTest, encode_bit_width) { - ASSERT_EQ(ONE, encode_bit_width(0)); + EXPECT_EQ(ONE, encode_bit_width(0)); for (int i = 1; i <= 24; ++i) { - ASSERT_EQ(i - 1, encode_bit_width(i)); + EXPECT_EQ(i - 1, encode_bit_width(i)); } for (int i = 25; i <= 26; ++i) { - ASSERT_EQ(TWENTYSIX, encode_bit_width(i)); + EXPECT_EQ(TWENTYSIX, encode_bit_width(i)); } for (int i = 27; i <= 28; ++i) { - ASSERT_EQ(TWENTYEIGHT, encode_bit_width(i)); + EXPECT_EQ(TWENTYEIGHT, encode_bit_width(i)); } for (int i = 29; i <= 30; ++i) { - ASSERT_EQ(THIRTY, encode_bit_width(i)); + EXPECT_EQ(THIRTY, encode_bit_width(i)); } for (int i = 31; i <= 32; ++i) { - ASSERT_EQ(THIRTYTWO, encode_bit_width(i)); + EXPECT_EQ(THIRTYTWO, encode_bit_width(i)); } for (int i = 33; i <= 40; ++i) { - ASSERT_EQ(FORTY, encode_bit_width(i)); + EXPECT_EQ(FORTY, encode_bit_width(i)); } for (int i = 41; i <= 48; ++i) { - ASSERT_EQ(FORTYEIGHT, encode_bit_width(i)); + EXPECT_EQ(FORTYEIGHT, encode_bit_width(i)); } for (int i = 49; i <= 56; ++i) { - ASSERT_EQ(FIFTYSIX, encode_bit_width(i)); + EXPECT_EQ(FIFTYSIX, encode_bit_width(i)); } for (int i = 57; i <= 64; ++i) { - ASSERT_EQ(SIXTYFOUR, encode_bit_width(i)); + EXPECT_EQ(SIXTYFOUR, encode_bit_width(i)); } } TEST_F(SerializeTest, decode_bit_width) { for (int i = 0; i <= TWENTYFOUR; ++i) { - ASSERT_EQ(i + 1, decode_bit_width(i)); + EXPECT_EQ(i + 1, decode_bit_width(i)); } - ASSERT_EQ(26, decode_bit_width(TWENTYSIX)); - ASSERT_EQ(28, decode_bit_width(TWENTYEIGHT)); - ASSERT_EQ(30, decode_bit_width(THIRTY)); - ASSERT_EQ(32, decode_bit_width(THIRTYTWO)); - ASSERT_EQ(40, decode_bit_width(FORTY)); - ASSERT_EQ(48, decode_bit_width(FORTYEIGHT)); - ASSERT_EQ(56, decode_bit_width(FIFTYSIX)); - ASSERT_EQ(64, decode_bit_width(SIXTYFOUR)); + EXPECT_EQ(26, decode_bit_width(TWENTYSIX)); + EXPECT_EQ(28, decode_bit_width(TWENTYEIGHT)); + EXPECT_EQ(30, decode_bit_width(THIRTY)); + EXPECT_EQ(32, decode_bit_width(THIRTYTWO)); + EXPECT_EQ(40, decode_bit_width(FORTY)); + EXPECT_EQ(48, decode_bit_width(FORTYEIGHT)); + EXPECT_EQ(56, decode_bit_width(FIFTYSIX)); + EXPECT_EQ(64, decode_bit_width(SIXTYFOUR)); } TEST_F(SerializeTest, percentile_bits) { @@ -154,10 +154,10 @@ TEST_F(SerializeTest, percentile_bits) { for (int i = 5; i < 100; ++i) { data[i] = 1; } - ASSERT_EQ(0, percentile_bits(data, 100, 0.0)); - ASSERT_EQ(1, percentile_bits(data, 100, 0.95)); - ASSERT_EQ(64, percentile_bits(data, 100, 0.99)); - ASSERT_EQ(64, percentile_bits(data, 100, 1.0)); + EXPECT_EQ(0, percentile_bits(data, 100, 0.0)); + EXPECT_EQ(1, percentile_bits(data, 100, 0.95)); + EXPECT_EQ(64, percentile_bits(data, 100, 0.99)); + EXPECT_EQ(64, percentile_bits(data, 100, 1.0)); } { for (int i = 0; i < 11; ++i) { @@ -166,9 +166,9 @@ TEST_F(SerializeTest, percentile_bits) { for (int i = 11; i < 100; ++i) { data[i] = 1; } - ASSERT_EQ(0, percentile_bits(data, 100, 0.0)); - ASSERT_EQ(1, percentile_bits(data, 100, 0.8)); - ASSERT_EQ(28, percentile_bits(data, 100, 0.9)); + EXPECT_EQ(0, percentile_bits(data, 100, 0.0)); + EXPECT_EQ(1, percentile_bits(data, 100, 0.8)); + EXPECT_EQ(28, percentile_bits(data, 100, 0.9)); } { for (int i = 0; i < 11; ++i) { @@ -177,10 +177,10 @@ TEST_F(SerializeTest, percentile_bits) { for (int i = 11; i < 100; ++i) { data[i] = 0; } - ASSERT_EQ(0, percentile_bits(data, 100, 0.0)); - ASSERT_EQ(1, percentile_bits(data, 100, 0.1)); - ASSERT_EQ(1, percentile_bits(data, 100, 0.8)); - ASSERT_EQ(28, percentile_bits(data, 100, 0.9)); + EXPECT_EQ(0, percentile_bits(data, 100, 0.0)); + EXPECT_EQ(1, percentile_bits(data, 100, 0.1)); + EXPECT_EQ(1, percentile_bits(data, 100, 0.8)); + EXPECT_EQ(28, percentile_bits(data, 100, 0.9)); } } @@ -196,10 +196,10 @@ TEST_F(SerializeTest, new_percentile_bits) { } uint16_t hists[65]; compute_hists(data, 100, hists); - ASSERT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); - ASSERT_EQ(1, percentile_bits_with_hist(hists, 100, 0.95)); - ASSERT_EQ(64, percentile_bits_with_hist(hists, 100, 0.99)); - ASSERT_EQ(64, percentile_bits_with_hist(hists, 100, 1.0)); + EXPECT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); + EXPECT_EQ(1, percentile_bits_with_hist(hists, 100, 0.95)); + EXPECT_EQ(64, percentile_bits_with_hist(hists, 100, 0.99)); + EXPECT_EQ(64, percentile_bits_with_hist(hists, 100, 1.0)); } { for (int i = 0; i < 11; ++i) { @@ -210,9 +210,9 @@ TEST_F(SerializeTest, new_percentile_bits) { } uint16_t hists[65]; compute_hists(data, 100, hists); - ASSERT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); - ASSERT_EQ(1, percentile_bits_with_hist(hists, 100, 0.8)); - ASSERT_EQ(28, percentile_bits_with_hist(hists, 100, 0.9)); + EXPECT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); + EXPECT_EQ(1, percentile_bits_with_hist(hists, 100, 0.8)); + EXPECT_EQ(28, percentile_bits_with_hist(hists, 100, 0.9)); } { for (int i = 0; i < 11; ++i) { @@ -223,17 +223,12 @@ TEST_F(SerializeTest, new_percentile_bits) { } uint16_t hists[65]; compute_hists(data, 100, hists); - ASSERT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); - ASSERT_EQ(1, percentile_bits_with_hist(hists, 100, 0.1)); - ASSERT_EQ(1, percentile_bits_with_hist(hists, 100, 0.8)); - ASSERT_EQ(28, percentile_bits_with_hist(hists, 100, 0.9)); + EXPECT_EQ(0, percentile_bits_with_hist(hists, 100, 0.0)); + EXPECT_EQ(1, percentile_bits_with_hist(hists, 100, 0.1)); + EXPECT_EQ(1, percentile_bits_with_hist(hists, 100, 0.8)); + EXPECT_EQ(28, percentile_bits_with_hist(hists, 100, 0.9)); } } } // namespace ser } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/short_key_index_test.cpp b/be/test/olap/short_key_index_test.cpp index 3db3890574..7f2e7bb20a 100644 --- a/be/test/olap/short_key_index_test.cpp +++ b/be/test/olap/short_key_index_test.cpp @@ -42,9 +42,9 @@ TEST_F(ShortKeyIndexTest, builder) { std::vector slices; segment_v2::PageFooterPB footer; auto st = builder.finalize(9000 * 1024, &slices, &footer); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(segment_v2::SHORT_KEY_PAGE, footer.type()); - ASSERT_EQ(num_items, footer.short_key_page_footer().num_items()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(segment_v2::SHORT_KEY_PAGE, footer.type()); + EXPECT_EQ(num_items, footer.short_key_page_footer().num_items()); std::string buf; for (auto& slice : slices) { @@ -53,43 +53,43 @@ TEST_F(ShortKeyIndexTest, builder) { ShortKeyIndexDecoder decoder; st = decoder.parse(buf, footer.short_key_page_footer()); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); // find 1499 { auto iter = decoder.lower_bound("1499"); - ASSERT_TRUE(iter.valid()); - ASSERT_STREQ("1500", (*iter).to_string().c_str()); + EXPECT_TRUE(iter.valid()); + EXPECT_STREQ("1500", (*iter).to_string().c_str()); } // find 1500 lower bound { auto iter = decoder.lower_bound("1500"); - ASSERT_TRUE(iter.valid()); - ASSERT_STREQ("1500", (*iter).to_string().c_str()); + EXPECT_TRUE(iter.valid()); + EXPECT_STREQ("1500", (*iter).to_string().c_str()); } // find 1500 upper bound { auto iter = decoder.upper_bound("1500"); - ASSERT_TRUE(iter.valid()); - ASSERT_STREQ("1502", (*iter).to_string().c_str()); + EXPECT_TRUE(iter.valid()); + EXPECT_STREQ("1502", (*iter).to_string().c_str()); } // find prefix "87" { auto iter = decoder.lower_bound("87"); - ASSERT_TRUE(iter.valid()); - ASSERT_STREQ("8700", (*iter).to_string().c_str()); + EXPECT_TRUE(iter.valid()); + EXPECT_STREQ("8700", (*iter).to_string().c_str()); } // find prefix "87" { auto iter = decoder.upper_bound("87"); - ASSERT_TRUE(iter.valid()); - ASSERT_STREQ("8700", (*iter).to_string().c_str()); + EXPECT_TRUE(iter.valid()); + EXPECT_STREQ("8700", (*iter).to_string().c_str()); } // find prefix "9999" { auto iter = decoder.upper_bound("9999"); - ASSERT_FALSE(iter.valid()); + EXPECT_FALSE(iter.valid()); } } @@ -123,7 +123,7 @@ TEST_F(ShortKeyIndexTest, encode) { std::string buf; encode_key_with_padding(&buf, row, 3, true); // should be \x02\x80\x00\x30\x39\x02\x80\x00\xD4\x31\x00 - ASSERT_STREQ("0280003039028000D43100", hexdump(buf.c_str(), buf.size()).c_str()); + EXPECT_STREQ("0280003039028000D43100", hexdump(buf.c_str(), buf.size()).c_str()); } // test with null { @@ -142,22 +142,17 @@ TEST_F(ShortKeyIndexTest, encode) { std::string buf; encode_key_with_padding(&buf, row, 3, false); // should be \x02\x80\x00\xD4\x31\x01\xff - ASSERT_STREQ("028000D43101FF", hexdump(buf.c_str(), buf.size()).c_str()); + EXPECT_STREQ("028000D43101FF", hexdump(buf.c_str(), buf.size()).c_str()); } // encode key { std::string buf; encode_key(&buf, row, 2); // should be \x02\x80\x00\xD4\x31\x01 - ASSERT_STREQ("028000D43101", hexdump(buf.c_str(), buf.size()).c_str()); + EXPECT_STREQ("028000D43101", hexdump(buf.c_str(), buf.size()).c_str()); } } } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/skiplist_test.cpp b/be/test/olap/skiplist_test.cpp index 7c76ac5e3b..76d670d27c 100644 --- a/be/test/olap/skiplist_test.cpp +++ b/be/test/olap/skiplist_test.cpp @@ -25,7 +25,7 @@ #include "olap/schema.h" #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/condition_variable.h" #include "util/hash_util.hpp" #include "util/mutex.h" @@ -57,16 +57,16 @@ TEST_F(SkipTest, Empty) { TestComparator* cmp = new TestComparator(); SkipList list(cmp, mem_pool.get(), false); - ASSERT_TRUE(!list.Contains(10)); + EXPECT_TRUE(!list.Contains(10)); SkipList::Iterator iter(&list); - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); iter.SeekToFirst(); - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); iter.Seek(100); - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); iter.SeekToLast(); - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); delete cmp; } @@ -90,28 +90,28 @@ TEST_F(SkipTest, InsertAndLookup) { for (int i = 0; i < R; i++) { if (list.Contains(i)) { - ASSERT_EQ(keys.count(i), 1); + EXPECT_EQ(keys.count(i), 1); } else { - ASSERT_EQ(keys.count(i), 0); + EXPECT_EQ(keys.count(i), 0); } } // Simple iterator tests { SkipList::Iterator iter(&list); - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); iter.Seek(0); - ASSERT_TRUE(iter.Valid()); - ASSERT_EQ(*(keys.begin()), iter.key()); + EXPECT_TRUE(iter.Valid()); + EXPECT_EQ(*(keys.begin()), iter.key()); iter.SeekToFirst(); - ASSERT_TRUE(iter.Valid()); - ASSERT_EQ(*(keys.begin()), iter.key()); + EXPECT_TRUE(iter.Valid()); + EXPECT_EQ(*(keys.begin()), iter.key()); iter.SeekToLast(); - ASSERT_TRUE(iter.Valid()); - ASSERT_EQ(*(keys.rbegin()), iter.key()); + EXPECT_TRUE(iter.Valid()); + EXPECT_EQ(*(keys.rbegin()), iter.key()); } // Forward iteration test @@ -123,11 +123,11 @@ TEST_F(SkipTest, InsertAndLookup) { std::set::iterator model_iter = keys.lower_bound(i); for (int j = 0; j < 3; j++) { if (model_iter == keys.end()) { - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); break; } else { - ASSERT_TRUE(iter.Valid()); - ASSERT_EQ(*model_iter, iter.key()); + EXPECT_TRUE(iter.Valid()); + EXPECT_EQ(*model_iter, iter.key()); ++model_iter; iter.Next(); } @@ -142,11 +142,11 @@ TEST_F(SkipTest, InsertAndLookup) { // Compare against model iterator for (std::set::reverse_iterator model_iter = keys.rbegin(); model_iter != keys.rend(); ++model_iter) { - ASSERT_TRUE(iter.Valid()); - ASSERT_EQ(*model_iter, iter.key()); + EXPECT_TRUE(iter.Valid()); + EXPECT_EQ(*model_iter, iter.key()); iter.Prev(); } - ASSERT_TRUE(!iter.Valid()); + EXPECT_TRUE(!iter.Valid()); } delete cmp; } @@ -167,18 +167,18 @@ TEST_F(SkipTest, InsertWithHintNoneDupModel) { Key key = rnd.Next() % R; bool is_exist = list.Find(key, &hint); if (keys.insert(key).second) { - ASSERT_FALSE(is_exist); + EXPECT_FALSE(is_exist); list.InsertWithHint(key, is_exist, &hint); } else { - ASSERT_TRUE(is_exist); + EXPECT_TRUE(is_exist); } } for (int i = 0; i < R; i++) { if (list.Contains(i)) { - ASSERT_EQ(keys.count(i), 1); + EXPECT_EQ(keys.count(i), 1); } else { - ASSERT_EQ(keys.count(i), 0); + EXPECT_EQ(keys.count(i), 0); } } delete cmp; @@ -273,7 +273,7 @@ public: _mem_pool(new MemPool(_mem_tracker.get())), _comparator(new TestComparator()), _list(_comparator.get(), _mem_pool.get(), false) {} - + // REQUIRES: External synchronization void write_step(Random* rnd) { const uint32_t k = rnd->Next() % K; @@ -300,18 +300,18 @@ public: current = make_key(K, 0); } else { current = iter.key(); - ASSERT_TRUE(is_valid_key(current)) << current; + EXPECT_TRUE(is_valid_key(current)) << current; } - ASSERT_LE(pos, current) << "should not go backwards"; + EXPECT_LE(pos, current) << "should not go backwards"; // Verify that everything in [pos,current) was not present in // initial_state. while (pos < current) { - ASSERT_LT(key(pos), K) << pos; + EXPECT_LT(key(pos), K) << pos; // Note that generation 0 is never inserted, so it is ok if // <*,0,*> is missing. - ASSERT_TRUE((gen(pos) == 0) || + EXPECT_TRUE((gen(pos) == 0) || (gen(pos) > static_cast(initial_state.get(key(pos))))) << "key: " << key(pos) << "; gen: " << gen(pos) << "; initgen: " << initial_state.get(key(pos)); @@ -425,9 +425,3 @@ TEST_F(SkipTest, Concurrent) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/storage_types_test.cpp b/be/test/olap/storage_types_test.cpp index 764d9b0b0a..36bb4aef98 100644 --- a/be/test/olap/storage_types_test.cpp +++ b/be/test/olap/storage_types_test.cpp @@ -35,36 +35,36 @@ template void common_test(typename TypeTraits::CppType src_val) { const auto* type = get_scalar_type_info(); - ASSERT_EQ(field_type, type->type()); - ASSERT_EQ(sizeof(src_val), type->size()); + EXPECT_EQ(field_type, type->type()); + EXPECT_EQ(sizeof(src_val), type->size()); { typename TypeTraits::CppType dst_val; auto tracker = std::make_shared(); MemPool pool(tracker.get()); type->deep_copy((char*)&dst_val, (char*)&src_val, &pool); - ASSERT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); } { typename TypeTraits::CppType dst_val; type->direct_copy((char*)&dst_val, (char*)&src_val); - ASSERT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); } // test min { typename TypeTraits::CppType dst_val; type->set_to_min((char*)&dst_val); - ASSERT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) > 0); + EXPECT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) > 0); } // test max { typename TypeTraits::CppType dst_val; type->set_to_max((char*)&dst_val); // NOTE: bool input is true, this will return 0 - ASSERT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) <= 0); + EXPECT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) <= 0); } } @@ -74,23 +74,23 @@ void test_char(Slice src_val) { field->_length = src_val.size; const auto* type = field->type_info(); - ASSERT_EQ(field->type(), fieldType); - ASSERT_EQ(sizeof(src_val), type->size()); + EXPECT_EQ(field->type(), fieldType); + EXPECT_EQ(sizeof(src_val), type->size()); { char buf[64]; Slice dst_val(buf, sizeof(buf)); auto tracker = std::make_shared(); MemPool pool(tracker.get()); type->deep_copy((char*)&dst_val, (char*)&src_val, &pool); - ASSERT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); } { char buf[64]; Slice dst_val(buf, sizeof(buf)); type->direct_copy((char*)&dst_val, (char*)&src_val); - ASSERT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, type->cmp((char*)&src_val, (char*)&dst_val)); } // test min { @@ -98,8 +98,8 @@ void test_char(Slice src_val) { Slice dst_val(buf, sizeof(buf)); field->set_to_min((char*)&dst_val); - ASSERT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) > 0); + EXPECT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) > 0); } // test max { @@ -107,8 +107,8 @@ void test_char(Slice src_val) { Slice dst_val(buf, sizeof(buf)); field->set_to_max((char*)&dst_val); - ASSERT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) < 0); + EXPECT_FALSE(type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(type->cmp((char*)&src_val, (char*)&dst_val) < 0); } delete field; } @@ -156,23 +156,23 @@ void common_test_array(CollectionValue src_val) { list_column.add_sub_column(item_column); const auto* array_type = dynamic_cast(get_type_info(&list_column)); - ASSERT_EQ(item_type, array_type->item_type_info()->type()); + EXPECT_EQ(item_type, array_type->item_type_info()->type()); { // test deep copy CollectionValue dst_val; auto tracker = std::make_shared(); MemPool pool(tracker.get()); array_type->deep_copy((char*)&dst_val, (char*)&src_val, &pool); - ASSERT_TRUE(array_type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, array_type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(array_type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, array_type->cmp((char*)&src_val, (char*)&dst_val)); } { // test direct copy bool null_signs[50]; uint8_t data[50]; CollectionValue dst_val(data, sizeof(null_signs), null_signs); array_type->direct_copy((char*)&dst_val, (char*)&src_val); - ASSERT_TRUE(array_type->equal((char*)&src_val, (char*)&dst_val)); - ASSERT_EQ(0, array_type->cmp((char*)&src_val, (char*)&dst_val)); + EXPECT_TRUE(array_type->equal((char*)&src_val, (char*)&dst_val)); + EXPECT_EQ(0, array_type->cmp((char*)&src_val, (char*)&dst_val)); } } @@ -221,8 +221,3 @@ TEST(ArrayTypeTest, copy_and_equal) { } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/stream_index_test.cpp b/be/test/olap/stream_index_test.cpp index 5c55226383..21d00cfe14 100644 --- a/be/test/olap/stream_index_test.cpp +++ b/be/test/olap/stream_index_test.cpp @@ -52,7 +52,7 @@ TEST_F(TestStreamIndex, index_write) { ColumnStatistics stat; stat.init(OLAP_FIELD_TYPE_INT, true); - ASSERT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); static const uint32_t loop = 10; uint32_t i = 0; @@ -70,22 +70,22 @@ TEST_F(TestStreamIndex, index_write) { // for statistics output_size += (sizeof(int) + 1) * 2 * loop; - ASSERT_EQ(output_size, writer.output_size()); + EXPECT_EQ(output_size, writer.output_size()); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i); - ASSERT_EQ(e.positions(1), i * 2); - ASSERT_EQ(e.positions(2), i * 3); + EXPECT_EQ(e.positions(0), i); + EXPECT_EQ(e.positions(1), i * 2); + EXPECT_EQ(e.positions(2), i * 3); } delete[] buffer; } @@ -122,18 +122,18 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i * 5); - ASSERT_EQ(e.positions(1), i * 6); - ASSERT_EQ(e.positions(2), i * 7); + EXPECT_EQ(e.positions(0), i * 5); + EXPECT_EQ(e.positions(1), i * 6); + EXPECT_EQ(e.positions(2), i * 7); } delete[] buffer; } @@ -164,20 +164,20 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i * 3); - ASSERT_EQ(e.positions(1), i * 4); - ASSERT_EQ(e.positions(2), i * 5); - ASSERT_EQ(e.positions(3), i * 6); - ASSERT_EQ(e.positions(4), i * 7); + EXPECT_EQ(e.positions(0), i * 3); + EXPECT_EQ(e.positions(1), i * 4); + EXPECT_EQ(e.positions(2), i * 5); + EXPECT_EQ(e.positions(3), i * 6); + EXPECT_EQ(e.positions(4), i * 7); } delete[] buffer; } @@ -207,20 +207,20 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i * 1); - ASSERT_EQ(e.positions(1), i * 2); - ASSERT_EQ(e.positions(2), i * 3); - ASSERT_EQ(e.positions(3), i * 6); - ASSERT_EQ(e.positions(4), i * 7); + EXPECT_EQ(e.positions(0), i * 1); + EXPECT_EQ(e.positions(1), i * 2); + EXPECT_EQ(e.positions(2), i * 3); + EXPECT_EQ(e.positions(3), i * 6); + EXPECT_EQ(e.positions(4), i * 7); } delete[] buffer; } @@ -250,19 +250,19 @@ TEST_F(TestStreamIndex, remove_written_position) { size_t output_size = writer.output_size(); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i * 1); - ASSERT_EQ(e.positions(1), i * 2); - ASSERT_EQ(e.positions(2), i * 3); - ASSERT_EQ(e.positions(3), i * 4); + EXPECT_EQ(e.positions(0), i * 1); + EXPECT_EQ(e.positions(1), i * 2); + EXPECT_EQ(e.positions(2), i * 3); + EXPECT_EQ(e.positions(3), i * 4); } delete[] buffer; } @@ -271,59 +271,59 @@ TEST_F(TestStreamIndex, remove_written_position) { TEST_F(TestStreamIndex, test_statistic) { ColumnStatistics stat; - ASSERT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); WrapperField* field = WrapperField::create_by_type(OLAP_FIELD_TYPE_INT); // start - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "2147483647"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "-2147483648"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "2147483647"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "-2147483648"); // 1 field->from_string("3"); stat.add(*field); - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "3"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "3"); // 2 field->from_string("5"); stat.add(*field); - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "3"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "5"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "5"); // 3 field->from_string("899"); stat.add(*field); - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "3"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "899"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "899"); // 4 field->from_string("-111"); stat.add(*field); - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "-111"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "899"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "-111"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "899"); stat.reset(); // start - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "2147483647"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "-2147483648"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "2147483647"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "-2147483648"); field->from_string("3"); stat.add(*field); field->from_string("6"); stat.add(*field); - ASSERT_STREQ(stat.minimum()->to_string().c_str(), "3"); - ASSERT_STREQ(stat.maximum()->to_string().c_str(), "6"); + EXPECT_STREQ(stat.minimum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat.maximum()->to_string().c_str(), "6"); ColumnStatistics stat2; - ASSERT_EQ(OLAP_SUCCESS, stat2.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(OLAP_SUCCESS, stat2.init(OLAP_FIELD_TYPE_INT, true)); char buf[256]; stat.write_to_buffer(buf, sizeof(buf)); stat2.attach(buf); - ASSERT_STREQ(stat2.minimum()->to_string().c_str(), "3"); - ASSERT_STREQ(stat2.maximum()->to_string().c_str(), "6"); + EXPECT_STREQ(stat2.minimum()->to_string().c_str(), "3"); + EXPECT_STREQ(stat2.maximum()->to_string().c_str(), "6"); delete field; } @@ -332,10 +332,10 @@ TEST_F(TestStreamIndex, statistic) { PositionEntryWriter entry; ColumnStatistics stat; - ASSERT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); + EXPECT_EQ(OLAP_SUCCESS, stat.init(OLAP_FIELD_TYPE_INT, true)); WrapperField* field = WrapperField::create_by_type(OLAP_FIELD_TYPE_INT); - ASSERT_TRUE(nullptr != field); + EXPECT_TRUE(nullptr != field); char string_buffer[256]; static const uint32_t loop = 10; @@ -361,39 +361,25 @@ TEST_F(TestStreamIndex, statistic) { size_t output_size = sizeof(StreamIndexHeader) + loop * sizeof(uint32_t) * 3 + (1 + sizeof(int32_t)) * loop * 2; - ASSERT_EQ(output_size, writer.output_size()); + EXPECT_EQ(output_size, writer.output_size()); char* buffer = new char[output_size]; - ASSERT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); + EXPECT_EQ(OLAP_SUCCESS, writer.write_to_buffer(buffer, output_size)); StreamIndexReader reader; - ASSERT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); + EXPECT_EQ(OLAP_SUCCESS, reader.init(buffer, output_size, OLAP_FIELD_TYPE_INT, true, true)); - ASSERT_EQ(loop, reader.entry_count()); + EXPECT_EQ(loop, reader.entry_count()); for (i = 0; i < loop; i++) { const PositionEntryReader& e = reader.entry(i); - ASSERT_EQ(e.positions(0), i); - ASSERT_EQ(e.positions(1), i * 2); - ASSERT_EQ(e.positions(2), i * 3); + EXPECT_EQ(e.positions(0), i); + EXPECT_EQ(e.positions(1), i * 2); + EXPECT_EQ(e.positions(2), i * 3); } delete[] buffer; delete field; } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - int ret = doris::OLAP_SUCCESS; - testing::InitGoogleTest(&argc, argv); - ret = RUN_ALL_TESTS(); - google::protobuf::ShutdownProtobufLibrary(); - return ret; -} diff --git a/be/test/olap/tablet_meta_manager_test.cpp b/be/test/olap/tablet_meta_manager_test.cpp index ccbff66813..8179ab3b5e 100644 --- a/be/test/olap/tablet_meta_manager_test.cpp +++ b/be/test/olap/tablet_meta_manager_test.cpp @@ -42,12 +42,12 @@ class TabletMetaManagerTest : public testing::Test { public: virtual void SetUp() { std::string root_path = "./store"; - ASSERT_TRUE(std::filesystem::create_directory(root_path)); + EXPECT_TRUE(std::filesystem::create_directory(root_path)); _data_dir = new (std::nothrow) DataDir(root_path); - ASSERT_NE(nullptr, _data_dir); + EXPECT_NE(nullptr, _data_dir); Status st = _data_dir->init(); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(std::filesystem::exists(root_path + "/meta")); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(std::filesystem::exists(root_path + "/meta")); std::ifstream infile(meta_path); char buffer[1024]; @@ -61,7 +61,7 @@ public: virtual void TearDown() { delete _data_dir; - ASSERT_TRUE(std::filesystem::remove_all("./store")); + EXPECT_TRUE(std::filesystem::remove_all("./store")); } private: @@ -74,41 +74,36 @@ TEST_F(TabletMetaManagerTest, TestSaveAndGetAndRemove) { const TSchemaHash schema_hash = 567997577; TabletMetaPB tablet_meta_pb; bool ret = json2pb::JsonToProtoMessage(_json_header, &tablet_meta_pb); - ASSERT_TRUE(ret); + EXPECT_TRUE(ret); std::string meta_binary; tablet_meta_pb.SerializeToString(&meta_binary); TabletMetaSharedPtr tablet_meta(new TabletMeta()); OLAPStatus s = tablet_meta->deserialize(meta_binary); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); s = TabletMetaManager::save(_data_dir, tablet_id, schema_hash, tablet_meta); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); std::string json_meta_read; s = TabletMetaManager::get_json_meta(_data_dir, tablet_id, schema_hash, &json_meta_read); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_EQ(_json_header, json_meta_read); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(_json_header, json_meta_read); s = TabletMetaManager::remove(_data_dir, tablet_id, schema_hash); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); TabletMetaSharedPtr meta_read(new TabletMeta()); s = TabletMetaManager::get_meta(_data_dir, tablet_id, schema_hash, meta_read); - ASSERT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); + EXPECT_EQ(OLAP_ERR_META_KEY_NOT_FOUND, s); } TEST_F(TabletMetaManagerTest, TestLoad) { const TTabletId tablet_id = 15672; const TSchemaHash schema_hash = 567997577; OLAPStatus s = TabletMetaManager::load_json_meta(_data_dir, meta_path); - ASSERT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(OLAP_SUCCESS, s); std::string json_meta_read; s = TabletMetaManager::get_json_meta(_data_dir, tablet_id, schema_hash, &json_meta_read); - ASSERT_EQ(OLAP_SUCCESS, s); - ASSERT_EQ(_json_header, json_meta_read); + EXPECT_EQ(OLAP_SUCCESS, s); + EXPECT_EQ(_json_header, json_meta_read); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/tablet_meta_test.cpp b/be/test/olap/tablet_meta_test.cpp index 8dd720dc91..6090a8a028 100644 --- a/be/test/olap/tablet_meta_test.cpp +++ b/be/test/olap/tablet_meta_test.cpp @@ -28,7 +28,7 @@ TEST(TabletMetaTest, SaveAndParse) { TabletMeta old_tablet_meta(1, 2, 3, 4, 5, TTabletSchema(), 6, {{7, 8}}, UniqueId(9, 10), TTabletType::TABLET_TYPE_DISK, TStorageMedium::HDD, ""); - ASSERT_EQ(OLAP_SUCCESS, old_tablet_meta.save(meta_path)); + EXPECT_EQ(OLAP_SUCCESS, old_tablet_meta.save(meta_path)); { // Just to make stack space dirty @@ -38,12 +38,7 @@ TEST(TabletMetaTest, SaveAndParse) { TabletMeta new_tablet_meta; new_tablet_meta.create_from_file(meta_path); - ASSERT_EQ(old_tablet_meta, new_tablet_meta); + EXPECT_EQ(old_tablet_meta, new_tablet_meta); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/tablet_mgr_test.cpp b/be/test/olap/tablet_mgr_test.cpp index 1c94124ed8..7ba81ecddf 100644 --- a/be/test/olap/tablet_mgr_test.cpp +++ b/be/test/olap/tablet_mgr_test.cpp @@ -43,8 +43,6 @@ using std::string; namespace doris { -static StorageEngine* k_engine = nullptr; - class TabletMgrTest : public testing::Test { public: virtual void SetUp() { @@ -59,21 +57,24 @@ public: EngineOptions options; // won't open engine, options.path is needless options.backend_uid = UniqueId::gen_uid(); - if (k_engine == nullptr) { - k_engine = new StorageEngine(options); - } - + k_engine = new StorageEngine(options); _data_dir = new DataDir(_engine_data_path, 1000000000); _data_dir->init(); _tablet_mgr = k_engine->tablet_manager(); } virtual void TearDown() { - delete _data_dir; + SAFE_DELETE(_data_dir); if (std::filesystem::exists(_engine_data_path)) { - ASSERT_TRUE(std::filesystem::remove_all(_engine_data_path)); + EXPECT_TRUE(std::filesystem::remove_all(_engine_data_path)); } + if (k_engine != nullptr) { + k_engine->stop(); + } + SAFE_DELETE(k_engine); + _tablet_mgr = nullptr; } + StorageEngine* k_engine = nullptr; private: DataDir* _data_dir = nullptr; @@ -103,26 +104,26 @@ TEST_F(TabletMgrTest, CreateTablet) { std::vector data_dirs; data_dirs.push_back(_data_dir); OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - ASSERT_TRUE(create_st == OLAP_SUCCESS); + EXPECT_TRUE(create_st == OLAP_SUCCESS); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); // check dir exist bool dir_exist = FileUtils::check_exist(tablet->tablet_path_desc().filepath); - ASSERT_TRUE(dir_exist); + EXPECT_TRUE(dir_exist); // check meta has this tablet TabletMetaSharedPtr new_tablet_meta(new TabletMeta()); OLAPStatus check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); - ASSERT_TRUE(check_meta_st == OLAP_SUCCESS); + EXPECT_TRUE(check_meta_st == OLAP_SUCCESS); // retry create should be successfully create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - ASSERT_TRUE(create_st == OLAP_SUCCESS); + EXPECT_TRUE(create_st == OLAP_SUCCESS); OLAPStatus drop_st = _tablet_mgr->drop_tablet(111, false); - ASSERT_TRUE(drop_st == OLAP_SUCCESS); + EXPECT_TRUE(drop_st == OLAP_SUCCESS); tablet.reset(); OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - ASSERT_TRUE(trash_st == OLAP_SUCCESS); + EXPECT_TRUE(trash_st == OLAP_SUCCESS); } TEST_F(TabletMgrTest, CreateTabletWithSequence) { @@ -161,23 +162,23 @@ TEST_F(TabletMgrTest, CreateTabletWithSequence) { std::vector data_dirs; data_dirs.push_back(_data_dir); OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - ASSERT_TRUE(create_st == OLAP_SUCCESS); + EXPECT_TRUE(create_st == OLAP_SUCCESS); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); // check dir exist bool dir_exist = FileUtils::check_exist(tablet->tablet_path_desc().filepath); - ASSERT_TRUE(dir_exist) << tablet->tablet_path_desc().filepath; + EXPECT_TRUE(dir_exist) << tablet->tablet_path_desc().filepath; // check meta has this tablet TabletMetaSharedPtr new_tablet_meta(new TabletMeta()); OLAPStatus check_meta_st = TabletMetaManager::get_meta(_data_dir, 111, 3333, new_tablet_meta); - ASSERT_TRUE(check_meta_st == OLAP_SUCCESS); + EXPECT_TRUE(check_meta_st == OLAP_SUCCESS); OLAPStatus drop_st = _tablet_mgr->drop_tablet(111, false); - ASSERT_TRUE(drop_st == OLAP_SUCCESS); + EXPECT_TRUE(drop_st == OLAP_SUCCESS); tablet.reset(); OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - ASSERT_TRUE(trash_st == OLAP_SUCCESS); + EXPECT_TRUE(trash_st == OLAP_SUCCESS); } TEST_F(TabletMgrTest, DropTablet) { @@ -202,46 +203,46 @@ TEST_F(TabletMgrTest, DropTablet) { std::vector data_dirs; data_dirs.push_back(_data_dir); OLAPStatus create_st = _tablet_mgr->create_tablet(create_tablet_req, data_dirs); - ASSERT_TRUE(create_st == OLAP_SUCCESS); + EXPECT_TRUE(create_st == OLAP_SUCCESS); TabletSharedPtr tablet = _tablet_mgr->get_tablet(111); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); // drop unexist tablet will be success OLAPStatus drop_st = _tablet_mgr->drop_tablet(1121, false); - ASSERT_TRUE(drop_st == OLAP_SUCCESS); + EXPECT_TRUE(drop_st == OLAP_SUCCESS); tablet = _tablet_mgr->get_tablet(111); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); // drop exist tablet will be success drop_st = _tablet_mgr->drop_tablet(111, false); - ASSERT_TRUE(drop_st == OLAP_SUCCESS); + EXPECT_TRUE(drop_st == OLAP_SUCCESS); tablet = _tablet_mgr->get_tablet(111); - ASSERT_TRUE(tablet == nullptr); + EXPECT_TRUE(tablet == nullptr); tablet = _tablet_mgr->get_tablet(111, true); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); // check dir exist std::string tablet_path = tablet->tablet_path_desc().filepath; bool dir_exist = FileUtils::check_exist(tablet_path); - ASSERT_TRUE(dir_exist); + EXPECT_TRUE(dir_exist); // do trash sweep, tablet will not be garbage collected // because tablet ptr referenced it OLAPStatus trash_st = _tablet_mgr->start_trash_sweep(); - ASSERT_TRUE(trash_st == OLAP_SUCCESS); + EXPECT_TRUE(trash_st == OLAP_SUCCESS); tablet = _tablet_mgr->get_tablet(111, true); - ASSERT_TRUE(tablet != nullptr); + EXPECT_TRUE(tablet != nullptr); dir_exist = FileUtils::check_exist(tablet_path); - ASSERT_TRUE(dir_exist); + EXPECT_TRUE(dir_exist); // reset tablet ptr tablet.reset(); trash_st = _tablet_mgr->start_trash_sweep(); - ASSERT_TRUE(trash_st == OLAP_SUCCESS); + EXPECT_TRUE(trash_st == OLAP_SUCCESS); tablet = _tablet_mgr->get_tablet(111, true); - ASSERT_TRUE(tablet == nullptr); + EXPECT_TRUE(tablet == nullptr); dir_exist = FileUtils::check_exist(tablet_path); - ASSERT_TRUE(!dir_exist); + EXPECT_TRUE(!dir_exist); } TEST_F(TabletMgrTest, GetRowsetId) { @@ -250,17 +251,17 @@ TEST_F(TabletMgrTest, GetRowsetId) { std::string path = _engine_data_path + "/data/0/15007/368169781"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); - ASSERT_EQ(15007, tid); - ASSERT_EQ(368169781, schema_hash); + EXPECT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); + EXPECT_EQ(15007, tid); + EXPECT_EQ(368169781, schema_hash); } { std::string path = _engine_data_path + "/data/0/15007/368169781/"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); - ASSERT_EQ(15007, tid); - ASSERT_EQ(368169781, schema_hash); + EXPECT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); + EXPECT_EQ(15007, tid); + EXPECT_EQ(368169781, schema_hash); } // normal case { @@ -269,43 +270,43 @@ TEST_F(TabletMgrTest, GetRowsetId) { "/data/0/15007/368169781/020000000000000100000000000000020000000000000003_0_0.dat"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); - ASSERT_EQ(15007, tid); - ASSERT_EQ(368169781, schema_hash); + EXPECT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); + EXPECT_EQ(15007, tid); + EXPECT_EQ(368169781, schema_hash); RowsetId id; - ASSERT_TRUE(_tablet_mgr->get_rowset_id_from_path(path, &id)); + EXPECT_TRUE(_tablet_mgr->get_rowset_id_from_path(path, &id)); EXPECT_EQ(2UL << 56 | 1, id.hi); - ASSERT_EQ(2, id.mi); - ASSERT_EQ(3, id.lo); + EXPECT_EQ(2, id.mi); + EXPECT_EQ(3, id.lo); } // empty tablet directory { std::string path = _engine_data_path + "/data/0/15007"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); - ASSERT_EQ(15007, tid); - ASSERT_EQ(0, schema_hash); + EXPECT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); + EXPECT_EQ(15007, tid); + EXPECT_EQ(0, schema_hash); RowsetId id; - ASSERT_FALSE(_tablet_mgr->get_rowset_id_from_path(path, &id)); + EXPECT_FALSE(_tablet_mgr->get_rowset_id_from_path(path, &id)); } // empty tablet directory { std::string path = _engine_data_path + "/data/0/15007/"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); - ASSERT_EQ(15007, tid); - ASSERT_EQ(0, schema_hash); + EXPECT_TRUE(_tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); + EXPECT_EQ(15007, tid); + EXPECT_EQ(0, schema_hash); } // empty tablet directory { std::string path = _engine_data_path + "/data/0/15007abc"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_FALSE( + EXPECT_FALSE( _tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); } // not match pattern @@ -315,17 +316,12 @@ TEST_F(TabletMgrTest, GetRowsetId) { "/data/0/15007/123abc/020000000000000100000000000000020000000000000003_0_0.dat"; TTabletId tid; TSchemaHash schema_hash; - ASSERT_FALSE( + EXPECT_FALSE( _tablet_mgr->get_tablet_id_and_schema_hash_from_path(path, &tid, &schema_hash)); RowsetId id; - ASSERT_FALSE(_tablet_mgr->get_rowset_id_from_path(path, &id)); + EXPECT_FALSE(_tablet_mgr->get_rowset_id_from_path(path, &id)); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/tablet_schema_helper.cpp b/be/test/olap/tablet_schema_helper.cpp new file mode 100644 index 0000000000..bba1f918dd --- /dev/null +++ b/be/test/olap/tablet_schema_helper.cpp @@ -0,0 +1,160 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "olap/tablet_schema_helper.h" + +namespace doris { + +TabletColumn create_int_key(int32_t id, bool is_nullable, bool is_bf_column, + bool has_bitmap_index) { + TabletColumn column; + column._unique_id = id; + column._col_name = std::to_string(id); + column._type = OLAP_FIELD_TYPE_INT; + column._is_key = true; + column._is_nullable = is_nullable; + column._length = 4; + column._index_length = 4; + column._is_bf_column = is_bf_column; + column._has_bitmap_index = has_bitmap_index; + return column; +} + +TabletColumn create_int_value(int32_t id, FieldAggregationMethod agg_method, bool is_nullable, + const std::string default_value, bool is_bf_column, + bool has_bitmap_index) { + TabletColumn column; + column._unique_id = id; + column._col_name = std::to_string(id); + column._type = OLAP_FIELD_TYPE_INT; + column._is_key = false; + column._aggregation = agg_method; + column._is_nullable = is_nullable; + column._length = 4; + column._index_length = 4; + if (default_value != "") { + column._has_default_value = true; + column._default_value = default_value; + } + column._is_bf_column = is_bf_column; + column._has_bitmap_index = has_bitmap_index; + return column; +} + +TabletColumn create_char_key(int32_t id, bool is_nullable) { + TabletColumn column; + column._unique_id = id; + column._col_name = std::to_string(id); + column._type = OLAP_FIELD_TYPE_CHAR; + column._is_key = true; + column._is_nullable = is_nullable; + column._length = 8; + column._index_length = 1; + return column; +} + +TabletColumn create_varchar_key(int32_t id, bool is_nullable) { + TabletColumn column; + column._unique_id = id; + column._col_name = std::to_string(id); + column._type = OLAP_FIELD_TYPE_VARCHAR; + column._is_key = true; + column._is_nullable = is_nullable; + column._length = 65533; + column._index_length = 4; + return column; +} + +TabletColumn create_string_key(int32_t id, bool is_nullable) { + TabletColumn column; + column._unique_id = id; + column._col_name = std::to_string(id); + column._type = OLAP_FIELD_TYPE_STRING; + column._is_key = true; + column._is_nullable = is_nullable; + column._length = 2147483643; + column._index_length = 4; + return column; +} + +void set_column_value_by_type(FieldType fieldType, int src, char* target, MemPool* pool, + size_t _length) { + if (fieldType == OLAP_FIELD_TYPE_CHAR) { + std::string s = std::to_string(src); + const char* src_value = s.c_str(); + int src_len = s.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = _length; + dest_slice->data = (char*)pool->allocate(dest_slice->size); + memcpy(dest_slice->data, src_value, src_len); + memset(dest_slice->data + src_len, 0, dest_slice->size - src_len); + } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) { + std::string s = std::to_string(src); + const char* src_value = s.c_str(); + int src_len = s.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = src_len; + dest_slice->data = (char*)pool->allocate(src_len); + memcpy(dest_slice->data, src_value, src_len); + } else if (fieldType == OLAP_FIELD_TYPE_STRING) { + std::string s = std::to_string(src); + const char* src_value = s.c_str(); + int src_len = s.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = src_len; + dest_slice->data = (char*)pool->allocate(src_len); + memcpy(dest_slice->data, src_value, src_len); + } else { + *(int*)target = src; + } +} +void set_column_value_by_type(FieldType fieldType, const std::string& src, char* target, + MemPool* pool, size_t _length) { + if (fieldType == OLAP_FIELD_TYPE_CHAR) { + const char* src_value = src.c_str(); + int src_len = src.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = _length; + dest_slice->data = (char*)pool->allocate(dest_slice->size); + memcpy(dest_slice->data, src_value, src_len); + memset(dest_slice->data + src_len, 0, dest_slice->size - src_len); + } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) { + const char* src_value = src.c_str(); + int src_len = src.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = src_len; + dest_slice->data = (char*)pool->allocate(src_len); + memcpy(dest_slice->data, src_value, src_len); + } else if (fieldType == OLAP_FIELD_TYPE_STRING) { + const char* src_value = src.c_str(); + int src_len = src.size(); + + auto* dest_slice = (Slice*)target; + dest_slice->size = src_len; + dest_slice->data = (char*)pool->allocate(src_len); + memcpy(dest_slice->data, src_value, src_len); + } else { + *(int*)target = std::stoi(src); + } +} + +} // namespace doris diff --git a/be/test/olap/tablet_schema_helper.h b/be/test/olap/tablet_schema_helper.h index b2183c3a73..d3772c26a4 100644 --- a/be/test/olap/tablet_schema_helper.h +++ b/be/test/olap/tablet_schema_helper.h @@ -25,77 +25,18 @@ namespace doris { TabletColumn create_int_key(int32_t id, bool is_nullable = true, bool is_bf_column = false, - bool has_bitmap_index = false) { - TabletColumn column; - column._unique_id = id; - column._col_name = std::to_string(id); - column._type = OLAP_FIELD_TYPE_INT; - column._is_key = true; - column._is_nullable = is_nullable; - column._length = 4; - column._index_length = 4; - column._is_bf_column = is_bf_column; - column._has_bitmap_index = has_bitmap_index; - return column; -} + bool has_bitmap_index = false); TabletColumn create_int_value(int32_t id, FieldAggregationMethod agg_method = OLAP_FIELD_AGGREGATION_SUM, bool is_nullable = true, const std::string default_value = "", - bool is_bf_column = false, bool has_bitmap_index = false) { - TabletColumn column; - column._unique_id = id; - column._col_name = std::to_string(id); - column._type = OLAP_FIELD_TYPE_INT; - column._is_key = false; - column._aggregation = agg_method; - column._is_nullable = is_nullable; - column._length = 4; - column._index_length = 4; - if (default_value != "") { - column._has_default_value = true; - column._default_value = default_value; - } - column._is_bf_column = is_bf_column; - column._has_bitmap_index = has_bitmap_index; - return column; -} + bool is_bf_column = false, bool has_bitmap_index = false); -TabletColumn create_char_key(int32_t id, bool is_nullable = true) { - TabletColumn column; - column._unique_id = id; - column._col_name = std::to_string(id); - column._type = OLAP_FIELD_TYPE_CHAR; - column._is_key = true; - column._is_nullable = is_nullable; - column._length = 8; - column._index_length = 1; - return column; -} +TabletColumn create_char_key(int32_t id, bool is_nullable = true); -TabletColumn create_varchar_key(int32_t id, bool is_nullable = true) { - TabletColumn column; - column._unique_id = id; - column._col_name = std::to_string(id); - column._type = OLAP_FIELD_TYPE_VARCHAR; - column._is_key = true; - column._is_nullable = is_nullable; - column._length = 65533; - column._index_length = 4; - return column; -} +TabletColumn create_varchar_key(int32_t id, bool is_nullable = true); -TabletColumn create_string_key(int32_t id, bool is_nullable = true) { - TabletColumn column; - column._unique_id = id; - column._col_name = std::to_string(id); - column._type = OLAP_FIELD_TYPE_STRING; - column._is_key = true; - column._is_nullable = is_nullable; - column._length = 2147483643; - column._index_length = 4; - return column; -} +TabletColumn create_string_key(int32_t id, bool is_nullable = true); template TabletColumn create_with_default_value(std::string default_value) { @@ -110,70 +51,9 @@ TabletColumn create_with_default_value(std::string default_value) { } void set_column_value_by_type(FieldType fieldType, int src, char* target, MemPool* pool, - size_t _length = 8) { - if (fieldType == OLAP_FIELD_TYPE_CHAR) { - std::string s = std::to_string(src); - const char* src_value = s.c_str(); - int src_len = s.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = _length; - dest_slice->data = (char*)pool->allocate(dest_slice->size); - memcpy(dest_slice->data, src_value, src_len); - memset(dest_slice->data + src_len, 0, dest_slice->size - src_len); - } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) { - std::string s = std::to_string(src); - const char* src_value = s.c_str(); - int src_len = s.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = src_len; - dest_slice->data = (char*)pool->allocate(src_len); - memcpy(dest_slice->data, src_value, src_len); - } else if (fieldType == OLAP_FIELD_TYPE_STRING) { - std::string s = std::to_string(src); - const char* src_value = s.c_str(); - int src_len = s.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = src_len; - dest_slice->data = (char*)pool->allocate(src_len); - memcpy(dest_slice->data, src_value, src_len); - } else { - *(int*)target = src; - } -} + size_t _length = 8); void set_column_value_by_type(FieldType fieldType, const std::string& src, char* target, - MemPool* pool, size_t _length = 8) { - if (fieldType == OLAP_FIELD_TYPE_CHAR) { - const char* src_value = src.c_str(); - int src_len = src.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = _length; - dest_slice->data = (char*)pool->allocate(dest_slice->size); - memcpy(dest_slice->data, src_value, src_len); - memset(dest_slice->data + src_len, 0, dest_slice->size - src_len); - } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) { - const char* src_value = src.c_str(); - int src_len = src.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = src_len; - dest_slice->data = (char*)pool->allocate(src_len); - memcpy(dest_slice->data, src_value, src_len); - } else if (fieldType == OLAP_FIELD_TYPE_STRING) { - const char* src_value = src.c_str(); - int src_len = src.size(); - - auto* dest_slice = (Slice*)target; - dest_slice->size = src_len; - dest_slice->data = (char*)pool->allocate(src_len); - memcpy(dest_slice->data, src_value, src_len); - } else { - *(int*)target = std::stoi(src); - } -} + MemPool* pool, size_t _length = 8); } // namespace doris diff --git a/be/test/olap/tablet_test.cpp b/be/test/olap/tablet_test.cpp index e0d2fd9eef..ba39e1d0fd 100644 --- a/be/test/olap/tablet_test.cpp +++ b/be/test/olap/tablet_test.cpp @@ -190,13 +190,7 @@ TEST_F(TestTablet, delete_expired_stale_rowset) { } _tablet->delete_expired_stale_rowset(); - ASSERT_EQ(0, _tablet->_timestamped_version_tracker._stale_version_path_map.size()); + EXPECT_EQ(0, _tablet->_timestamped_version_tracker._stale_version_path_map.size()); _tablet.reset(); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - auto ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/olap/timestamped_version_tracker_test.cpp b/be/test/olap/timestamped_version_tracker_test.cpp index b9f086145b..0710134127 100644 --- a/be/test/olap/timestamped_version_tracker_test.cpp +++ b/be/test/olap/timestamped_version_tracker_test.cpp @@ -303,9 +303,9 @@ TEST_F(TestTimestampedVersionTracker, construct_version_graph) { int64_t max_version = 0; version_graph.construct_version_graph(rs_metas, &max_version); - ASSERT_EQ(6, version_graph._version_graph.size()); + EXPECT_EQ(6, version_graph._version_graph.size()); int64_t exp = 11; - ASSERT_EQ(exp, max_version); + EXPECT_EQ(exp, max_version); } TEST_F(TestTimestampedVersionTracker, construct_version_graph_with_same_version) { @@ -320,9 +320,9 @@ TEST_F(TestTimestampedVersionTracker, construct_version_graph_with_same_version) int64_t max_version = 0; version_graph.construct_version_graph(rs_metas, &max_version); - ASSERT_EQ(6, version_graph._version_graph.size()); + EXPECT_EQ(6, version_graph._version_graph.size()); int64_t exp = 11; - ASSERT_EQ(exp, max_version); + EXPECT_EQ(exp, max_version); } TEST_F(TestTimestampedVersionTracker, reconstruct_version_graph) { @@ -333,9 +333,9 @@ TEST_F(TestTimestampedVersionTracker, reconstruct_version_graph) { int64_t max_version = 0; version_graph.reconstruct_version_graph(rs_metas, &max_version); - ASSERT_EQ(6, version_graph._version_graph.size()); + EXPECT_EQ(6, version_graph._version_graph.size()); int64_t exp = 11; - ASSERT_EQ(exp, max_version); + EXPECT_EQ(exp, max_version); } TEST_F(TestTimestampedVersionTracker, delete_version_from_graph) { @@ -346,8 +346,8 @@ TEST_F(TestTimestampedVersionTracker, delete_version_from_graph) { version_graph.add_version_to_graph(version0); version_graph.delete_version_from_graph(version0); - ASSERT_EQ(2, version_graph._version_graph.size()); - ASSERT_EQ(0, version_graph._version_graph[0].edges.size()); + EXPECT_EQ(2, version_graph._version_graph.size()); + EXPECT_EQ(0, version_graph._version_graph[0].edges.size()); } TEST_F(TestTimestampedVersionTracker, delete_version_from_graph_with_same_version) { @@ -361,8 +361,8 @@ TEST_F(TestTimestampedVersionTracker, delete_version_from_graph_with_same_versio version_graph.delete_version_from_graph(version0); - ASSERT_EQ(2, version_graph._version_graph.size()); - ASSERT_EQ(1, version_graph._version_graph[0].edges.size()); + EXPECT_EQ(2, version_graph._version_graph.size()); + EXPECT_EQ(1, version_graph._version_graph[0].edges.size()); } TEST_F(TestTimestampedVersionTracker, add_version_to_graph) { @@ -374,9 +374,9 @@ TEST_F(TestTimestampedVersionTracker, add_version_to_graph) { version_graph.add_version_to_graph(version0); version_graph.add_version_to_graph(version1); - ASSERT_EQ(3, version_graph._version_graph.size()); - ASSERT_EQ(0, version_graph._vertex_index_map.find(0)->second); - ASSERT_EQ(1, version_graph._vertex_index_map.find(1)->second); + EXPECT_EQ(3, version_graph._version_graph.size()); + EXPECT_EQ(0, version_graph._vertex_index_map.find(0)->second); + EXPECT_EQ(1, version_graph._vertex_index_map.find(1)->second); } TEST_F(TestTimestampedVersionTracker, add_version_to_graph_with_same_version) { @@ -388,8 +388,8 @@ TEST_F(TestTimestampedVersionTracker, add_version_to_graph_with_same_version) { version_graph.add_version_to_graph(version0); version_graph.add_version_to_graph(version1); - ASSERT_EQ(2, version_graph._version_graph.size()); - ASSERT_EQ(2, version_graph._version_graph[0].edges.size()); + EXPECT_EQ(2, version_graph._version_graph.size()); + EXPECT_EQ(2, version_graph._version_graph[0].edges.size()); } TEST_F(TestTimestampedVersionTracker, capture_consistent_versions) { @@ -409,11 +409,11 @@ TEST_F(TestTimestampedVersionTracker, capture_consistent_versions) { Version spec_version(0, 8); version_graph.capture_consistent_versions(spec_version, &version_path); - ASSERT_EQ(4, version_path.size()); - ASSERT_EQ(Version(0, 0), version_path[0]); - ASSERT_EQ(Version(1, 1), version_path[1]); - ASSERT_EQ(Version(2, 5), version_path[2]); - ASSERT_EQ(Version(6, 8), version_path[3]); + EXPECT_EQ(4, version_path.size()); + EXPECT_EQ(Version(0, 0), version_path[0]); + EXPECT_EQ(Version(1, 1), version_path[1]); + EXPECT_EQ(Version(2, 5), version_path[2]); + EXPECT_EQ(Version(6, 8), version_path[3]); } TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_with_same_rowset) { @@ -433,11 +433,11 @@ TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_with_same_rows Version spec_version(0, 8); version_graph.capture_consistent_versions(spec_version, &version_path); - ASSERT_EQ(4, version_path.size()); - ASSERT_EQ(Version(0, 0), version_path[0]); - ASSERT_EQ(Version(1, 1), version_path[1]); - ASSERT_EQ(Version(2, 5), version_path[2]); - ASSERT_EQ(Version(6, 8), version_path[3]); + EXPECT_EQ(4, version_path.size()); + EXPECT_EQ(Version(0, 0), version_path[0]); + EXPECT_EQ(Version(1, 1), version_path[1]); + EXPECT_EQ(Version(2, 5), version_path[2]); + EXPECT_EQ(Version(6, 8), version_path[3]); } TEST_F(TestTimestampedVersionTracker, construct_versioned_tracker) { @@ -452,9 +452,9 @@ TEST_F(TestTimestampedVersionTracker, construct_versioned_tracker) { TimestampedVersionTracker tracker; tracker.construct_versioned_tracker(rs_metas); - ASSERT_EQ(10, tracker._version_graph._version_graph.size()); - ASSERT_EQ(0, tracker._stale_version_path_map.size()); - ASSERT_EQ(1, tracker._next_path_id); + EXPECT_EQ(10, tracker._version_graph._version_graph.size()); + EXPECT_EQ(0, tracker._stale_version_path_map.size()); + EXPECT_EQ(1, tracker._next_path_id); } TEST_F(TestTimestampedVersionTracker, construct_version_tracker_by_stale_meta) { @@ -468,9 +468,9 @@ TEST_F(TestTimestampedVersionTracker, construct_version_tracker_by_stale_meta) { TimestampedVersionTracker tracker; tracker.construct_versioned_tracker(rs_metas, expired_rs_metas); - ASSERT_EQ(10, tracker._version_graph._version_graph.size()); - ASSERT_EQ(4, tracker._stale_version_path_map.size()); - ASSERT_EQ(5, tracker._next_path_id); + EXPECT_EQ(10, tracker._version_graph._version_graph.size()); + EXPECT_EQ(4, tracker._stale_version_path_map.size()); + EXPECT_EQ(5, tracker._next_path_id); } TEST_F(TestTimestampedVersionTracker, construct_versioned_tracker_with_same_rowset) { @@ -485,9 +485,9 @@ TEST_F(TestTimestampedVersionTracker, construct_versioned_tracker_with_same_rows TimestampedVersionTracker tracker; tracker.construct_versioned_tracker(rs_metas); - ASSERT_EQ(10, tracker._version_graph._version_graph.size()); - ASSERT_EQ(0, tracker._stale_version_path_map.size()); - ASSERT_EQ(1, tracker._next_path_id); + EXPECT_EQ(10, tracker._version_graph._version_graph.size()); + EXPECT_EQ(0, tracker._stale_version_path_map.size()); + EXPECT_EQ(1, tracker._next_path_id); } TEST_F(TestTimestampedVersionTracker, recover_versioned_tracker) { @@ -504,9 +504,9 @@ TEST_F(TestTimestampedVersionTracker, recover_versioned_tracker) { tracker.construct_versioned_tracker(rs_metas); tracker.recover_versioned_tracker(stale_version_path_map); - ASSERT_EQ(10, tracker._version_graph._version_graph.size()); - ASSERT_EQ(0, tracker._stale_version_path_map.size()); - ASSERT_EQ(1, tracker._next_path_id); + EXPECT_EQ(10, tracker._version_graph._version_graph.size()); + EXPECT_EQ(0, tracker._stale_version_path_map.size()); + EXPECT_EQ(1, tracker._next_path_id); } TEST_F(TestTimestampedVersionTracker, add_version) { @@ -518,9 +518,9 @@ TEST_F(TestTimestampedVersionTracker, add_version) { tracker.add_version(version0); tracker.add_version(version1); - ASSERT_EQ(3, tracker._version_graph._version_graph.size()); - ASSERT_EQ(0, tracker._version_graph._vertex_index_map.find(0)->second); - ASSERT_EQ(1, tracker._version_graph._vertex_index_map.find(1)->second); + EXPECT_EQ(3, tracker._version_graph._version_graph.size()); + EXPECT_EQ(0, tracker._version_graph._vertex_index_map.find(0)->second); + EXPECT_EQ(1, tracker._version_graph._vertex_index_map.find(1)->second); } TEST_F(TestTimestampedVersionTracker, add_version_with_same_rowset) { @@ -532,8 +532,8 @@ TEST_F(TestTimestampedVersionTracker, add_version_with_same_rowset) { tracker.add_version(version0); tracker.add_version(version1); - ASSERT_EQ(2, tracker._version_graph._version_graph.size()); - ASSERT_EQ(2, tracker._version_graph._version_graph[0].edges.size()); + EXPECT_EQ(2, tracker._version_graph._version_graph.size()); + EXPECT_EQ(2, tracker._version_graph._version_graph[0].edges.size()); } TEST_F(TestTimestampedVersionTracker, add_stale_path_version) { @@ -548,8 +548,8 @@ TEST_F(TestTimestampedVersionTracker, add_stale_path_version) { init_expired_row_rs_meta(&expired_rs_metas); tracker.add_stale_path_version(expired_rs_metas); - ASSERT_EQ(1, tracker._stale_version_path_map.size()); - ASSERT_EQ(7, tracker._stale_version_path_map.begin()->second->timestamped_versions().size()); + EXPECT_EQ(1, tracker._stale_version_path_map.size()); + EXPECT_EQ(7, tracker._stale_version_path_map.begin()->second->timestamped_versions().size()); } TEST_F(TestTimestampedVersionTracker, add_stale_path_version_with_same_rowset) { @@ -566,8 +566,8 @@ TEST_F(TestTimestampedVersionTracker, add_stale_path_version_with_same_rowset) { tracker.add_stale_path_version(*ptr); } - ASSERT_EQ(5, tracker._stale_version_path_map.size()); - ASSERT_EQ(1, tracker._stale_version_path_map.begin()->second->timestamped_versions().size()); + EXPECT_EQ(5, tracker._stale_version_path_map.size()); + EXPECT_EQ(1, tracker._stale_version_path_map.begin()->second->timestamped_versions().size()); } TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_tracker) { @@ -590,11 +590,11 @@ TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_tracker) { Version spec_version(0, 8); tracker.capture_consistent_versions(spec_version, &version_path); - ASSERT_EQ(4, version_path.size()); - ASSERT_EQ(Version(0, 0), version_path[0]); - ASSERT_EQ(Version(1, 1), version_path[1]); - ASSERT_EQ(Version(2, 5), version_path[2]); - ASSERT_EQ(Version(6, 8), version_path[3]); + EXPECT_EQ(4, version_path.size()); + EXPECT_EQ(Version(0, 0), version_path[0]); + EXPECT_EQ(Version(1, 1), version_path[1]); + EXPECT_EQ(Version(2, 5), version_path[2]); + EXPECT_EQ(Version(6, 8), version_path[3]); } TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_tracker_with_same_rowset) { @@ -617,11 +617,11 @@ TEST_F(TestTimestampedVersionTracker, capture_consistent_versions_tracker_with_s Version spec_version(0, 8); tracker.capture_consistent_versions(spec_version, &version_path); - ASSERT_EQ(4, version_path.size()); - ASSERT_EQ(Version(0, 0), version_path[0]); - ASSERT_EQ(Version(1, 1), version_path[1]); - ASSERT_EQ(Version(2, 5), version_path[2]); - ASSERT_EQ(Version(6, 8), version_path[3]); + EXPECT_EQ(4, version_path.size()); + EXPECT_EQ(Version(0, 0), version_path[0]); + EXPECT_EQ(Version(1, 1), version_path[1]); + EXPECT_EQ(Version(2, 5), version_path[2]); + EXPECT_EQ(Version(6, 8), version_path[3]); } TEST_F(TestTimestampedVersionTracker, fetch_and_delete_path_version) { @@ -640,34 +640,34 @@ TEST_F(TestTimestampedVersionTracker, fetch_and_delete_path_version) { tracker.add_stale_path_version(*ptr); } - ASSERT_EQ(4, tracker._stale_version_path_map.size()); + EXPECT_EQ(4, tracker._stale_version_path_map.size()); Version spec_version(0, 8); PathVersionListSharedPtr ptr = tracker.fetch_and_delete_path_by_id(1); std::vector& timestamped_versions = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions.size()); - ASSERT_EQ(Version(2, 3), timestamped_versions[0]->version()); - ASSERT_EQ(Version(4, 5), timestamped_versions[1]->version()); + EXPECT_EQ(2, timestamped_versions.size()); + EXPECT_EQ(Version(2, 3), timestamped_versions[0]->version()); + EXPECT_EQ(Version(4, 5), timestamped_versions[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(2); std::vector& timestamped_versions2 = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions2.size()); - ASSERT_EQ(Version(6, 6), timestamped_versions2[0]->version()); - ASSERT_EQ(Version(7, 8), timestamped_versions2[1]->version()); + EXPECT_EQ(2, timestamped_versions2.size()); + EXPECT_EQ(Version(6, 6), timestamped_versions2[0]->version()); + EXPECT_EQ(Version(7, 8), timestamped_versions2[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(3); std::vector& timestamped_versions3 = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions3.size()); - ASSERT_EQ(Version(6, 8), timestamped_versions3[0]->version()); - ASSERT_EQ(Version(9, 9), timestamped_versions3[1]->version()); + EXPECT_EQ(2, timestamped_versions3.size()); + EXPECT_EQ(Version(6, 8), timestamped_versions3[0]->version()); + EXPECT_EQ(Version(9, 9), timestamped_versions3[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(4); std::vector& timestamped_versions4 = ptr->timestamped_versions(); - ASSERT_EQ(1, timestamped_versions4.size()); - ASSERT_EQ(Version(10, 10), timestamped_versions4[0]->version()); + EXPECT_EQ(1, timestamped_versions4.size()); + EXPECT_EQ(Version(10, 10), timestamped_versions4[0]->version()); - ASSERT_EQ(0, tracker._stale_version_path_map.size()); + EXPECT_EQ(0, tracker._stale_version_path_map.size()); } TEST_F(TestTimestampedVersionTracker, fetch_and_delete_path_version_with_same_rowset) { @@ -686,37 +686,37 @@ TEST_F(TestTimestampedVersionTracker, fetch_and_delete_path_version_with_same_ro tracker.add_stale_path_version(*ptr); } - ASSERT_EQ(5, tracker._stale_version_path_map.size()); + EXPECT_EQ(5, tracker._stale_version_path_map.size()); PathVersionListSharedPtr ptr = tracker.fetch_and_delete_path_by_id(1); std::vector& timestamped_versions = ptr->timestamped_versions(); - ASSERT_EQ(1, timestamped_versions.size()); - ASSERT_EQ(Version(1, 1), timestamped_versions[0]->version()); + EXPECT_EQ(1, timestamped_versions.size()); + EXPECT_EQ(Version(1, 1), timestamped_versions[0]->version()); ptr = tracker.fetch_and_delete_path_by_id(2); std::vector& timestamped_versions2 = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions2.size()); - ASSERT_EQ(Version(2, 3), timestamped_versions2[0]->version()); - ASSERT_EQ(Version(4, 5), timestamped_versions2[1]->version()); + EXPECT_EQ(2, timestamped_versions2.size()); + EXPECT_EQ(Version(2, 3), timestamped_versions2[0]->version()); + EXPECT_EQ(Version(4, 5), timestamped_versions2[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(3); std::vector& timestamped_versions3 = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions3.size()); - ASSERT_EQ(Version(6, 6), timestamped_versions3[0]->version()); - ASSERT_EQ(Version(7, 8), timestamped_versions3[1]->version()); + EXPECT_EQ(2, timestamped_versions3.size()); + EXPECT_EQ(Version(6, 6), timestamped_versions3[0]->version()); + EXPECT_EQ(Version(7, 8), timestamped_versions3[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(4); std::vector& timestamped_versions4 = ptr->timestamped_versions(); - ASSERT_EQ(2, timestamped_versions4.size()); - ASSERT_EQ(Version(6, 8), timestamped_versions4[0]->version()); - ASSERT_EQ(Version(9, 9), timestamped_versions4[1]->version()); + EXPECT_EQ(2, timestamped_versions4.size()); + EXPECT_EQ(Version(6, 8), timestamped_versions4[0]->version()); + EXPECT_EQ(Version(9, 9), timestamped_versions4[1]->version()); ptr = tracker.fetch_and_delete_path_by_id(5); std::vector& timestamped_versions5 = ptr->timestamped_versions(); - ASSERT_EQ(1, timestamped_versions5.size()); - ASSERT_EQ(Version(10, 10), timestamped_versions5[0]->version()); + EXPECT_EQ(1, timestamped_versions5.size()); + EXPECT_EQ(Version(10, 10), timestamped_versions5[0]->version()); - ASSERT_EQ(0, tracker._stale_version_path_map.size()); + EXPECT_EQ(0, tracker._stale_version_path_map.size()); } TEST_F(TestTimestampedVersionTracker, capture_expired_path_version) { @@ -737,10 +737,10 @@ TEST_F(TestTimestampedVersionTracker, capture_expired_path_version) { } tracker.capture_expired_paths(9999, &path_version); - ASSERT_EQ(0, path_version.size()); + EXPECT_EQ(0, path_version.size()); tracker.capture_expired_paths(10001, &path_version); - ASSERT_EQ(4, path_version.size()); + EXPECT_EQ(4, path_version.size()); } TEST_F(TestTimestampedVersionTracker, get_stale_version_path_json_doc) { @@ -796,7 +796,7 @@ TEST_F(TestTimestampedVersionTracker, get_stale_version_path_json_doc) { ])"; expect_result = strings::Substitute(expect_result, time_zone_str); - ASSERT_EQ(expect_result, json_result); + EXPECT_EQ(expect_result, json_result); } TEST_F(TestTimestampedVersionTracker, get_stale_version_path_json_doc_empty) { @@ -822,7 +822,7 @@ TEST_F(TestTimestampedVersionTracker, get_stale_version_path_json_doc_empty) { std::string expect_result = R"([])"; - ASSERT_EQ(expect_result, json_result); + EXPECT_EQ(expect_result, json_result); } TEST_F(TestTimestampedVersionTracker, get_version_graph_orphan_vertex_ratio) { @@ -840,14 +840,8 @@ TEST_F(TestTimestampedVersionTracker, get_version_graph_orphan_vertex_ratio) { version_graph.delete_version_from_graph(version2); version_graph.delete_version_from_graph(version3); - ASSERT_EQ(5, version_graph._version_graph.size()); - ASSERT_EQ(0.4, version_graph.get_orphan_vertex_ratio()); + EXPECT_EQ(5, version_graph._version_graph.size()); + EXPECT_EQ(0.4, version_graph.get_orphan_vertex_ratio()); } } // namespace doris - -// @brief Test Stub -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/olap/txn_manager_test.cpp b/be/test/olap/txn_manager_test.cpp index e396b61c87..a3213da90d 100644 --- a/be/test/olap/txn_manager_test.cpp +++ b/be/test/olap/txn_manager_test.cpp @@ -17,8 +17,8 @@ #include "olap/txn_manager.h" -#include #include +#include #include #include @@ -109,12 +109,12 @@ public: std::string meta_path = "./meta"; std::filesystem::remove_all("./meta"); - ASSERT_TRUE(std::filesystem::create_directory(meta_path)); + EXPECT_TRUE(std::filesystem::create_directory(meta_path)); _meta = new (std::nothrow) OlapMeta(meta_path); - ASSERT_NE(nullptr, _meta); + EXPECT_NE(nullptr, _meta); OLAPStatus st = _meta->init(); - ASSERT_TRUE(st == OLAP_SUCCESS); - ASSERT_TRUE(std::filesystem::exists("./meta")); + EXPECT_TRUE(st == OLAP_SUCCESS); + EXPECT_TRUE(std::filesystem::exists("./meta")); load_id.set_hi(0); load_id.set_lo(0); @@ -132,12 +132,12 @@ public: rowset_id.init(10000); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); rowset_meta->init_from_json(_json_rowset_meta); - ASSERT_EQ(rowset_meta->rowset_id(), rowset_id); + EXPECT_EQ(rowset_meta->rowset_id(), rowset_id); FilePathDesc rowset_meta_path_desc; rowset_meta_path_desc.filepath = rowset_meta_path; - ASSERT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, rowset_meta, &_alpha_rowset)); - ASSERT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc, rowset_meta, &_alpha_rowset_same_id)); // init rowset meta 2 @@ -147,23 +147,22 @@ public: while (!infile2.eof()) { infile2.getline(buffer2, 1024); _json_rowset_meta = _json_rowset_meta + buffer2 + "\n"; - std::cout << _json_rowset_meta << std::endl; } _json_rowset_meta = _json_rowset_meta.substr(0, _json_rowset_meta.size() - 1); rowset_id.init(10001); RowsetMetaSharedPtr rowset_meta2(new AlphaRowsetMeta()); rowset_meta2->init_from_json(_json_rowset_meta); - ASSERT_EQ(rowset_meta2->rowset_id(), rowset_id); + EXPECT_EQ(rowset_meta2->rowset_id(), rowset_id); FilePathDesc rowset_meta_path_desc_2; rowset_meta_path_desc_2.filepath = rowset_meta_path_2; - ASSERT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc_2, + EXPECT_EQ(OLAP_SUCCESS, RowsetFactory::create_rowset(_schema.get(), rowset_meta_path_desc_2, rowset_meta2, &_alpha_rowset_diff_id)); _tablet_uid = TabletUid(10, 10); } virtual void TearDown() { delete _meta; - ASSERT_TRUE(std::filesystem::remove_all("./meta")); + EXPECT_TRUE(std::filesystem::remove_all("./meta")); } private: @@ -174,7 +173,7 @@ private: TTransactionId transaction_id = 111; TTabletId tablet_id = 222; SchemaHash schema_hash = 333; - TabletUid _tablet_uid{0, 0}; + TabletUid _tablet_uid {0, 0}; PUniqueId load_id; std::unique_ptr _schema; RowsetSharedPtr _alpha_rowset; @@ -185,7 +184,7 @@ private: TEST_F(TxnManagerTest, PrepareNewTxn) { OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); } // 1. prepare txn @@ -196,12 +195,12 @@ TEST_F(TxnManagerTest, CommitTxnWithPrepare) { _tablet_uid, load_id); _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); } // 1. commit without prepare @@ -210,7 +209,7 @@ TEST_F(TxnManagerTest, CommitTxnWithNoPrepare) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); } // 1. commit twice with different rowset id @@ -219,10 +218,10 @@ TEST_F(TxnManagerTest, CommitTxnTwiceWithDiffRowsetId) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset_diff_id, false); - ASSERT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != OLAP_SUCCESS); } // 1. commit twice with same rowset id @@ -231,34 +230,34 @@ TEST_F(TxnManagerTest, CommitTxnTwiceWithSameRowsetId) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset_same_id, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); } // 1. prepare twice should be success TEST_F(TxnManagerTest, PrepareNewTxnTwice) { OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); } // 1. txn could be rollbacked if it is not committed TEST_F(TxnManagerTest, RollbackNotCommittedTxn) { OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->rollback_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - ASSERT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != OLAP_SUCCESS); } // 1. txn could not be rollbacked if it is committed @@ -266,15 +265,15 @@ TEST_F(TxnManagerTest, RollbackCommittedTxn) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->rollback_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - ASSERT_FALSE(status == OLAP_SUCCESS); + EXPECT_FALSE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); } // 1. publish version success @@ -282,60 +281,54 @@ TEST_F(TxnManagerTest, PublishVersionSuccessful) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); Version new_version(10, 11); status = _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, new_version); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - ASSERT_TRUE(status == OLAP_SUCCESS); - ASSERT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); - ASSERT_TRUE(rowset_meta->start_version() == 10); - ASSERT_TRUE(rowset_meta->end_version() == 11); + EXPECT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(rowset_meta->rowset_id() == _alpha_rowset->rowset_id()); + EXPECT_TRUE(rowset_meta->start_version() == 10); + EXPECT_TRUE(rowset_meta->end_version() == 11); } // 1. publish version failed if not found related txn and rowset TEST_F(TxnManagerTest, PublishNotExistedTxn) { Version new_version(10, 11); - OLAPStatus status = - _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, - _tablet_uid, new_version); - ASSERT_TRUE(status != OLAP_SUCCESS); + OLAPStatus status = _txn_mgr->publish_txn(_meta, partition_id, transaction_id, tablet_id, + schema_hash, _tablet_uid, new_version); + EXPECT_TRUE(status != OLAP_SUCCESS); } TEST_F(TxnManagerTest, DeletePreparedTxn) { OLAPStatus status = _txn_mgr->prepare_txn(partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->delete_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); } TEST_F(TxnManagerTest, DeleteCommittedTxn) { OLAPStatus status = _txn_mgr->commit_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid, load_id, _alpha_rowset, false); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); status = _txn_mgr->delete_txn(_meta, partition_id, transaction_id, tablet_id, schema_hash, _tablet_uid); - ASSERT_TRUE(status == OLAP_SUCCESS); + EXPECT_TRUE(status == OLAP_SUCCESS); RowsetMetaSharedPtr rowset_meta2(new AlphaRowsetMeta()); status = RowsetMetaManager::get_rowset_meta(_meta, _tablet_uid, _alpha_rowset->rowset_id(), rowset_meta2); - ASSERT_TRUE(status != OLAP_SUCCESS); + EXPECT_TRUE(status != OLAP_SUCCESS); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/plugin/CMakeLists.txt b/be/test/plugin/CMakeLists.txt deleted file mode 100755 index fc4a48812e..0000000000 --- a/be/test/plugin/CMakeLists.txt +++ /dev/null @@ -1,26 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/plugin") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/plugin") - -#ADD_BE_TEST(plugin_zip_test) -#ADD_BE_TEST(plugin_loader_test) -#ADD_BE_TEST(plugin_mgr_test) diff --git a/be/test/plugin/plugin_loader_test.cpp b/be/test/plugin/plugin_loader_test.cpp index 2573aba371..2c6bbaf8a4 100644 --- a/be/test/plugin/plugin_loader_test.cpp +++ b/be/test/plugin/plugin_loader_test.cpp @@ -20,7 +20,7 @@ #include #include "plugin/plugin.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" namespace doris { @@ -71,22 +71,22 @@ TEST_F(PluginLoaderTest, normal) { DynamicPluginLoader plugin_loader("PluginExample", PLUGIN_TYPE_STORAGE, _path + "/plugin_test/source/test.zip", "libplugin_example.so", _path + "/plugin_test/target"); - ASSERT_TRUE(plugin_loader.install().ok()); + EXPECT_TRUE(plugin_loader.install().ok()); - ASSERT_TRUE(FileUtils::is_dir(_path + "/plugin_test/target/PluginExample")); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/PluginExample/")); + EXPECT_TRUE(FileUtils::is_dir(_path + "/plugin_test/target/PluginExample")); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/PluginExample/")); std::shared_ptr plugin = plugin_loader.plugin(); - ASSERT_EQ(3, plugin->flags); - ASSERT_EQ(1, plugin->init(nullptr)); - ASSERT_EQ(2, plugin->close(nullptr)); + EXPECT_EQ(3, plugin->flags); + EXPECT_EQ(1, plugin->init(nullptr)); + EXPECT_EQ(2, plugin->close(nullptr)); - ASSERT_TRUE(plugin->flags & PLUGIN_NOT_DYNAMIC_UNINSTALL); - ASSERT_FALSE(plugin_loader.uninstall().ok()); + EXPECT_TRUE(plugin->flags & PLUGIN_NOT_DYNAMIC_UNINSTALL); + EXPECT_FALSE(plugin_loader.uninstall().ok()); - ASSERT_TRUE(FileUtils::is_dir(_path + "/plugin_test/target/PluginExample")); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/PluginExample/")); + EXPECT_TRUE(FileUtils::is_dir(_path + "/plugin_test/target/PluginExample")); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/PluginExample/")); FileUtils::remove_all(_path + "/plugin_test/target"); } @@ -97,20 +97,15 @@ TEST_F(PluginLoaderTest, builtin) { }; BuiltinPluginLoader plugin_loader("test", PLUGIN_TYPE_AUDIT, &demoPlugin); - ASSERT_TRUE(plugin_loader.install().ok()); + EXPECT_TRUE(plugin_loader.install().ok()); std::shared_ptr plugin = plugin_loader.plugin(); - ASSERT_EQ(PLUGIN_DEFAULT_FLAG, plugin->flags); + EXPECT_EQ(PLUGIN_DEFAULT_FLAG, plugin->flags); - ASSERT_NE(nullptr, plugin->handler); - ASSERT_EQ("test", ((DemoPluginHandler*)plugin->handler)->hello("test")); + EXPECT_NE(nullptr, plugin->handler); + EXPECT_EQ("test", ((DemoPluginHandler*)plugin->handler)->hello("test")); - ASSERT_TRUE(plugin_loader.uninstall().ok()); + EXPECT_TRUE(plugin_loader.uninstall().ok()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/plugin/plugin_mgr_test.cpp b/be/test/plugin/plugin_mgr_test.cpp index 6680a6e54b..8d7422291d 100644 --- a/be/test/plugin/plugin_mgr_test.cpp +++ b/be/test/plugin/plugin_mgr_test.cpp @@ -22,7 +22,7 @@ #include "plugin/plugin.h" #include "plugin/plugin_loader.h" #include "string" -#include "test_util/test_util.h" +#include "testutil/test_util.h" namespace doris { @@ -76,21 +76,16 @@ TEST_F(PluginMgrTest, normal) { mgr.register_builtin_plugin("demo", PLUGIN_TYPE_AUDIT, &demo_plugin); std::shared_ptr re; - ASSERT_TRUE(mgr.get_plugin("demo", PLUGIN_TYPE_AUDIT, &re).ok()); - ASSERT_NE(nullptr, re.get()); - ASSERT_EQ("test", ((DemoPluginHandler*)re->handler)->hello("test")); + EXPECT_TRUE(mgr.get_plugin("demo", PLUGIN_TYPE_AUDIT, &re).ok()); + EXPECT_NE(nullptr, re.get()); + EXPECT_EQ("test", ((DemoPluginHandler*)re->handler)->hello("test")); - ASSERT_TRUE(mgr.get_plugin("demo", &re).ok()); - ASSERT_EQ("test", ((DemoPluginHandler*)re->handler)->hello("test")); + EXPECT_TRUE(mgr.get_plugin("demo", &re).ok()); + EXPECT_EQ("test", ((DemoPluginHandler*)re->handler)->hello("test")); std::vector> list; - ASSERT_TRUE(mgr.get_plugin_list(PLUGIN_TYPE_AUDIT, &list).ok()); - ASSERT_EQ(1, list.size()); + EXPECT_TRUE(mgr.get_plugin_list(PLUGIN_TYPE_AUDIT, &list).ok()); + EXPECT_EQ(1, list.size()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/plugin/plugin_zip_test.cpp b/be/test/plugin/plugin_zip_test.cpp index e564734e94..2d04d3fe7f 100644 --- a/be/test/plugin/plugin_zip_test.cpp +++ b/be/test/plugin/plugin_zip_test.cpp @@ -29,7 +29,7 @@ #include "http/http_channel.h" #include "http/http_handler.h" #include "http/http_request.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" #include "util/slice.h" @@ -38,12 +38,12 @@ class HttpTestHandler : public HttpHandler { public: void handle(HttpRequest* req) override { std::string path = GetCurrentRunningDir(); - ASSERT_FALSE(path.empty()); + EXPECT_FALSE(path.empty()); auto& file_name = req->param("FILE"); FILE* fp = fopen((path + "/plugin_test/source/" + file_name).c_str(), "r"); - ASSERT_TRUE(fp != nullptr); + EXPECT_TRUE(fp != nullptr); std::string response; char f[1024]; @@ -70,8 +70,6 @@ public: _server.reset(new EvHttpServer(29191)); _server->register_handler(GET, "/{FILE}", &_handler); _server->start(); - - std::cout << "the path: " << _path << std::endl; } public: @@ -84,10 +82,10 @@ TEST_F(PluginZipTest, local_normal) { FileUtils::remove_all(_path + "/plugin_test/target"); PluginZip zip(_path + "/plugin_test/source/test.zip"); - ASSERT_TRUE(zip.extract(_path + "/plugin_test/target/", "test").ok()); + EXPECT_TRUE(zip.extract(_path + "/plugin_test/target/", "test").ok()); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test")); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test/test.txt")); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test")); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test/test.txt")); std::unique_ptr file; Env::Default()->new_random_access_file(_path + "/plugin_test/target/test/test.txt", &file); @@ -96,7 +94,7 @@ TEST_F(PluginZipTest, local_normal) { Slice s(f, 11); file->read_at(0, &s); - ASSERT_EQ("hello world", s.to_string()); + EXPECT_EQ("hello world", s.to_string()); FileUtils::remove_all(_path + "/plugin_test/target/"); } @@ -106,11 +104,11 @@ TEST_F(PluginZipTest, http_normal) { PluginZip zip("http://127.0.0.1:29191/test.zip"); - // ASSERT_TRUE(zip.extract(_path + "/plugin_test/target/", "test").ok()); + // EXPECT_TRUE(zip.extract(_path + "/plugin_test/target/", "test").ok()); Status st = (zip.extract(_path + "/plugin_test/target/", "test")); - ASSERT_TRUE(st.ok()) << st.to_string(); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test")); - ASSERT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test/test.txt")); + EXPECT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test")); + EXPECT_TRUE(FileUtils::check_exist(_path + "/plugin_test/target/test/test.txt")); std::unique_ptr file; Env::Default()->new_random_access_file(_path + "/plugin_test/target/test/test.txt", &file); @@ -119,16 +117,16 @@ TEST_F(PluginZipTest, http_normal) { Slice s(f, 11); file->read_at(0, &s); - ASSERT_EQ("hello world", s.to_string()); + EXPECT_EQ("hello world", s.to_string()); std::set dirs; std::set files; - ASSERT_TRUE( + EXPECT_TRUE( FileUtils::list_dirs_files(_path + "/plugin_test/target", &dirs, &files, Env::Default()) .ok()); - ASSERT_EQ(1, dirs.size()); - ASSERT_EQ(1, files.size()); + EXPECT_EQ(1, dirs.size()); + EXPECT_EQ(1, files.size()); FileUtils::remove_all(_path + "/plugin_test/target/"); } @@ -140,12 +138,7 @@ TEST_F(PluginZipTest, already_install) { FileUtils::remove_all(_path + "/plugin_test/target"); PluginZip zip("http://127.0.0.1:29191/test.zip"); - ASSERT_FALSE(zip.extract(_path + "/plugin_test/", "source").ok()); + EXPECT_FALSE(zip.extract(_path + "/plugin_test/", "source").ok()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/CMakeLists.txt b/be/test/runtime/CMakeLists.txt deleted file mode 100644 index 06a121416e..0000000000 --- a/be/test/runtime/CMakeLists.txt +++ /dev/null @@ -1,67 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/runtime") - -#ADD_BE_TEST(buffered_tuple_stream_test) -#ADD_BE_TEST(sorter_test) -#ADD_BE_TEST(buffer_control_block_test) -#ADD_BE_TEST(result_buffer_mgr_test) -#ADD_BE_TEST(result_sink_test) -ADD_BE_TEST(mem_pool_test) -ADD_BE_TEST(free_list_test) -ADD_BE_TEST(string_buffer_test) -#ADD_BE_TEST(data_stream_test) -#ADD_BE_TEST(parallel_executor_test) -#ADD_BE_TEST(datetime_value_test) -ADD_BE_TEST(decimalv2_value_test) -ADD_BE_TEST(large_int_value_test) -ADD_BE_TEST(string_value_test) -#ADD_BE_TEST(thread_resource_mgr_test) -#ADD_BE_TEST(qsorter_test) -ADD_BE_TEST(fragment_mgr_test) -#ADD_BE_TEST(dpp_sink_internal_test) -#ADD_BE_TEST(dpp_sink_test) -#ADD_BE_TEST(data_spliter_test) -#ADD_BE_TEST(etl_job_mgr_test) - -#ADD_BE_TEST(tmp_file_mgr_test) -#ADD_BE_TEST(disk_io_mgr_test) -ADD_BE_TEST(mem_limit_test) -#ADD_BE_TEST(buffered_block_mgr2_test) -#ADD_BE_TEST(buffered_tuple_stream2_test) -ADD_BE_TEST(stream_load_pipe_test) -ADD_BE_TEST(load_channel_mgr_test) -#ADD_BE_TEST(export_task_mgr_test) -ADD_BE_TEST(snapshot_loader_test) -ADD_BE_TEST(user_function_cache_test) -ADD_BE_TEST(kafka_consumer_pipe_test) -ADD_BE_TEST(routine_load_task_executor_test) -ADD_BE_TEST(small_file_mgr_test) -ADD_BE_TEST(heartbeat_flags_test) - -ADD_BE_TEST(result_queue_mgr_test) -ADD_BE_TEST(memory_scratch_sink_test test_env.cc) -ADD_BE_TEST(external_scan_context_mgr_test) - -ADD_BE_TEST(memory/chunk_allocator_test) -ADD_BE_TEST(memory/system_allocator_test) -ADD_BE_TEST(cache/partition_cache_test) -ADD_BE_TEST(collection_value_test) -#ADD_BE_TEST(minidump_test) -ADD_BE_TEST(array_test) diff --git a/be/test/runtime/array_test.cpp b/be/test/runtime/array_test.cpp index 5eee237e3e..dc5ada4480 100644 --- a/be/test/runtime/array_test.cpp +++ b/be/test/runtime/array_test.cpp @@ -40,7 +40,7 @@ #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" #include "runtime/raw_value.h" -#include "test_util/array_utils.h" +#include "testutil/array_utils.h" #include "testutil/desc_tbl_builder.h" #include "util/file_utils.h" #include "util/uid_util.h" @@ -130,14 +130,14 @@ public: protected: void SetUp() override { if (FileUtils::check_exist(TEST_DIR)) { - ASSERT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); } - ASSERT_TRUE(FileUtils::create_dir(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::create_dir(TEST_DIR).ok()); } void TearDown() override { if (FileUtils::check_exist(TEST_DIR)) { - ASSERT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); + EXPECT_TRUE(FileUtils::remove_all(TEST_DIR).ok()); } } @@ -149,14 +149,14 @@ private: auto total_size = tuple_desc->byte_size() + array->get_byte_size(type_desc); auto src = allocate_tuple(total_size); - ASSERT_NE(src, nullptr); + EXPECT_NE(src, nullptr); RawValue::write(array, src, slot_desc, _mem_pool.get()); auto src_cv = reinterpret_cast(src->get_slot(slot_desc->tuple_offset())); validate(field, array, src_cv); auto dst = allocate_tuple(total_size); - ASSERT_NE(dst, nullptr); + EXPECT_NE(dst, nullptr); src->deep_copy(dst, *tuple_desc, _mem_pool.get()); auto dst_cv = reinterpret_cast(dst->get_slot(slot_desc->tuple_offset())); @@ -208,33 +208,33 @@ private: Schema schema({tablet_column}, 0); { auto wblock = create_writable_block(path); - ASSERT_NE(wblock, nullptr); + EXPECT_NE(wblock, nullptr); auto writer = create_column_writer(wblock.get(), meta, column_pb); - ASSERT_NE(writer, nullptr); + EXPECT_NE(writer, nullptr); Status st; for (auto array : arrays) { st = writer->append(false, const_cast(array)); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } - ASSERT_TRUE(writer->finish().ok()); - ASSERT_TRUE(writer->write_data().ok()); - ASSERT_TRUE(writer->write_ordinal_index().ok()); - ASSERT_TRUE(writer->write_zone_map().ok()); + EXPECT_TRUE(writer->finish().ok()); + EXPECT_TRUE(writer->write_data().ok()); + EXPECT_TRUE(writer->write_ordinal_index().ok()); + EXPECT_TRUE(writer->write_zone_map().ok()); - ASSERT_TRUE(wblock->close().ok()); + EXPECT_TRUE(wblock->close().ok()); } { auto reader = create_column_reader(path, meta, arrays.size()); - ASSERT_NE(reader, nullptr); + EXPECT_NE(reader, nullptr); auto rblock = create_readable_block(path); - ASSERT_NE(rblock, nullptr); + EXPECT_NE(rblock, nullptr); OlapReaderStatistics stats; std::unique_ptr iter( new_iterator(rblock.get(), &stats, reader.get())); - ASSERT_NE(iter, nullptr); + EXPECT_NE(iter, nullptr); auto st = iter->seek_to_first(); - ASSERT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(st.ok()) << st.to_string(); RowBlockV2 block(schema, 1024); auto col = block.column_block(0); @@ -243,12 +243,12 @@ private: do { ColumnBlockView dst(&col); st = iter->next_batch(&rows_read, &dst); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); for (int i = 0; i < rows_read; ++i) { validate(field, arrays[index++], reinterpret_cast(col.cell_ptr(i))); } - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } while (rows_read >= 1024); auto tuple_desc = get_tuple_descriptor(_object_pool, get_type_info(column_pb)); @@ -347,7 +347,7 @@ private: template void test_array(const ColumnPB& column_pb, const Field* field, const TupleDescriptor* tuple_desc, const CollectionValue* array) { - ASSERT_NE(array, nullptr); + EXPECT_NE(array, nullptr); test_copy_array(tuple_desc, field, array); test_direct_copy_array(field, {array}); test_write_and_read_column(column_pb, field, {array}); @@ -386,7 +386,7 @@ TEST_F(ArrayTest, TestSimpleIntArrays) { const auto* type_info = get_type_info(column_pb); auto field = create_field(column_pb); auto tuple_desc = get_tuple_descriptor(_object_pool, type_info); - ASSERT_EQ(tuple_desc->slots().size(), 1); + EXPECT_EQ(tuple_desc->slots().size(), 1); FunctionContext context; ArrayUtils::prepare_context(context, *_mem_pool, column_pb); @@ -414,7 +414,7 @@ TEST_F(ArrayTest, TestNestedIntArrays) { const auto* type_info = get_type_info(column_pb); auto field = create_field(column_pb); auto tuple_desc = get_tuple_descriptor(_object_pool, type_info); - ASSERT_EQ(tuple_desc->slots().size(), 1); + EXPECT_EQ(tuple_desc->slots().size(), 1); auto context = std::make_unique(); ArrayUtils::prepare_context(*context, *_mem_pool, column_pb); @@ -439,9 +439,9 @@ TEST_F(ArrayTest, TestNestedIntArrays) { type_info = get_type_info(column_pb); field = create_field(column_pb); tuple_desc = get_tuple_descriptor(_object_pool, type_info); - ASSERT_EQ(tuple_desc->slots().size(), 1); + EXPECT_EQ(tuple_desc->slots().size(), 1); arrays.clear(); - ASSERT_EQ(arrays.size(), 0); + EXPECT_EQ(arrays.size(), 0); context.reset(new FunctionContext); ArrayUtils::prepare_context(*context, *_mem_pool, column_pb); @@ -466,7 +466,7 @@ TEST_F(ArrayTest, TestSimpleStringArrays) { auto type_info = get_type_info(column_pb); auto field = create_field(column_pb); auto tuple_desc = get_tuple_descriptor(_object_pool, type_info); - ASSERT_EQ(tuple_desc->slots().size(), 1); + EXPECT_EQ(tuple_desc->slots().size(), 1); FunctionContext context; ArrayUtils::prepare_context(context, *_mem_pool, column_pb); @@ -494,7 +494,7 @@ TEST_F(ArrayTest, TestNestedStringArrays) { const auto* type_info = get_type_info(column_pb); auto field = create_field(column_pb); auto tuple_desc = get_tuple_descriptor(_object_pool, type_info); - ASSERT_EQ(tuple_desc->slots().size(), 1); + EXPECT_EQ(tuple_desc->slots().size(), 1); FunctionContext context; ArrayUtils::prepare_context(context, *_mem_pool, column_pb); @@ -516,8 +516,3 @@ TEST_F(ArrayTest, TestNestedStringArrays) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/buffer_control_block_test.cpp b/be/test/runtime/buffer_control_block_test.cpp index b997daddc1..d9824a00b1 100644 --- a/be/test/runtime/buffer_control_block_test.cpp +++ b/be/test/runtime/buffer_control_block_test.cpp @@ -37,46 +37,46 @@ private: TEST_F(BufferControlBlockTest, init_normal) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); } TEST_F(BufferControlBlockTest, add_one_get_one) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); TFetchDataResult* add_result = new TFetchDataResult(); add_result->result_batch.rows.push_back("hello test"); - ASSERT_TRUE(control_block.add_batch(add_result).ok()); + EXPECT_TRUE(control_block.add_batch(add_result).ok()); TFetchDataResult get_result; - ASSERT_TRUE(control_block.get_batch(&get_result).ok()); - ASSERT_FALSE(get_result.eos); - ASSERT_EQ(1U, get_result.result_batch.rows.size()); - ASSERT_STREQ("hello test", get_result.result_batch.rows[0].c_str()); + EXPECT_TRUE(control_block.get_batch(&get_result).ok()); + EXPECT_FALSE(get_result.eos); + EXPECT_EQ(1U, get_result.result_batch.rows.size()); + EXPECT_STREQ("hello test", get_result.result_batch.rows[0].c_str()); } TEST_F(BufferControlBlockTest, get_one_after_close) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); control_block.close(Status::OK()); TFetchDataResult get_result; - ASSERT_TRUE(control_block.get_batch(&get_result).ok()); - ASSERT_TRUE(get_result.eos); + EXPECT_TRUE(control_block.get_batch(&get_result).ok()); + EXPECT_TRUE(get_result.eos); } TEST_F(BufferControlBlockTest, get_add_after_cancel) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); - ASSERT_TRUE(control_block.cancel().ok()); + EXPECT_TRUE(control_block.cancel().ok()); TFetchDataResult* add_result = new TFetchDataResult(); add_result->result_batch.rows.push_back("hello test"); - ASSERT_FALSE(control_block.add_batch(add_result).ok()); + EXPECT_FALSE(control_block.add_batch(add_result).ok()); delete add_result; TFetchDataResult get_result; - ASSERT_FALSE(control_block.get_batch(&get_result).ok()); + EXPECT_FALSE(control_block.get_batch(&get_result).ok()); } void* cancel_thread(void* param) { @@ -89,7 +89,7 @@ void* cancel_thread(void* param) { TEST_F(BufferControlBlockTest, add_then_cancel) { // only can add one batch BufferControlBlock control_block(TUniqueId(), 1); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); pthread_t id; pthread_create(&id, nullptr, cancel_thread, &control_block); @@ -98,32 +98,32 @@ TEST_F(BufferControlBlockTest, add_then_cancel) { TFetchDataResult* add_result = new TFetchDataResult(); add_result->result_batch.rows.push_back("hello test1"); add_result->result_batch.rows.push_back("hello test2"); - ASSERT_TRUE(control_block.add_batch(add_result).ok()); + EXPECT_TRUE(control_block.add_batch(add_result).ok()); } { TFetchDataResult* add_result = new TFetchDataResult(); add_result->result_batch.rows.push_back("hello test1"); add_result->result_batch.rows.push_back("hello test2"); - ASSERT_FALSE(control_block.add_batch(add_result).ok()); + EXPECT_FALSE(control_block.add_batch(add_result).ok()); delete add_result; } TFetchDataResult get_result; - ASSERT_FALSE(control_block.get_batch(&get_result).ok()); + EXPECT_FALSE(control_block.get_batch(&get_result).ok()); pthread_join(id, nullptr); } TEST_F(BufferControlBlockTest, get_then_cancel) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); pthread_t id; pthread_create(&id, nullptr, cancel_thread, &control_block); // get block until cancel TFetchDataResult get_result; - ASSERT_FALSE(control_block.get_batch(&get_result).ok()); + EXPECT_FALSE(control_block.get_batch(&get_result).ok()); pthread_join(id, nullptr); } @@ -142,18 +142,18 @@ void* add_thread(void* param) { TEST_F(BufferControlBlockTest, get_then_add) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); pthread_t id; pthread_create(&id, nullptr, add_thread, &control_block); // get block until a batch add TFetchDataResult get_result; - ASSERT_TRUE(control_block.get_batch(&get_result).ok()); - ASSERT_FALSE(get_result.eos); - ASSERT_EQ(2U, get_result.result_batch.rows.size()); - ASSERT_STREQ("hello test1", get_result.result_batch.rows[0].c_str()); - ASSERT_STREQ("hello test2", get_result.result_batch.rows[1].c_str()); + EXPECT_TRUE(control_block.get_batch(&get_result).ok()); + EXPECT_FALSE(get_result.eos); + EXPECT_EQ(2U, get_result.result_batch.rows.size()); + EXPECT_STREQ("hello test1", get_result.result_batch.rows[0].c_str()); + EXPECT_STREQ("hello test2", get_result.result_batch.rows[1].c_str()); pthread_join(id, nullptr); } @@ -167,30 +167,18 @@ void* close_thread(void* param) { TEST_F(BufferControlBlockTest, get_then_close) { BufferControlBlock control_block(TUniqueId(), 1024); - ASSERT_TRUE(control_block.init().ok()); + EXPECT_TRUE(control_block.init().ok()); pthread_t id; pthread_create(&id, nullptr, close_thread, &control_block); // get block until a batch add TFetchDataResult get_result; - ASSERT_TRUE(control_block.get_batch(&get_result).ok()); - ASSERT_TRUE(get_result.eos); - ASSERT_EQ(0U, get_result.result_batch.rows.size()); + EXPECT_TRUE(control_block.get_batch(&get_result).ok()); + EXPECT_TRUE(get_result.eos); + EXPECT_EQ(0U, get_result.result_batch.rows.size()); pthread_join(id, nullptr); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} - -/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */ diff --git a/be/test/runtime/buffered_block_mgr2_test.cpp b/be/test/runtime/buffered_block_mgr2_test.cpp index 95d60f7e6f..f553a7502b 100644 --- a/be/test/runtime/buffered_block_mgr2_test.cpp +++ b/be/test/runtime/buffered_block_mgr2_test.cpp @@ -186,8 +186,8 @@ protected: BufferedBlockMgr2::Block* new_block; for (int i = 0; i < num_blocks; ++i) { status = block_mgr->get_new_block(client, nullptr, &new_block); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(new_block != nullptr); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(new_block != nullptr); data = new_block->allocate(sizeof(int32_t)); *data = blocks->size(); blocks->push_back(new_block); @@ -918,7 +918,7 @@ TEST_F(BufferedBlockMgrTest, DISABLED_WriteErrorBlacklist) { const string& good_dir = tmp_dirs[1]; // Delete one file from first scratch dir for first block manager. BufferedBlockMgr2::Block* error_block = FindBlockForDir(blocks[error_mgr], error_dir); - ASSERT_TRUE(error_block != nullptr) << "Expected a tmp file in dir " << error_dir; + EXPECT_TRUE(error_block != nullptr) << "Expected a tmp file in dir " << error_dir; PinBlocks(all_blocks); DeleteBackingFile(error_block); UnpinBlocks(all_blocks); // Should succeed since tmp file space was already allocated. @@ -1257,25 +1257,3 @@ TEST_F(BufferedBlockMgrTest, CreateDestroyMulti) { } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::config::query_scratch_dirs = "/tmp"; - // doris::config::max_free_io_buffers = 128; - doris::config::read_size = 8388608; - doris::config::min_buffer_size = 1024; - - doris::config::disable_mem_pools = false; - - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::CpuInfo::init(); - doris::DiskInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/buffered_tuple_stream2_test.cpp b/be/test/runtime/buffered_tuple_stream2_test.cpp index 4a522ad84f..7ae670c787 100644 --- a/be/test/runtime/buffered_tuple_stream2_test.cpp +++ b/be/test/runtime/buffered_tuple_stream2_test.cpp @@ -98,10 +98,10 @@ protected: // tracked by _tracker. void InitBlockMgr(int64_t limit, int block_size) { Status status = _test_env->create_query_state(0, limit, block_size, &_runtime_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _runtime_state->block_mgr2()->register_client(0, _tracker, _runtime_state, &_client); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } // Generate the ith element of a sequence of int values. @@ -229,11 +229,11 @@ protected: for (int j = 0; j < int_tuples; ++j) { int idx = i * int_tuples + j; if (!gen_null || GenBoolValue(idx)) { - ASSERT_EQ(results[idx], GenIntValue(i)) + EXPECT_EQ(results[idx], GenIntValue(i)) << " results[" << idx << "]: " << results[idx] << " != " << GenIntValue(i) << " gen_null=" << gen_null; } else { - ASSERT_TRUE(results[idx] == std::numeric_limits::max()) + EXPECT_TRUE(results[idx] == std::numeric_limits::max()) << "i: " << i << " j: " << j << " results[" << idx << "]: " << results[idx] << " != " << std::numeric_limits::max(); } @@ -249,12 +249,12 @@ protected: for (int j = 0; j < string_tuples; ++j) { int idx = i * string_tuples + j; if (!gen_null || GenBoolValue(idx)) { - ASSERT_TRUE(results[idx] == STRINGS[i % NUM_STRINGS]) + EXPECT_TRUE(results[idx] == STRINGS[i % NUM_STRINGS]) << "results[" << idx << "] " << results[idx] << " != " << STRINGS[i % NUM_STRINGS] << " i=" << i << " gen_null=" << gen_null; } else { - ASSERT_TRUE(results[idx] == StringValue()) + EXPECT_TRUE(results[idx] == StringValue()) << "results[" << idx << "] " << results[idx] << " not nullptr"; } } @@ -267,9 +267,9 @@ protected: BufferedTupleStream2 stream(_runtime_state, *desc, _runtime_state->block_mgr2(), _client, true, false); Status status = stream.init(-1, nullptr, true); - ASSERT_TRUE(status.ok()) << status.get_error_msg(); + EXPECT_TRUE(status.ok()) << status.get_error_msg(); status = stream.unpin_stream(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Add rows to the stream int offset = 0; @@ -284,17 +284,17 @@ protected: } for (int j = 0; j < batch->num_rows(); ++j) { bool b = stream.add_row(batch->get_row(j), &status); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!b) { - ASSERT_TRUE(stream.using_small_buffers()); + EXPECT_TRUE(stream.using_small_buffers()); bool got_buffer; status = stream.switch_to_io_buffers(&got_buffer); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(got_buffer); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(got_buffer); b = stream.add_row(batch->get_row(j), &status); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } - ASSERT_TRUE(b); + EXPECT_TRUE(b); } offset += batch->num_rows(); // Reset the batch to make sure the stream handles the memory correctly. @@ -302,7 +302,7 @@ protected: } status = stream.prepare_for_read(false); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Read all the rows back std::vector results; @@ -320,11 +320,11 @@ protected: _client, small_buffers == 0, // initial small buffers true); // read_write Status status = stream.init(-1, nullptr, true); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = stream.prepare_for_read(true); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = stream.unpin_stream(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector results; @@ -332,8 +332,8 @@ protected: RowBatch* batch = CreateIntBatch(i * BATCH_SIZE, BATCH_SIZE, false); for (int j = 0; j < batch->num_rows(); ++j) { bool b = stream.add_row(batch->get_row(j), &status); - ASSERT_TRUE(b); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(b); + EXPECT_TRUE(status.ok()); } // Reset the batch to make sure the stream handles the memory correctly. batch->reset(); @@ -523,7 +523,7 @@ TEST_F(SimpleTupleStreamTest, UnpinPin) { BufferedTupleStream2 stream(_runtime_state, *_int_desc, _runtime_state->block_mgr2(), _client, true, false); Status status = stream.init(-1, nullptr, true); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int offset = 0; bool full = false; @@ -532,7 +532,7 @@ TEST_F(SimpleTupleStreamTest, UnpinPin) { int j = 0; for (; j < batch->num_rows(); ++j) { full = !stream.add_row(batch->get_row(j), &status); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (full) { break; } @@ -541,12 +541,12 @@ TEST_F(SimpleTupleStreamTest, UnpinPin) { } status = stream.unpin_stream(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); bool pinned = false; status = stream.pin_stream(false, &pinned); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(pinned); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(pinned); std::vector results; @@ -556,7 +556,7 @@ TEST_F(SimpleTupleStreamTest, UnpinPin) { for (int i = 0; i < read_iters; ++i) { bool delete_on_read = i == read_iters - 1; status = stream.prepare_for_read(delete_on_read); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); results.clear(); ReadValues(&stream, _int_desc, &results); VerifyResults(results, offset, false); @@ -580,7 +580,7 @@ TEST_F(SimpleTupleStreamTest, SmallBuffers) { BufferedTupleStream2 stream(_runtime_state, *_int_desc, _runtime_state->block_mgr2(), _client, true, false); Status status = stream.init(-1, nullptr, false); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Initial buffer should be small. EXPECT_LT(stream.bytes_in_mem(false), buffer_size); @@ -589,27 +589,27 @@ TEST_F(SimpleTupleStreamTest, SmallBuffers) { for (int i = 0; i < batch->num_rows(); ++i) { bool ret = stream.add_row(batch->get_row(i), &status); EXPECT_TRUE(ret); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } EXPECT_LT(stream.bytes_in_mem(false), buffer_size); EXPECT_LT(stream.byte_size(), buffer_size); - ASSERT_TRUE(stream.using_small_buffers()); + EXPECT_TRUE(stream.using_small_buffers()); // 40 MB of ints batch = CreateIntBatch(0, 10 * 1024 * 1024, false); for (int i = 0; i < batch->num_rows(); ++i) { bool ret = stream.add_row(batch->get_row(i), &status); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); if (!ret) { - ASSERT_TRUE(stream.using_small_buffers()); + EXPECT_TRUE(stream.using_small_buffers()); bool got_buffer; status = stream.switch_to_io_buffers(&got_buffer); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(got_buffer); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(got_buffer); ret = stream.add_row(batch->get_row(i), &status); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } - ASSERT_TRUE(ret); + EXPECT_TRUE(ret); } EXPECT_EQ(stream.bytes_in_mem(false), buffer_size); @@ -773,8 +773,8 @@ TEST_F(ArrayTupleStreamTest, TestArrayDeepCopy) { // Check that internal row size computation gives correct result. EXPECT_EQ(expected_row_size, stream.ComputeRowSize(row.get())); bool b = stream.add_row(row.get(), &status); - ASSERT_TRUE(b); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(b); + EXPECT_TRUE(status.ok()); _mem_pool->FreeAll(); // Free data as soon as possible to smoke out issues. } @@ -787,34 +787,34 @@ TEST_F(ArrayTupleStreamTest, TestArrayDeepCopy) { RowBatch batch(*_array_desc, BATCH_SIZE, _tracker.get()); do { batch.reset(); - ASSERT_TRUE(stream.get_next(&batch, &eos).ok()); + EXPECT_TRUE(stream.get_next(&batch, &eos).ok()); for (int i = 0; i < batch.num_rows(); ++i) { TupleRow* row = batch.GetRow(i); Tuple* tuple0 = row->get_tuple(0); Tuple* tuple1 = row->get_tuple(1); - ASSERT_TRUE(tuple0 != nullptr); - ASSERT_TRUE(tuple1 != nullptr); + EXPECT_TRUE(tuple0 != nullptr); + EXPECT_TRUE(tuple1 != nullptr); const SlotDescriptor* array_slot_desc = tuple_descs[0]->slots()[0]; - ASSERT_FALSE(tuple0->IsNull(array_slot_desc->null_indicator_offset())); - ASSERT_TRUE(tuple0->IsNull(tuple_descs[0]->slots()[1]->null_indicator_offset())); - ASSERT_TRUE(tuple1->IsNull(tuple_descs[1]->slots()[0]->null_indicator_offset())); + EXPECT_FALSE(tuple0->IsNull(array_slot_desc->null_indicator_offset())); + EXPECT_TRUE(tuple0->IsNull(tuple_descs[0]->slots()[1]->null_indicator_offset())); + EXPECT_TRUE(tuple1->IsNull(tuple_descs[1]->slots()[0]->null_indicator_offset())); const TupleDescriptor* item_desc = array_slot_desc->collection_item_descriptor(); int expected_array_len = array_lens[array_len_index++ % num_array_lens]; CollectionValue* cv = tuple0->GetCollectionSlot(array_slot_desc->tuple_offset()); - ASSERT_EQ(expected_array_len, cv->num_tuples); + EXPECT_EQ(expected_array_len, cv->num_tuples); for (int j = 0; j < cv->num_tuples; ++j) { Tuple* item = reinterpret_cast(cv->ptr + j * item_desc->byte_size()); const SlotDescriptor* string_desc = item_desc->slots()[0]; - ASSERT_FALSE(item->IsNull(string_desc->null_indicator_offset())); + EXPECT_FALSE(item->IsNull(string_desc->null_indicator_offset())); const StringValue* expected = &STRINGS[strings_index++ % NUM_STRINGS]; const StringValue* actual = item->GetStringSlot(string_desc->tuple_offset()); - ASSERT_EQ(*expected, *actual); + EXPECT_EQ(*expected, *actual); } } rows_read += batch.num_rows(); } while (!eos); - ASSERT_EQ(NUM_ROWS, rows_read); + EXPECT_EQ(NUM_ROWS, rows_read); } #endif @@ -822,25 +822,3 @@ TEST_F(ArrayTupleStreamTest, TestArrayDeepCopy) { // - The stream can operate in many modes } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::config::query_scratch_dirs = "/tmp"; - // doris::config::max_free_io_buffers = 128; - doris::config::read_size = 8388608; - doris::config::min_buffer_size = 1024; - - doris::config::disable_mem_pools = false; - - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::CpuInfo::init(); - doris::DiskInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/buffered_tuple_stream_test.cpp b/be/test/runtime/buffered_tuple_stream_test.cpp index 6cb7c1bf13..085200b163 100644 --- a/be/test/runtime/buffered_tuple_stream_test.cpp +++ b/be/test/runtime/buffered_tuple_stream_test.cpp @@ -195,7 +195,7 @@ TEST_F(BufferedTupleStreamTest, init_bufferStream) { BufferedTupleStream* input_stream = new BufferedTupleStream(_runtime_state, *_child_row_desc, _runtime_state->block_mgr()); Status status = input_stream->init(_profile); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); input_stream->close(); delete input_stream; } @@ -204,15 +204,15 @@ TEST_F(BufferedTupleStreamTest, addRow_bufferStream) { BufferedTupleStream* input_stream = new BufferedTupleStream(_runtime_state, *_child_row_desc, _runtime_state->block_mgr()); Status status = input_stream->init(_profile); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num_rows = 5; RowBatch* batch = create_row_batch(num_rows); for (int i = 0; i < num_rows; i++) { TupleRow* row = batch->GetRow(i); input_stream->add_row(row); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } - ASSERT_EQ(input_stream->num_rows(), num_rows); + EXPECT_EQ(input_stream->num_rows(), num_rows); input_stream->close(); delete input_stream; } @@ -221,51 +221,45 @@ TEST_F(BufferedTupleStreamTest, getNext_bufferStream) { BufferedTupleStream* input_stream = new BufferedTupleStream(_runtime_state, *_child_row_desc, _runtime_state->block_mgr()); Status status = input_stream->init(_profile); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); int num_rows = 5; RowBatch* batch = create_row_batch(num_rows * 2); for (int i = 0; i < num_rows * 2; i++) { TupleRow* row = batch->GetRow(i); input_stream->add_row(row); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } - ASSERT_EQ(input_stream->num_rows(), num_rows * 2); + EXPECT_EQ(input_stream->num_rows(), num_rows * 2); RowBatch output_batch(*_child_row_desc, num_rows); bool eos; status = input_stream->get_next(&output_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); - ASSERT_EQ("[(0)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); - ASSERT_EQ("[(1)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); - ASSERT_EQ("[(2)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); + EXPECT_EQ("[(0)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); + EXPECT_EQ("[(1)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); + EXPECT_EQ("[(2)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); output_batch.Reset(); status = input_stream->get_next(&output_batch, &eos); - ASSERT_TRUE(status.ok()); - ASSERT_EQ("[(5)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); - ASSERT_EQ("[(6)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); - ASSERT_EQ("[(7)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); - ASSERT_EQ("[(8)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); - ASSERT_EQ("[(9)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); + EXPECT_TRUE(status.ok()); + EXPECT_EQ("[(5)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); + EXPECT_EQ("[(6)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); + EXPECT_EQ("[(7)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); + EXPECT_EQ("[(8)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); + EXPECT_EQ("[(9)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); - ASSERT_EQ(input_stream->rows_returned(), num_rows * 2); + EXPECT_EQ(input_stream->rows_returned(), num_rows * 2); input_stream->close(); delete input_stream; } } // namespace doris -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - impala::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} - -/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */ +\n \ No newline at end of file diff --git a/be/test/runtime/cache/partition_cache_test.cpp b/be/test/runtime/cache/partition_cache_test.cpp index ebd295301b..7a66c75912 100644 --- a/be/test/runtime/cache/partition_cache_test.cpp +++ b/be/test/runtime/cache/partition_cache_test.cpp @@ -21,7 +21,7 @@ #include "gen_cpp/internal_service.pb.h" #include "runtime/buffer_control_block.h" #include "runtime/cache/result_cache.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/cpu_info.h" #include "util/logging.h" @@ -115,7 +115,7 @@ PCacheStatus PartitionCacheTest::init_batch_data(int sql_num, int part_begin, in TEST_F(PartitionCacheTest, update_data) { init_default(); PCacheStatus st = init_batch_data(1, 1, 1, CacheType::SQL_CACHE); - ASSERT_TRUE(st == PCacheStatus::CACHE_OK); + EXPECT_TRUE(st == PCacheStatus::CACHE_OK); LOG(WARNING) << "clear cache"; clear(); } @@ -124,7 +124,7 @@ TEST_F(PartitionCacheTest, update_over_partition) { init_default(); PCacheStatus st = init_batch_data(1, 1, config::query_cache_max_partition_count + 1, CacheType::PARTITION_CACHE); - ASSERT_TRUE(st == PCacheStatus::PARAM_ERROR); + EXPECT_TRUE(st == PCacheStatus::PARAM_ERROR); clear(); } @@ -132,7 +132,7 @@ TEST_F(PartitionCacheTest, cache_clear) { init_default(); init_batch_data(1, 1, 1, CacheType::SQL_CACHE); _cache->clear(_clear_request, _clear_response); - ASSERT_EQ(_cache->get_cache_size(), 0); + EXPECT_EQ(_cache->get_cache_size(), 0); clear(); } @@ -149,9 +149,9 @@ TEST_F(PartitionCacheTest, fetch_simple_data) { LOG(WARNING) << "begin fetch\n"; _cache->fetch(_fetch_request, _fetch_result); LOG(WARNING) << "finish fetch1\n"; - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); - ASSERT_EQ(_fetch_result->values_size(), 1); - ASSERT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); + EXPECT_EQ(_fetch_result->values_size(), 1); + EXPECT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); LOG(WARNING) << "finish fetch2\n"; clear(); @@ -168,7 +168,7 @@ TEST_F(PartitionCacheTest, fetch_not_sqlid) { p1->set_last_version(1); p1->set_last_version_time(1); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::NO_SQL_KEY); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::NO_SQL_KEY); clear(); } @@ -188,8 +188,8 @@ TEST_F(PartitionCacheTest, fetch_range_data) { p2->set_last_version_time(3); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); - ASSERT_EQ(_fetch_result->values_size(), 2); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); + EXPECT_EQ(_fetch_result->values_size(), 2); clear(); } @@ -209,8 +209,8 @@ TEST_F(PartitionCacheTest, fetch_invalid_right_range) { p2->set_last_version_time(5); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); - ASSERT_EQ(_fetch_result->values_size(), 0); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); + EXPECT_EQ(_fetch_result->values_size(), 0); clear(); } @@ -225,8 +225,8 @@ TEST_F(PartitionCacheTest, fetch_invalid_left_range) { p1->set_last_version_time(0); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); - ASSERT_EQ(_fetch_result->values_size(), 0); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); + EXPECT_EQ(_fetch_result->values_size(), 0); clear(); } @@ -250,8 +250,8 @@ TEST_F(PartitionCacheTest, fetch_invalid_key_range) { p3->set_last_version(3); p3->set_last_version_time(3); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::INVALID_KEY_RANGE); - ASSERT_EQ(_fetch_result->values_size(), 0); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::INVALID_KEY_RANGE); + EXPECT_EQ(_fetch_result->values_size(), 0); clear(); } @@ -269,8 +269,8 @@ TEST_F(PartitionCacheTest, fetch_data_overdue) { LOG(WARNING) << "fetch_data_overdue:" << _fetch_result->status(); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::DATA_OVERDUE); - ASSERT_EQ(_fetch_result->values_size(), 0); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::DATA_OVERDUE); + EXPECT_EQ(_fetch_result->values_size(), 0); clear(); } @@ -279,7 +279,7 @@ TEST_F(PartitionCacheTest, prune_data) { init(1, 1); init_batch_data(LOOP_LESS_OR_MORE(10, 129), 1, 1024, CacheType::PARTITION_CACHE); // 16*1024*128=2M - ASSERT_LE(_cache->get_cache_size(), 1 * 1024 * 1024); //cache_size <= 1M + EXPECT_LE(_cache->get_cache_size(), 1 * 1024 * 1024); //cache_size <= 1M clear(); } @@ -301,10 +301,10 @@ TEST_F(PartitionCacheTest, fetch_not_continue_partition) { p3->set_last_version(1); p3->set_last_version_time(1); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); - ASSERT_EQ(_fetch_result->values_size(), 2); - ASSERT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); - ASSERT_EQ(_fetch_result->values(1).rows(0), "0123456789abcdef"); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); + EXPECT_EQ(_fetch_result->values_size(), 2); + EXPECT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); + EXPECT_EQ(_fetch_result->values(1).rows(0), "0123456789abcdef"); clear(); } @@ -317,9 +317,9 @@ TEST_F(PartitionCacheTest, update_sql_cache) { p1->set_last_version(1); p1->set_last_version_time(1); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); - ASSERT_EQ(_fetch_result->values_size(), 1); - ASSERT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::CACHE_OK); + EXPECT_EQ(_fetch_result->values_size(), 1); + EXPECT_EQ(_fetch_result->values(0).rows(0), "0123456789abcdef"); // update sql cache and fetch cache again init_batch_data(1, 2, 1, CacheType::SQL_CACHE); set_sql_key(_fetch_request->mutable_sql_key(), 1, 1); @@ -328,21 +328,10 @@ TEST_F(PartitionCacheTest, update_sql_cache) { p1->set_last_version(1); p1->set_last_version_time(1); _cache->fetch(_fetch_request, _fetch_result); - ASSERT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); + EXPECT_TRUE(_fetch_result->status() == PCacheStatus::NO_PARTITION_KEY); clear(); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} /* vim: set ts=4 sw=4 sts=4 tw=100 */ diff --git a/be/test/runtime/collection_value_test.cpp b/be/test/runtime/collection_value_test.cpp index b9825b984e..60d199428a 100644 --- a/be/test/runtime/collection_value_test.cpp +++ b/be/test/runtime/collection_value_test.cpp @@ -65,7 +65,7 @@ TEST(CollectionValueTest, set) { cv.set(0, TYPE_INT, &v0); for (int j = 1; j < cv.size(); ++j) { IntVal i(j + 10); - ASSERT_TRUE(cv.set(j, TYPE_INT, &i).ok()); + EXPECT_TRUE(cv.set(j, TYPE_INT, &i).ok()); } } @@ -73,8 +73,8 @@ TEST(CollectionValueTest, set) { auto iter = cv.iterator(TYPE_INT); IntVal v0; iter.value(&v0); - ASSERT_TRUE(v0.is_null); - ASSERT_TRUE(iter.is_null()); + EXPECT_TRUE(v0.is_null); + EXPECT_TRUE(iter.is_null()); iter.next(); for (int k = 1; k < cv.size(); ++k, iter.next()) { IntVal v; @@ -86,12 +86,7 @@ TEST(CollectionValueTest, set) { // over size { IntVal intv(20); - ASSERT_FALSE(cv.set(10, TYPE_INT, &intv).ok()); + EXPECT_FALSE(cv.set(10, TYPE_INT, &intv).ok()); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/runtime/data_spliter_test.cpp b/be/test/runtime/data_spliter_test.cpp index 073ac365ce..1f0ab50c5c 100644 --- a/be/test/runtime/data_spliter_test.cpp +++ b/be/test/runtime/data_spliter_test.cpp @@ -176,19 +176,3 @@ void DataSplitTest::init_desc_tbl() { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - // 覆盖be.conf中的配置 - doris::config::storage_root_path = "./test_run/mini_load"; - doris::FileUtils::create_dir(doris::config::storage_root_path); - doris::touch_all_singleton(); - - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/data_stream_test.cpp b/be/test/runtime/data_stream_test.cpp index e6d4a7af5d..39d7cba249 100644 --- a/be/test/runtime/data_stream_test.cpp +++ b/be/test/runtime/data_stream_test.cpp @@ -680,27 +680,3 @@ TEST_F(DataStreamTest, BasicTest) { // - receivers getting created concurrently } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. conffile path= %s\n", conffile.c_str()); - // return -1; - // } - doris::config::query_scratch_dirs = "/tmp"; - doris::config::max_free_io_buffers = 128; - doris::config::disable_mem_pools = false; - doris::config::min_buffer_size = 1024; - doris::config::read_size = 8388608; - doris::config::port = 2001; - doris::config::thrift_connect_timeout_seconds = 20; - - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::CpuInfo::init(); - doris::DiskInfo::init(); - doris::MemInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/datetime_value_test.cpp b/be/test/runtime/datetime_value_test.cpp index da0053ab18..f6bea60c81 100644 --- a/be/test/runtime/datetime_value_test.cpp +++ b/be/test/runtime/datetime_value_test.cpp @@ -38,7 +38,7 @@ protected: // Assert size TEST_F(DateTimeValueTest, struct_size) { - ASSERT_EQ(16, sizeof(DateTimeValue)); + EXPECT_EQ(16, sizeof(DateTimeValue)); } TEST_F(DateTimeValueTest, equal) { @@ -47,49 +47,49 @@ TEST_F(DateTimeValueTest, equal) { DateTimeValue value2; value2.from_date_int64(19880201); - ASSERT_TRUE(value1 == value2); - ASSERT_TRUE(value1 <= value2); - ASSERT_TRUE(value1 >= value2); - ASSERT_FALSE(value1 < value2); - ASSERT_FALSE(value1 > value2); + EXPECT_TRUE(value1 == value2); + EXPECT_TRUE(value1 <= value2); + EXPECT_TRUE(value1 >= value2); + EXPECT_FALSE(value1 < value2); + EXPECT_FALSE(value1 > value2); value2.from_date_int64(19880201000000); - ASSERT_TRUE(value1 == value2); - ASSERT_TRUE(value1 <= value2); - ASSERT_TRUE(value1 >= value2); - ASSERT_FALSE(value1 < value2); - ASSERT_FALSE(value1 > value2); + EXPECT_TRUE(value1 == value2); + EXPECT_TRUE(value1 <= value2); + EXPECT_TRUE(value1 >= value2); + EXPECT_FALSE(value1 < value2); + EXPECT_FALSE(value1 > value2); value2.from_date_int64(19880202); - ASSERT_TRUE(value1 != value2); - ASSERT_TRUE(value1 <= value2); - ASSERT_TRUE(value1 < value2); - ASSERT_FALSE(value1 >= value2); - ASSERT_FALSE(value1 > value2); + EXPECT_TRUE(value1 != value2); + EXPECT_TRUE(value1 <= value2); + EXPECT_TRUE(value1 < value2); + EXPECT_FALSE(value1 >= value2); + EXPECT_FALSE(value1 > value2); value2.from_date_int64(19880131); - ASSERT_TRUE(value1 != value2); - ASSERT_TRUE(value1 > value2); - ASSERT_TRUE(value1 >= value2); - ASSERT_FALSE(value1 < value2); - ASSERT_FALSE(value1 <= value2); + EXPECT_TRUE(value1 != value2); + EXPECT_TRUE(value1 > value2); + EXPECT_TRUE(value1 >= value2); + EXPECT_FALSE(value1 < value2); + EXPECT_FALSE(value1 <= value2); std::string test_str = "1988-02-01 00:00:00.12345"; value2.from_date_str(test_str.c_str(), test_str.size()); - ASSERT_TRUE(value1 != value2); - ASSERT_TRUE(value1 < value2); - ASSERT_TRUE(value1 <= value2); - ASSERT_FALSE(value1 > value2); - ASSERT_FALSE(value1 >= value2); + EXPECT_TRUE(value1 != value2); + EXPECT_TRUE(value1 < value2); + EXPECT_TRUE(value1 <= value2); + EXPECT_FALSE(value1 > value2); + EXPECT_FALSE(value1 >= value2); } // Test check range TEST_F(DateTimeValueTest, day_of_year) { DateTimeValue value; value.from_date_int64(20070101); - ASSERT_EQ(1, value.day_of_year()); + EXPECT_EQ(1, value.day_of_year()); value.from_date_int64(20070203); - ASSERT_EQ(34, value.day_of_year()); + EXPECT_EQ(34, value.day_of_year()); } // Test check range @@ -105,32 +105,32 @@ TEST_F(DateTimeValueTest, random_convert) { DateTimeValue* value = (DateTimeValue*)buf; value->from_date_daynr(366); value_check.from_date_daynr(366); - ASSERT_STREQ("0001-01-01", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("0001-01-01", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); value = (DateTimeValue*)&buf[5]; value->from_date_str("19880201", 8); value_check.from_date_str("19880201", 8); - ASSERT_STREQ("1988-02-01", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("1988-02-01", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); value = (DateTimeValue*)&buf[10]; value->from_date_format_str("%Y%m%d", 6, "19880201", 8); value_check.from_date_format_str("%Y%m%d", 6, "19880201", 8); - ASSERT_STREQ("1988-02-01", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("1988-02-01", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); value = (DateTimeValue*)&buf[15]; value->from_date_int64(19880201); value_check.from_date_int64(19880201); - ASSERT_STREQ("1988-02-01", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("1988-02-01", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); value = (DateTimeValue*)&buf[20]; value->from_olap_datetime(19880201235959); value_check.from_date_int64(19880201235959); - ASSERT_STREQ("1988-02-01 23:59:59", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("1988-02-01 23:59:59", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); value = (DateTimeValue*)&buf[30]; uint64_t date = 0; @@ -141,8 +141,8 @@ TEST_F(DateTimeValueTest, random_convert) { date |= 1; value->from_olap_date(date); value_check.from_date_int64(19880201); - ASSERT_STREQ("1988-02-01", value->debug_string().c_str()); - ASSERT_FALSE(memcmp(value, &value_check, sizeof(value_check))); + EXPECT_STREQ("1988-02-01", value->debug_string().c_str()); + EXPECT_FALSE(memcmp(value, &value_check, sizeof(value_check))); } // Test check range @@ -154,14 +154,14 @@ TEST_F(DateTimeValueTest, construct_int64) { DateTimeValue value1(19880201); value1.to_string(buf); - ASSERT_STREQ("1988-02-01", buf); - ASSERT_TRUE(value == value1); + EXPECT_STREQ("1988-02-01", buf); + EXPECT_TRUE(value == value1); value.from_date_int64(19880201123456); DateTimeValue value2(19880201123456); value2.to_string(buf); - ASSERT_STREQ("1988-02-01 12:34:56", buf); - ASSERT_TRUE(value == value2); + EXPECT_STREQ("1988-02-01 12:34:56", buf); + EXPECT_TRUE(value == value2); } // Test check range @@ -172,14 +172,14 @@ TEST_F(DateTimeValueTest, acc) { value.from_date_int64(19880201); ++value; value.to_string(buf); - ASSERT_STREQ("1988-02-02", buf); + EXPECT_STREQ("1988-02-02", buf); value.from_date_int64(19880131235959); value.to_string(buf); - ASSERT_STREQ("1988-01-31 23:59:59", buf); + EXPECT_STREQ("1988-01-31 23:59:59", buf); ++value; value.to_string(buf); - ASSERT_STREQ("1988-02-01 00:00:00", buf); + EXPECT_STREQ("1988-02-01 00:00:00", buf); } // Test check range @@ -191,70 +191,83 @@ TEST_F(DateTimeValueTest, local_time) { // Test check range TEST_F(DateTimeValueTest, check_range) { DateTimeValue value; - ASSERT_TRUE(value.from_date_int64(19880201123456)); + EXPECT_TRUE(value.from_date_int64(19880201123456)); value._year = 10000; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._year = 1988; value._month = 13; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._month = 2; value._day = 32; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._day = 1; value._hour = TIME_MAX_HOUR; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._type = TIME_TIME; - ASSERT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._hour = TIME_MAX_HOUR + 1; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._type = TIME_DATETIME; value._hour = 12; value._minute = 60; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._minute = 34; value._second = 60; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._second = 56; value._microsecond = 1000000; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._month = 0; } TEST_F(DateTimeValueTest, check_date) { DateTimeValue value; - ASSERT_TRUE(value.from_date_int64(19880201)); + EXPECT_TRUE(value.from_date_int64(19880201)); value._month = 0; - ASSERT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._month = 2; value._day = 0; - ASSERT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._year = 1987; value._day = 29; - ASSERT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_TRUE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); value._year = 2000; - ASSERT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), - value.hour(), value.minute(), value.second(), value.microsecond(), value.type())); + EXPECT_FALSE(DateTimeValue::check_range(value.year(), value.month(), value.day(), value.hour(), + value.minute(), value.second(), value.microsecond(), + value.type())); } // Calculate format @@ -265,38 +278,38 @@ TEST_F(DateTimeValueTest, week) { // 0000-01-01 date_str = "0000-01-01"; value.from_date_str(date_str.c_str(), date_str.size()); - ASSERT_EQ(1, value.week(mysql_week_mode(0))); - ASSERT_EQ(0, value.week(mysql_week_mode(1))); - ASSERT_EQ(1, value.week(mysql_week_mode(2))); - ASSERT_EQ(52, value.week(mysql_week_mode(3))); - ASSERT_EQ(1, value.week(mysql_week_mode(4))); - ASSERT_EQ(0, value.week(mysql_week_mode(5))); - ASSERT_EQ(1, value.week(mysql_week_mode(6))); - ASSERT_EQ(52, value.week(mysql_week_mode(7))); + EXPECT_EQ(1, value.week(mysql_week_mode(0))); + EXPECT_EQ(0, value.week(mysql_week_mode(1))); + EXPECT_EQ(1, value.week(mysql_week_mode(2))); + EXPECT_EQ(52, value.week(mysql_week_mode(3))); + EXPECT_EQ(1, value.week(mysql_week_mode(4))); + EXPECT_EQ(0, value.week(mysql_week_mode(5))); + EXPECT_EQ(1, value.week(mysql_week_mode(6))); + EXPECT_EQ(52, value.week(mysql_week_mode(7))); // 2013-12-31 date_str = "2013-12-31"; value.from_date_str(date_str.c_str(), date_str.size()); - ASSERT_EQ(52, value.week(mysql_week_mode(0))); - ASSERT_EQ(53, value.week(mysql_week_mode(1))); - ASSERT_EQ(52, value.week(mysql_week_mode(2))); - ASSERT_EQ(1, value.week(mysql_week_mode(3))); - ASSERT_EQ(53, value.week(mysql_week_mode(4))); - ASSERT_EQ(52, value.week(mysql_week_mode(5))); - ASSERT_EQ(1, value.week(mysql_week_mode(6))); - ASSERT_EQ(52, value.week(mysql_week_mode(7))); + EXPECT_EQ(52, value.week(mysql_week_mode(0))); + EXPECT_EQ(53, value.week(mysql_week_mode(1))); + EXPECT_EQ(52, value.week(mysql_week_mode(2))); + EXPECT_EQ(1, value.week(mysql_week_mode(3))); + EXPECT_EQ(53, value.week(mysql_week_mode(4))); + EXPECT_EQ(52, value.week(mysql_week_mode(5))); + EXPECT_EQ(1, value.week(mysql_week_mode(6))); + EXPECT_EQ(52, value.week(mysql_week_mode(7))); // 1988-02-01 date_str = "1988-02-01"; value.from_date_str(date_str.c_str(), date_str.size()); - ASSERT_EQ(5, value.week(mysql_week_mode(0))); - ASSERT_EQ(5, value.week(mysql_week_mode(1))); - ASSERT_EQ(5, value.week(mysql_week_mode(2))); - ASSERT_EQ(5, value.week(mysql_week_mode(3))); - ASSERT_EQ(5, value.week(mysql_week_mode(4))); - ASSERT_EQ(5, value.week(mysql_week_mode(5))); - ASSERT_EQ(5, value.week(mysql_week_mode(6))); - ASSERT_EQ(5, value.week(mysql_week_mode(7))); + EXPECT_EQ(5, value.week(mysql_week_mode(0))); + EXPECT_EQ(5, value.week(mysql_week_mode(1))); + EXPECT_EQ(5, value.week(mysql_week_mode(2))); + EXPECT_EQ(5, value.week(mysql_week_mode(3))); + EXPECT_EQ(5, value.week(mysql_week_mode(4))); + EXPECT_EQ(5, value.week(mysql_week_mode(5))); + EXPECT_EQ(5, value.week(mysql_week_mode(6))); + EXPECT_EQ(5, value.week(mysql_week_mode(7))); } // Calculate format @@ -306,18 +319,18 @@ TEST_F(DateTimeValueTest, from_unixtime) { value.from_unixtime(570672000, TimezoneUtils::default_time_zone); value.to_string(str); - ASSERT_STREQ("1988-02-01 08:00:00", str); + EXPECT_STREQ("1988-02-01 08:00:00", str); value.from_unixtime(253402271999, TimezoneUtils::default_time_zone); value.to_string(str); - ASSERT_STREQ("9999-12-31 23:59:59", str); + EXPECT_STREQ("9999-12-31 23:59:59", str); value.from_unixtime(0, TimezoneUtils::default_time_zone); value.to_string(str); - ASSERT_STREQ("1970-01-01 08:00:00", str); + EXPECT_STREQ("1970-01-01 08:00:00", str); - ASSERT_FALSE(value.from_unixtime(1586098092, "+20:00")); - ASSERT_FALSE(value.from_unixtime(1586098092, "foo")); + EXPECT_FALSE(value.from_unixtime(1586098092, "+20:00")); + EXPECT_FALSE(value.from_unixtime(1586098092, "foo")); } // Calculate format @@ -326,26 +339,26 @@ TEST_F(DateTimeValueTest, unix_timestamp) { int64_t timestamp; value.from_date_int64(19691231); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(-115200, timestamp); + EXPECT_EQ(-115200, timestamp); value.from_date_int64(19700101); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(0 - 28800, timestamp); + EXPECT_EQ(0 - 28800, timestamp); value.from_date_int64(19700102); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(86400 - 28800, timestamp); + EXPECT_EQ(86400 - 28800, timestamp); value.from_date_int64(19880201000000); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(570672000 - 28800, timestamp); + EXPECT_EQ(570672000 - 28800, timestamp); value.from_date_int64(20380119); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(2147472000 - 28800, timestamp); + EXPECT_EQ(2147472000 - 28800, timestamp); value.from_date_int64(20380120); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(2147529600, timestamp); + EXPECT_EQ(2147529600, timestamp); value.from_date_int64(10000101); value.unix_timestamp(×tamp, TimezoneUtils::default_time_zone); - ASSERT_EQ(-30610252800, timestamp); + EXPECT_EQ(-30610252800, timestamp); } // Calculate format @@ -359,61 +372,61 @@ TEST_F(DateTimeValueTest, add_interval) { value.from_date_int64(19880201); interval.microsecond = 1; - ASSERT_TRUE(value.date_add_interval(interval, MICROSECOND)); + EXPECT_TRUE(value.date_add_interval(interval, MICROSECOND)); interval.microsecond = 0; value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:00.000001", str); + EXPECT_STREQ("1988-02-01 00:00:00.000001", str); value.from_date_int64(19880201); interval.second = 1; - ASSERT_TRUE(value.date_add_interval(interval, SECOND)); + EXPECT_TRUE(value.date_add_interval(interval, SECOND)); interval.second = 0; value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:01", str); + EXPECT_STREQ("1988-02-01 00:00:01", str); value.from_date_int64(19880201); interval.minute = 1; - ASSERT_TRUE(value.date_add_interval(interval, MINUTE)); + EXPECT_TRUE(value.date_add_interval(interval, MINUTE)); interval.minute = 0; value.to_string(str); - ASSERT_STREQ("1988-02-01 00:01:00", str); + EXPECT_STREQ("1988-02-01 00:01:00", str); value.from_date_int64(19880201); interval.hour = 1; - ASSERT_TRUE(value.date_add_interval(interval, HOUR)); + EXPECT_TRUE(value.date_add_interval(interval, HOUR)); interval.hour = 0; value.to_string(str); - ASSERT_STREQ("1988-02-01 01:00:00", str); + EXPECT_STREQ("1988-02-01 01:00:00", str); value.from_date_int64(19880201); interval.microsecond = 1; interval.second = 1; - ASSERT_TRUE(value.date_add_interval(interval, SECOND_MICROSECOND)); + EXPECT_TRUE(value.date_add_interval(interval, SECOND_MICROSECOND)); interval.microsecond = 0; interval.second = 0; value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:01.000001", str); + EXPECT_STREQ("1988-02-01 00:00:01.000001", str); value.from_date_int64(19880201); interval.day = 100; - ASSERT_TRUE(value.date_add_interval(interval, DAY)); + EXPECT_TRUE(value.date_add_interval(interval, DAY)); interval.day = 0; value.to_string(str); - ASSERT_STREQ("1988-05-11", str); + EXPECT_STREQ("1988-05-11", str); value.from_date_int64(19880131); interval.month = 97; - ASSERT_TRUE(value.date_add_interval(interval, MONTH)); + EXPECT_TRUE(value.date_add_interval(interval, MONTH)); interval.month = 0; value.to_string(str); - ASSERT_STREQ("1996-02-29", str); + EXPECT_STREQ("1996-02-29", str); value.from_date_int64(19880229); interval.year = 1; - ASSERT_TRUE(value.date_add_interval(interval, YEAR)); + EXPECT_TRUE(value.date_add_interval(interval, YEAR)); interval.year = 0; value.to_string(str); - ASSERT_STREQ("1989-02-28", str); + EXPECT_STREQ("1989-02-28", str); } // Calculate format @@ -427,140 +440,140 @@ TEST_F(DateTimeValueTest, from_date_format_str) { // %Y-%m-%d format_str = "%Y-%m-%d"; value_str = "1988-02-01"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%Y-%M-%d"; value_str = "1988-feb-01"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%Y-%b-%d"; value_str = "1988-feb-01"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%Y%b%d"; value_str = "1988f01"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%y%m%d"; value_str = "880201"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%y%c%d"; value_str = "880201"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); format_str = "%y%c-%e"; value_str = "882-1"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); // %j format_str = "%Y%j %H"; value_str = "198832 03"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 03:00:00", str); + EXPECT_STREQ("1988-02-01 03:00:00", str); // %x format_str = "%X %V %w"; value_str = "2015 1 1"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2015-01-05", str); + EXPECT_STREQ("2015-01-05", str); // %x format_str = "%x %v %w"; value_str = "2015 1 1"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2014-12-29", str); + EXPECT_STREQ("2014-12-29", str); // %x format_str = "%x %v %W"; value_str = "2015 1 Monday"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2014-12-29", str); + EXPECT_STREQ("2014-12-29", str); // %x format_str = "%X %V %a"; value_str = "2015 1 Mon"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2015-01-05", str); + EXPECT_STREQ("2015-01-05", str); // %T format_str = "%X %V %a %r"; value_str = "2015 1 Mon 2:34:56 AM"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2015-01-05 02:34:56", str); + EXPECT_STREQ("2015-01-05 02:34:56", str); // %T format_str = "%X %V %a %T"; value_str = "2015 1 Mon 12:34:56"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2015-01-05 12:34:56", str); + EXPECT_STREQ("2015-01-05 12:34:56", str); // %T format_str = "%W %U %Y"; value_str = "Tuesday 00 2002"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2002-01-01", str); + EXPECT_STREQ("2002-01-01", str); // hour format_str = "%Y-%m-%d %H %i %s"; value_str = "88-2-1 03 4 5"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 03:04:05", str); + EXPECT_STREQ("1988-02-01 03:04:05", str); // escape % format_str = "%Y-%m-%d %H%%3A%i%%3A%s"; value_str = "2020-02-26 00%3A00%3A00"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2020-02-26 00:00:00", str); + EXPECT_STREQ("2020-02-26 00:00:00", str); // escape % format_str = "%Y-%m-%d%%%% %H%%3A%i%%3A%s"; value_str = "2020-02-26%% 00%3A00%3A00"; - ASSERT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), + EXPECT_TRUE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); value.to_string(str); - ASSERT_STREQ("2020-02-26 00:00:00", str); + EXPECT_STREQ("2020-02-26 00:00:00", str); } // Calculate format @@ -572,30 +585,30 @@ TEST_F(DateTimeValueTest, from_date_format_str_invalid) { format_str = "%y%c%e"; value_str = "8821"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); format_str = "%y-%c-%e"; value_str = "8821"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); format_str = "%y%c-%e"; value_str = "882-30"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); // %x format_str = "%X %v %w"; value_str = "2015 1 1"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); format_str = "%x %V %w"; value_str = "2015 1 1"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); format_str = "%Y-%m-%d %H%3A%i%3A%s"; value_str = "2020-02-26 00%3A00%3A00"; - ASSERT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), + EXPECT_FALSE(value.from_date_format_str(format_str.c_str(), format_str.size(), value_str.c_str(), value_str.size())); } // Calculate format @@ -609,300 +622,300 @@ TEST_F(DateTimeValueTest, format_str) { // %a format_str = "%a"; value.from_date_int64(20150215); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("Sun", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("Sun", str); // %b format_str = "%b"; value.from_date_int64(20150215); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("Feb", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("Feb", str); // %c format_str = "%c"; value.from_date_int64(20150215); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2", str); value.from_date_int64(20151215); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("12", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("12", str); // %d format_str = "%d"; value.from_date_int64(20150215); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("15", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("15", str); value.from_date_int64(20150205); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("05", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("05", str); // %D format_str = "%D"; value.from_date_int64(20150201); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("1st", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("1st", str); value.from_date_int64(20150202); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2nd", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2nd", str); value.from_date_int64(20150203); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("3rd", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("3rd", str); value.from_date_int64(20150204); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("4th", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("4th", str); // %e format_str = "%e"; value.from_date_int64(20150201); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("1", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("1", str); value.from_date_int64(20150211); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("11", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("11", str); // %f format_str = "%f"; value.from_date_str("20150201000000.1", 16); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("100000", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("100000", str); value.from_date_str("20150211000000.123456", 21); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("123456", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("123456", str); // %h %I format_str = "%h"; value.from_date_int64(20150201010000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); value.from_date_int64(20150201230000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("11", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("11", str); format_str = "%I"; value.from_date_int64(20150201010000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); value.from_date_int64(20150201230000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("11", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("11", str); // %H format_str = "%H"; value.from_date_int64(20150201010000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); value.from_date_int64(20150201230000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("23", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("23", str); // %i format_str = "%i"; value.from_date_int64(20150201010000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("00", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("00", str); value.from_date_int64(20150201235900L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("59", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("59", str); // %j format_str = "%j"; value.from_date_int64(20150201L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("032", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("032", str); value.from_date_int64(20151231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("365", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("365", str); // %k format_str = "%k"; value.from_date_int64(20150201000000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("0", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("0", str); value.from_date_int64(20150201230000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("23", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("23", str); // %l format_str = "%l"; value.from_date_int64(20150201010000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("1", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("1", str); value.from_date_int64(20150201230000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("11", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("11", str); // %m format_str = "%m"; value.from_date_int64(20150201); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("02", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("02", str); // %M format_str = "%M"; value.from_date_int64(20150201); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("February", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("February", str); // %p format_str = "%p"; value.from_date_int64(20150201000000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("AM", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("AM", str); value.from_date_int64(20150201120000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("PM", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("PM", str); // %r format_str = "%r"; value.from_date_int64(20150201023456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("02:34:56 AM", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("02:34:56 AM", str); value.from_date_int64(20150201003456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("12:34:56 AM", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("12:34:56 AM", str); value.from_date_int64(20150201123456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("12:34:56 PM", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("12:34:56 PM", str); // %s & %S format_str = "%s"; value.from_date_int64(20150201023456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("56", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("56", str); value.from_date_int64(20150201023406L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("06", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("06", str); format_str = "%S"; value.from_date_int64(20150201023456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("56", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("56", str); value.from_date_int64(20150201023406L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("06", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("06", str); // %T format_str = "%T"; value.from_date_int64(20150201023456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("02:34:56", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("02:34:56", str); value.from_date_int64(20150201003456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("00:34:56", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("00:34:56", str); value.from_date_int64(20150201123456L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("12:34:56", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("12:34:56", str); // %u format_str = "%u"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("53", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("53", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); // %U format_str = "%U"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("52", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("52", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("00", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("00", str); // %v format_str = "%v"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("01", str); // %V format_str = "%V"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("52", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("52", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("52", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("52", str); // %w format_str = "%w"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("4", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("4", str); // %W format_str = "%W"; value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("Tuesday", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("Tuesday", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("Thursday", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("Thursday", str); // %x format_str = "%x"; value.from_date_str("0000-01-01", 10); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("4294967295", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("4294967295", str); value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2014", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2014", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2015", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2015", str); // %X format_str = "%X"; value.from_date_str("0000-01-01", 10); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("0000", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("0000", str); value.from_date_int64(20131231L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2013", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2013", str); value.from_date_int64(20150101); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2014", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2014", str); // %y format_str = "%y"; value.from_date_int64(20150201000000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("15", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("15", str); value.from_date_str("0005.0201120000", 17); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("05", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("05", str); // %Y format_str = "%Y"; value.from_date_int64(20150201000000L); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("2015", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("2015", str); value.from_date_str("0015.0201120000", 17); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("0015", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("0015", str); // %Y%m%a format_str = "this is %Y-%m-%d"; value.from_date_int64(19880201); - ASSERT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); - ASSERT_STREQ("this is 1988-02-01", str); + EXPECT_TRUE(value.to_format_string(format_str.c_str(), format_str.size(), str)); + EXPECT_STREQ("this is 1988-02-01", str); } // Calculate weekday TEST_F(DateTimeValueTest, weekday) { DateTimeValue value; // NORMAL CASE - ASSERT_TRUE(value.from_date_int64(101)); - ASSERT_TRUE(value.from_date_daynr(6)); + EXPECT_TRUE(value.from_date_int64(101)); + EXPECT_TRUE(value.from_date_daynr(6)); // NORMAL CASE - ASSERT_TRUE(value.from_date_int64(20150215)); - ASSERT_TRUE(value.from_date_daynr(6)); + EXPECT_TRUE(value.from_date_int64(20150215)); + EXPECT_TRUE(value.from_date_daynr(6)); } // Calculate from daynr @@ -912,54 +925,54 @@ TEST_F(DateTimeValueTest, calc_form_daynr) { DateTimeValue value; // NORMAL CASE - ASSERT_TRUE(value.from_date_daynr(1)); + EXPECT_TRUE(value.from_date_daynr(1)); value.to_string(str); - ASSERT_STREQ("0000-01-01", str); - ASSERT_TRUE(value.from_date_daynr(59)); + EXPECT_STREQ("0000-01-01", str); + EXPECT_TRUE(value.from_date_daynr(59)); value.to_string(str); - ASSERT_STREQ("0000-02-28", str); - ASSERT_TRUE(value.from_date_daynr(60)); + EXPECT_STREQ("0000-02-28", str); + EXPECT_TRUE(value.from_date_daynr(60)); value.to_string(str); - ASSERT_STREQ("0000-03-01", str); - ASSERT_TRUE(value.from_date_daynr(365)); + EXPECT_STREQ("0000-03-01", str); + EXPECT_TRUE(value.from_date_daynr(365)); value.to_string(str); - ASSERT_STREQ("0000-12-31", str); - ASSERT_TRUE(value.from_date_daynr(366)); + EXPECT_STREQ("0000-12-31", str); + EXPECT_TRUE(value.from_date_daynr(366)); value.to_string(str); - ASSERT_STREQ("0001-01-01", str); - ASSERT_TRUE(value.from_date_daynr(1520)); + EXPECT_STREQ("0001-01-01", str); + EXPECT_TRUE(value.from_date_daynr(1520)); value.to_string(str); - ASSERT_STREQ("0004-02-29", str); - ASSERT_TRUE(value.from_date_daynr(1519)); + EXPECT_STREQ("0004-02-29", str); + EXPECT_TRUE(value.from_date_daynr(1519)); value.to_string(str); - ASSERT_STREQ("0004-02-28", str); - ASSERT_TRUE(value.from_date_daynr(1521)); + EXPECT_STREQ("0004-02-28", str); + EXPECT_TRUE(value.from_date_daynr(1521)); value.to_string(str); - ASSERT_STREQ("0004-03-01", str); - ASSERT_TRUE(value.from_date_daynr(726133)); + EXPECT_STREQ("0004-03-01", str); + EXPECT_TRUE(value.from_date_daynr(726133)); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); - ASSERT_TRUE(value.from_date_daynr(3652424)); + EXPECT_STREQ("1988-02-01", str); + EXPECT_TRUE(value.from_date_daynr(3652424)); value.to_string(str); - ASSERT_STREQ("9999-12-31", str); + EXPECT_STREQ("9999-12-31", str); // BAD CASE - ASSERT_FALSE(value.from_date_daynr(0)); - ASSERT_FALSE(value.from_date_daynr(3652425)); - ASSERT_FALSE(value.from_date_daynr(36524251)); + EXPECT_FALSE(value.from_date_daynr(0)); + EXPECT_FALSE(value.from_date_daynr(3652425)); + EXPECT_FALSE(value.from_date_daynr(36524251)); } // Calculate daynr TEST_F(DateTimeValueTest, calc_daynr) { - ASSERT_EQ(0, DateTimeValue::calc_daynr(0, 0, 1)); - ASSERT_EQ(1, DateTimeValue::calc_daynr(0, 1, 1)); - ASSERT_EQ(365, DateTimeValue::calc_daynr(0, 12, 31)); - ASSERT_EQ(366, DateTimeValue::calc_daynr(1, 1, 1)); - ASSERT_EQ(726133, DateTimeValue::calc_daynr(1988, 2, 1)); + EXPECT_EQ(0, DateTimeValue::calc_daynr(0, 0, 1)); + EXPECT_EQ(1, DateTimeValue::calc_daynr(0, 1, 1)); + EXPECT_EQ(365, DateTimeValue::calc_daynr(0, 12, 31)); + EXPECT_EQ(366, DateTimeValue::calc_daynr(1, 1, 1)); + EXPECT_EQ(726133, DateTimeValue::calc_daynr(1988, 2, 1)); DateTimeValue value; value.from_date_int64(880201); - ASSERT_EQ(726133, value.daynr()); - ASSERT_EQ(726161, DateTimeValue::calc_daynr(1988, 2, 29)); + EXPECT_EQ(726133, value.daynr()); + EXPECT_EQ(726161, DateTimeValue::calc_daynr(1988, 2, 29)); } // Construct from int value @@ -971,87 +984,87 @@ TEST_F(DateTimeValueTest, from_time_str) { DateTimeValue value; // INTERNAL MODE WITH OUT test_str = " 880201"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); test_str = "88020112"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("8802-01-12", str); + EXPECT_STREQ("8802-01-12", str); test_str = "8802011223"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:23:00", str); + EXPECT_STREQ("1988-02-01 12:23:00", str); test_str = "880201122334"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:23:34", str); + EXPECT_STREQ("1988-02-01 12:23:34", str); test_str = "19880201"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); test_str = "1988.020112"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:00:00", str); + EXPECT_STREQ("1988-02-01 12:00:00", str); test_str = "1988.0201123"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:03:00", str); + EXPECT_STREQ("1988-02-01 12:03:00", str); test_str = "1988.020112345"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:34:05", str); + EXPECT_STREQ("1988-02-01 12:34:05", str); test_str = "19880201000000.1234567"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:00.123456", str); + EXPECT_STREQ("1988-02-01 00:00:00.123456", str); test_str = "19880201T000000.1234567"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:00.123456", str); + EXPECT_STREQ("1988-02-01 00:00:00.123456", str); // normal-2 // Delim MODE test_str = "88-02-01"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); test_str = "1988-02-01"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); test_str = "1988-02-01 12"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:00:00", str); + EXPECT_STREQ("1988-02-01 12:00:00", str); test_str = "1988-02-01 12:34"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:34:00", str); + EXPECT_STREQ("1988-02-01 12:34:00", str); test_str = "1988-02-01 12:34:56"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:34:56", str); + EXPECT_STREQ("1988-02-01 12:34:56", str); test_str = "1988-02-01 12:34:56.123"; - ASSERT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_TRUE(value.from_date_str(test_str.c_str(), test_str.size())); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:34:56.123000", str); + EXPECT_STREQ("1988-02-01 12:34:56.123000", str); } TEST_F(DateTimeValueTest, from_time_str_invalid) { @@ -1059,24 +1072,24 @@ TEST_F(DateTimeValueTest, from_time_str_invalid) { DateTimeValue value; test_str = " "; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); test_str = " a"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); // normal-1 test_str = "1988-02-31 00:00:00"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); test_str = "1988-02 01 12:34:56"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); // excede 9999999 test_str = "1988999-02-31 00:00:00"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); test_str = "1988-02-31 100"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); test_str = "1988.02-31 10"; - ASSERT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); + EXPECT_FALSE(value.from_date_str(test_str.c_str(), test_str.size())); } // Construct from int value @@ -1086,34 +1099,34 @@ TEST_F(DateTimeValueTest, from_time_int) { DateTimeValue value; // 59 -> 00:00:59 - ASSERT_TRUE(value.from_time_int64(59)); + EXPECT_TRUE(value.from_time_int64(59)); value.to_string(str); - ASSERT_STREQ("00:00:59", str); + EXPECT_STREQ("00:00:59", str); // 5959 -> 00:59:59 - ASSERT_TRUE(value.from_time_int64(5959)); + EXPECT_TRUE(value.from_time_int64(5959)); value.to_string(str); - ASSERT_STREQ("00:59:59", str); + EXPECT_STREQ("00:59:59", str); // 8385959 -> 838:59:59 - ASSERT_TRUE(value.from_time_int64(8385959)); + EXPECT_TRUE(value.from_time_int64(8385959)); value.to_string(str); - ASSERT_STREQ("838:59:59", str); + EXPECT_STREQ("838:59:59", str); // 880201000000 - ASSERT_TRUE(value.from_time_int64(880201000000)); + EXPECT_TRUE(value.from_time_int64(880201000000)); value.to_string(str); - ASSERT_STREQ("1988-02-01 00:00:00", str); + EXPECT_STREQ("1988-02-01 00:00:00", str); } // Construct from int value TEST_F(DateTimeValueTest, from_time_int_invalid) { DateTimeValue value; // 69 - ASSERT_FALSE(value.from_time_int64(69)); + EXPECT_FALSE(value.from_time_int64(69)); // 6959 - ASSERT_FALSE(value.from_time_int64(6959)); + EXPECT_FALSE(value.from_time_int64(6959)); // 9006969 - ASSERT_FALSE(value.from_time_int64(8396969)); + EXPECT_FALSE(value.from_time_int64(8396969)); // 1000132000000 - ASSERT_FALSE(value.from_time_int64(1000132000000)); + EXPECT_FALSE(value.from_time_int64(1000132000000)); } // Construct from int value @@ -1123,80 +1136,80 @@ TEST_F(DateTimeValueTest, from_int_value) { DateTimeValue value; // 101 -> 2000-01-01 - ASSERT_TRUE(value.from_date_int64(101)); + EXPECT_TRUE(value.from_date_int64(101)); value.to_string(str); - ASSERT_STREQ("2000-01-01", str); + EXPECT_STREQ("2000-01-01", str); // 150201 -> 2015-02-01 - ASSERT_TRUE(value.from_date_int64(150201)); + EXPECT_TRUE(value.from_date_int64(150201)); value.to_string(str); - ASSERT_STREQ("2015-02-01", str); + EXPECT_STREQ("2015-02-01", str); // 691231 -> 2069-12-31 - ASSERT_TRUE(value.from_date_int64(691231)); + EXPECT_TRUE(value.from_date_int64(691231)); value.to_string(str); - ASSERT_STREQ("2069-12-31", str); + EXPECT_STREQ("2069-12-31", str); // 700101 -> 1970-01-01 - ASSERT_TRUE(value.from_date_int64(700101)); + EXPECT_TRUE(value.from_date_int64(700101)); value.to_string(str); - ASSERT_STREQ("1970-01-01", str); + EXPECT_STREQ("1970-01-01", str); // 880201 -> 1988-02-01 - ASSERT_TRUE(value.from_date_int64(880201)); + EXPECT_TRUE(value.from_date_int64(880201)); value.to_string(str); - ASSERT_STREQ("1988-02-01", str); + EXPECT_STREQ("1988-02-01", str); // 991231 -> 1999-12-31 - ASSERT_TRUE(value.from_date_int64(991231)); + EXPECT_TRUE(value.from_date_int64(991231)); value.to_string(str); - ASSERT_STREQ("1999-12-31", str); + EXPECT_STREQ("1999-12-31", str); // 10000101 -> 1000-01-01 - ASSERT_TRUE(value.from_date_int64(10000101)); + EXPECT_TRUE(value.from_date_int64(10000101)); value.to_string(str); - ASSERT_STREQ("1000-01-01", str); + EXPECT_STREQ("1000-01-01", str); // 12340531 -> 1234-05-31 - ASSERT_TRUE(value.from_date_int64(12340531)); + EXPECT_TRUE(value.from_date_int64(12340531)); value.to_string(str); - ASSERT_STREQ("1234-05-31", str); + EXPECT_STREQ("1234-05-31", str); // 99991231 -> 9999-12-31 - ASSERT_TRUE(value.from_date_int64(99991231)); + EXPECT_TRUE(value.from_date_int64(99991231)); value.to_string(str); - ASSERT_STREQ("9999-12-31", str); + EXPECT_STREQ("9999-12-31", str); // BELOW IS DATETIME VALUE CHECK // 101000000 -> 2000-01-01 00:00:00 - ASSERT_TRUE(value.from_date_int64(101000000)); + EXPECT_TRUE(value.from_date_int64(101000000)); value.to_string(str); - ASSERT_STREQ("2000-01-01 00:00:00", str); + EXPECT_STREQ("2000-01-01 00:00:00", str); // 150201123456 -> 2015-02-01 12:34:56 - ASSERT_TRUE(value.from_date_int64(150201123456)); + EXPECT_TRUE(value.from_date_int64(150201123456)); value.to_string(str); - ASSERT_STREQ("2015-02-01 12:34:56", str); + EXPECT_STREQ("2015-02-01 12:34:56", str); // 691231235959 -> 2069-12-31 23:59:59 - ASSERT_TRUE(value.from_date_int64(691231235959)); + EXPECT_TRUE(value.from_date_int64(691231235959)); value.to_string(str); - ASSERT_STREQ("2069-12-31 23:59:59", str); + EXPECT_STREQ("2069-12-31 23:59:59", str); // 700101000000 -> 1970-01-01 00:00:00 - ASSERT_TRUE(value.from_date_int64(700101000000)); + EXPECT_TRUE(value.from_date_int64(700101000000)); value.to_string(str); - ASSERT_STREQ("1970-01-01 00:00:00", str); + EXPECT_STREQ("1970-01-01 00:00:00", str); // 880201123456 -> 1988-02-01 12:34:56 - ASSERT_TRUE(value.from_date_int64(880201123456)); + EXPECT_TRUE(value.from_date_int64(880201123456)); value.to_string(str); - ASSERT_STREQ("1988-02-01 12:34:56", str); + EXPECT_STREQ("1988-02-01 12:34:56", str); // 991231235959 -> 1999-12-31 23:59:59 - ASSERT_TRUE(value.from_date_int64(991231235959)); + EXPECT_TRUE(value.from_date_int64(991231235959)); value.to_string(str); - ASSERT_STREQ("1999-12-31 23:59:59", str); + EXPECT_STREQ("1999-12-31 23:59:59", str); // four digits year // 1231231235959 -> 0123-12-31 23:59:59 - ASSERT_TRUE(value.from_date_int64(1231231235959)); + EXPECT_TRUE(value.from_date_int64(1231231235959)); value.to_string(str); - ASSERT_STREQ("0123-12-31 23:59:59", str); + EXPECT_STREQ("0123-12-31 23:59:59", str); // 99991231235959 -> 9999-12-31 23:59:59 - ASSERT_TRUE(value.from_date_int64(99991231235959)); + EXPECT_TRUE(value.from_date_int64(99991231235959)); value.to_string(str); - ASSERT_STREQ("9999-12-31 23:59:59", str); + EXPECT_STREQ("9999-12-31 23:59:59", str); } // Construct from int value invalid @@ -1204,24 +1217,24 @@ TEST_F(DateTimeValueTest, from_int_value_invalid) { DateTimeValue value; char str[MAX_DTVALUE_STR_LEN]; // minus value - ASSERT_FALSE(value.from_date_int64(-1231)); + EXPECT_FALSE(value.from_date_int64(-1231)); // [0, 101) - ASSERT_FALSE(value.from_date_int64(100)); + EXPECT_FALSE(value.from_date_int64(100)); // 691323 - ASSERT_FALSE(value.from_date_int64(691323)); + EXPECT_FALSE(value.from_date_int64(691323)); // three digits year 8980101 - ASSERT_FALSE(value.from_date_int64(8980101)); + EXPECT_FALSE(value.from_date_int64(8980101)); // 100-12-31 - ASSERT_FALSE(value.from_date_int64(1000101L)); + EXPECT_FALSE(value.from_date_int64(1000101L)); // 100-12-31 - ASSERT_FALSE(value.from_date_int64(1232)); + EXPECT_FALSE(value.from_date_int64(1232)); // 99 00:00:00 - ASSERT_TRUE(value.from_date_int64(99000000)); + EXPECT_TRUE(value.from_date_int64(99000000)); value.to_string(str); - ASSERT_STREQ("9900-00-00", str); + EXPECT_STREQ("9900-00-00", str); // 9999-99-99 99:99:99 + 1 - ASSERT_FALSE(value.from_date_int64(99999999999999L + 1)); + EXPECT_FALSE(value.from_date_int64(99999999999999L + 1)); } // Convert to datetime string @@ -1233,17 +1246,17 @@ TEST_F(DateTimeValueTest, to_string) { DateTimeValue value; // datetime value.to_string(str); - ASSERT_STREQ("0000-00-00 00:00:00", str); + EXPECT_STREQ("0000-00-00 00:00:00", str); // date value._type = TIME_DATE; value.to_string(str); - ASSERT_STREQ("0000-00-00", str); + EXPECT_STREQ("0000-00-00", str); // time value._type = TIME_TIME; value.to_string(str); - ASSERT_STREQ("00:00:00", str); + EXPECT_STREQ("00:00:00", str); } // 8765-12-23 12:34:56.987654 @@ -1258,17 +1271,17 @@ TEST_F(DateTimeValueTest, to_string) { value._microsecond = 987654; // datetime value.to_string(str); - ASSERT_STREQ("8765-12-23 12:34:56.987654", str); + EXPECT_STREQ("8765-12-23 12:34:56.987654", str); // time value._type = TIME_TIME; value.to_string(str); - ASSERT_STREQ("12:34:56.987654", str); + EXPECT_STREQ("12:34:56.987654", str); // date value._type = TIME_DATE; value.to_string(str); - ASSERT_STREQ("8765-12-23", str); + EXPECT_STREQ("8765-12-23", str); } // 0001-02-03 04:05:06.000007 @@ -1282,17 +1295,17 @@ TEST_F(DateTimeValueTest, to_string) { value._second = 6; value._microsecond = 7; value.to_string(str); - ASSERT_STREQ("0001-02-03 04:05:06.000007", str); + EXPECT_STREQ("0001-02-03 04:05:06.000007", str); // date value._type = TIME_DATE; value.to_string(str); - ASSERT_STREQ("0001-02-03", str); + EXPECT_STREQ("0001-02-03", str); // time value._type = TIME_TIME; value.to_string(str); - ASSERT_STREQ("04:05:06.000007", str); + EXPECT_STREQ("04:05:06.000007", str); } // time minus -100:05:06 @@ -1305,7 +1318,7 @@ TEST_F(DateTimeValueTest, to_string) { value._type = TIME_TIME; value._neg = 1; value.to_string(str); - ASSERT_STREQ("-100:05:06.000007", str); + EXPECT_STREQ("-100:05:06.000007", str); } } @@ -1314,15 +1327,15 @@ TEST_F(DateTimeValueTest, to_int64) { { DateTimeValue value; // datetime - ASSERT_EQ(0L, value.to_int64()); + EXPECT_EQ(0L, value.to_int64()); // date value._type = TIME_DATE; - ASSERT_EQ(0L, value.to_int64()); + EXPECT_EQ(0L, value.to_int64()); // time value._type = TIME_TIME; - ASSERT_EQ(0L, value.to_int64()); + EXPECT_EQ(0L, value.to_int64()); } // 8765-12-23 12:34:56.987654 @@ -1336,15 +1349,15 @@ TEST_F(DateTimeValueTest, to_int64) { value._second = 56; value._microsecond = 987654; // datetime - ASSERT_EQ(87651223123456L, value.to_int64()); + EXPECT_EQ(87651223123456L, value.to_int64()); // time value._type = TIME_TIME; - ASSERT_EQ(123456L, value.to_int64()); + EXPECT_EQ(123456L, value.to_int64()); // date value._type = TIME_DATE; - ASSERT_EQ(87651223L, value.to_int64()); + EXPECT_EQ(87651223L, value.to_int64()); } // 0001-02-03 04:05:06.000007 @@ -1357,15 +1370,15 @@ TEST_F(DateTimeValueTest, to_int64) { value._minute = 5; value._second = 6; value._microsecond = 7; - ASSERT_EQ(10203040506L, value.to_int64()); + EXPECT_EQ(10203040506L, value.to_int64()); // date value._type = TIME_DATE; - ASSERT_EQ(10203L, value.to_int64()); + EXPECT_EQ(10203L, value.to_int64()); // time value._type = TIME_TIME; - ASSERT_EQ(40506L, value.to_int64()); + EXPECT_EQ(40506L, value.to_int64()); } // time minus -100:05:06 @@ -1377,35 +1390,35 @@ TEST_F(DateTimeValueTest, to_int64) { value._microsecond = 7; value._type = TIME_TIME; value._neg = 1; - ASSERT_EQ(-1000506L, value.to_int64()); + EXPECT_EQ(-1000506L, value.to_int64()); } } TEST_F(DateTimeValueTest, operator_minus) { { DateTimeValue v1; - ASSERT_TRUE(v1.from_date_int64(19880201)); + EXPECT_TRUE(v1.from_date_int64(19880201)); DateTimeValue v2; - ASSERT_TRUE(v2.from_date_int64(19870201)); + EXPECT_TRUE(v2.from_date_int64(19870201)); int value = v1 - v2; - ASSERT_EQ(365, value); + EXPECT_EQ(365, value); value = v2 - v1; - ASSERT_EQ(-365, value); + EXPECT_EQ(-365, value); value = v1 - v1; - ASSERT_EQ(0, value); + EXPECT_EQ(0, value); } { DateTimeValue v1; - ASSERT_TRUE(v1.from_date_int64(19880201)); + EXPECT_TRUE(v1.from_date_int64(19880201)); DateTimeValue v2; - ASSERT_TRUE(v2.from_date_int64(19870201123456)); + EXPECT_TRUE(v2.from_date_int64(19870201123456)); int value = v1 - v2; - ASSERT_EQ(365, value); + EXPECT_EQ(365, value); value = v2 - v1; - ASSERT_EQ(-365, value); + EXPECT_EQ(-365, value); value = v1 - v1; - ASSERT_EQ(0, value); + EXPECT_EQ(0, value); } } @@ -1414,13 +1427,13 @@ TEST_F(DateTimeValueTest, min_max) { { DateTimeValue v1 = DateTimeValue::datetime_min_value(); v1.to_string(buf); - ASSERT_STREQ("0000-01-01 00:00:00", buf); + EXPECT_STREQ("0000-01-01 00:00:00", buf); } { DateTimeValue v1 = DateTimeValue::datetime_max_value(); v1.to_string(buf); - ASSERT_STREQ("9999-12-31 23:59:59", buf); + EXPECT_STREQ("9999-12-31 23:59:59", buf); } } @@ -1430,12 +1443,12 @@ TEST_F(DateTimeValueTest, packed_time) { DateTimeValue v1; v1.from_date_int64(20010203123456L); v1.to_string(buf); - ASSERT_STREQ("2001-02-03 12:34:56", buf); + EXPECT_STREQ("2001-02-03 12:34:56", buf); int64_t packed_time = v1.to_int64_date_packed(); - ASSERT_EQ(1830649476851695616L, packed_time); + EXPECT_EQ(1830649476851695616L, packed_time); packed_time = v1.to_int64_datetime_packed(); - ASSERT_EQ(1830650338932162560L, packed_time); + EXPECT_EQ(1830650338932162560L, packed_time); } { @@ -1444,24 +1457,13 @@ TEST_F(DateTimeValueTest, packed_time) { tv.type = TIME_DATETIME; DateTimeValue v1 = DateTimeValue::from_datetime_val(tv); v1.to_string(buf); - ASSERT_STREQ("2001-02-03 12:34:56", buf); + EXPECT_STREQ("2001-02-03 12:34:56", buf); doris_udf::DateTimeVal tv2; v1.to_datetime_val(&tv2); - ASSERT_TRUE(tv == tv2); + EXPECT_TRUE(tv == tv2); } } } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/decimal_value_test.cpp b/be/test/runtime/decimal_value_test.cpp index 3d2c6f9c13..b6bbc3631a 100644 --- a/be/test/runtime/decimal_value_test.cpp +++ b/be/test/runtime/decimal_value_test.cpp @@ -36,142 +36,121 @@ protected: TEST_F(DecimalValueTest, string_to_decimal) { DecimalValue value(std::string("1.23")); - ASSERT_EQ("1.23", value.to_string(3)); + EXPECT_EQ("1.23", value.to_string(3)); DecimalValue value1(std::string("0.23")); - ASSERT_EQ("0.23", value1.to_string(3)); + EXPECT_EQ("0.23", value1.to_string(3)); DecimalValue value2(std::string("1234567890123456789.0")); - ASSERT_EQ("1234567890123456789.0", value2.to_string(3)); + EXPECT_EQ("1234567890123456789.0", value2.to_string(3)); } TEST_F(DecimalValueTest, negative_zero) { DecimalValue value(std::string("-0.00")); - std::cout << "value: " << value.get_debug_info() << std::endl; { // positive zero VS negative zero DecimalValue value2(std::string("0.00")); - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_TRUE(value == value2); - ASSERT_FALSE(value < value2); - ASSERT_FALSE(value < value2); - ASSERT_TRUE(value <= value2); - ASSERT_TRUE(value >= value2); + EXPECT_TRUE(value == value2); + EXPECT_FALSE(value < value2); + EXPECT_FALSE(value < value2); + EXPECT_TRUE(value <= value2); + EXPECT_TRUE(value >= value2); } { // from string, positive DecimalValue value3(std::string("5.0")); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } { // from string, negative DecimalValue value3(std::string("-5.0")); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value > value3); - ASSERT_TRUE(value >= value3); - ASSERT_TRUE(value3 < value); - ASSERT_TRUE(value3 <= value); + EXPECT_TRUE(value > value3); + EXPECT_TRUE(value >= value3); + EXPECT_TRUE(value3 < value); + EXPECT_TRUE(value3 <= value); } { // from int DecimalValue value3(6); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); - ASSERT_FALSE(!(value < value3)); - ASSERT_FALSE(!(value <= value3)); - ASSERT_FALSE(!(value3 > value)); - ASSERT_FALSE(!(value3 >= value)); + EXPECT_FALSE(!(value < value3)); + EXPECT_FALSE(!(value <= value3)); + EXPECT_FALSE(!(value3 > value)); + EXPECT_FALSE(!(value3 >= value)); } { // from int DecimalValue value3(4, 0); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } { // from int DecimalValue value3(3, -0); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } } TEST_F(DecimalValueTest, int_to_decimal) { DecimalValue value1; - ASSERT_EQ("0", value1.to_string(3)); + EXPECT_EQ("0", value1.to_string(3)); DecimalValue value2(111111111); // 9 digits - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("111111111", value2.to_string(3)); + EXPECT_EQ("111111111", value2.to_string(3)); DecimalValue value3(111111111, 222222222); // 9 digits - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_EQ("111111111.222", value3.to_string(3)); + EXPECT_EQ("111111111.222", value3.to_string(3)); DecimalValue value4(0, 222222222); // 9 digits - std::cout << "value4: " << value4.get_debug_info() << std::endl; - ASSERT_EQ("0.222", value4.to_string(3)); + EXPECT_EQ("0.222", value4.to_string(3)); DecimalValue value5(111111111, 0); // 9 digits - std::cout << "value5: " << value5.get_debug_info() << std::endl; - ASSERT_EQ("111111111", value5.to_string(3)); + EXPECT_EQ("111111111", value5.to_string(3)); DecimalValue value6(0, 0); // 9 digits - std::cout << "value6: " << value6.get_debug_info() << std::endl; - ASSERT_EQ("0", value6.to_string(3)); + EXPECT_EQ("0", value6.to_string(3)); DecimalValue value7(0, 12345); // 9 digits - std::cout << "value7: " << value7.get_debug_info() << std::endl; - ASSERT_EQ("0.000012", value7.to_string(6)); + EXPECT_EQ("0.000012", value7.to_string(6)); DecimalValue value8(11, 0); - std::cout << "value8: " << value8.get_debug_info() << std::endl; - ASSERT_EQ("11", value8.to_string(3)); + EXPECT_EQ("11", value8.to_string(3)); // more than 9digit, fraction will be trancated to 999999999 DecimalValue value9(1230123456789, 1230123456789); - std::cout << "value9: " << value9.get_debug_info() << std::endl; - ASSERT_EQ("1230123456789.999999999", value9.to_string(10)); + EXPECT_EQ("1230123456789.999999999", value9.to_string(10)); // negative { DecimalValue value2(-111111111); // 9 digits - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("-111111111", value2.to_string(3)); + EXPECT_EQ("-111111111", value2.to_string(3)); DecimalValue value3(-111111111, 222222222); // 9 digits - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_EQ("-111111111.222", value3.to_string(3)); + EXPECT_EQ("-111111111.222", value3.to_string(3)); DecimalValue value4(0, -222222222); // 9 digits - std::cout << "value4: " << value4.get_debug_info() << std::endl; - ASSERT_EQ("-0.222", value4.to_string(3)); + EXPECT_EQ("-0.222", value4.to_string(3)); DecimalValue value5(-111111111, 0); // 9 digits - std::cout << "value5: " << value5.get_debug_info() << std::endl; - ASSERT_EQ("-111111111", value5.to_string(3)); + EXPECT_EQ("-111111111", value5.to_string(3)); DecimalValue value7(0, -12345); // 9 digits - std::cout << "value7: " << value7.get_debug_info() << std::endl; - ASSERT_EQ("-0.000012", value7.to_string(6)); + EXPECT_EQ("-0.000012", value7.to_string(6)); DecimalValue value8(-11, 0); - std::cout << "value8: " << value8.get_debug_info() << std::endl; - ASSERT_EQ("-11", value8.to_string(3)); + EXPECT_EQ("-11", value8.to_string(3)); } } @@ -179,14 +158,12 @@ TEST_F(DecimalValueTest, add) { DecimalValue value11(std::string("1111111111.2222222222")); // 10 digits DecimalValue value12(std::string("2222222222.1111111111")); // 10 digits DecimalValue add_result1 = value11 + value12; - std::cout << "add_result1: " << add_result1.get_debug_info() << std::endl; - ASSERT_EQ("3333333333.3333333333", add_result1.to_string(10)); + EXPECT_EQ("3333333333.3333333333", add_result1.to_string(10)); DecimalValue value21(std::string("-3333333333.2222222222")); // 10 digits DecimalValue value22(std::string("2222222222.1111111111")); // 10 digits DecimalValue add_result2 = value21 + value22; - std::cout << "add_result2: " << add_result2.get_debug_info() << std::endl; - ASSERT_EQ("-1111111111.1111111111", add_result2.to_string(10)); + EXPECT_EQ("-1111111111.1111111111", add_result2.to_string(10)); } TEST_F(DecimalValueTest, compound_add) { @@ -194,8 +171,7 @@ TEST_F(DecimalValueTest, compound_add) { DecimalValue value1(std::string("111111111.222222222")); DecimalValue value2(std::string("111111111.222222222")); value1 += value2; - std::cout << "value1: " << value1.get_debug_info() << std::endl; - ASSERT_EQ("222222222.444444444", value1.to_string(10)); + EXPECT_EQ("222222222.444444444", value1.to_string(10)); } } @@ -203,13 +179,11 @@ TEST_F(DecimalValueTest, sub) { DecimalValue value11(std::string("3333333333.2222222222")); // 10 digits DecimalValue value12(std::string("2222222222.1111111111")); // 10 digits DecimalValue sub_result1 = value11 - value12; - std::cout << "sub_result1: " << sub_result1.get_debug_info() << std::endl; - ASSERT_EQ("1111111111.1111111111", sub_result1.to_string(10)); + EXPECT_EQ("1111111111.1111111111", sub_result1.to_string(10)); DecimalValue value21(std::string("-2222222222.1111111111")); // 10 digits DecimalValue sub_result2 = value11 - value21; - std::cout << "sub_result2: " << sub_result2.get_debug_info() << std::endl; - ASSERT_EQ("5555555555.3333333333", sub_result2.to_string(10)); + EXPECT_EQ("5555555555.3333333333", sub_result2.to_string(10)); // small - big { @@ -218,8 +192,8 @@ TEST_F(DecimalValueTest, sub) { DecimalValue sub_result = value2 - value1; LOG(INFO) << "sub_result: " << sub_result.get_debug_info() << std::endl; DecimalValue expected_value(std::string("-8.0")); - ASSERT_EQ(expected_value, sub_result); - ASSERT_FALSE(sub_result.is_zero()); + EXPECT_EQ(expected_value, sub_result); + EXPECT_FALSE(sub_result.is_zero()); } // minimum - maximal { @@ -232,9 +206,9 @@ TEST_F(DecimalValueTest, sub) { DecimalValue sub_result = value2 - value1; LOG(INFO) << "sub_result: " << sub_result.get_debug_info() << std::endl; DecimalValue expected_value = value2; - ASSERT_EQ(expected_value, sub_result); - ASSERT_FALSE(sub_result.is_zero()); - ASSERT_TRUE(value1 > value2); + EXPECT_EQ(expected_value, sub_result); + EXPECT_FALSE(sub_result.is_zero()); + EXPECT_TRUE(value1 > value2); } } @@ -242,21 +216,18 @@ TEST_F(DecimalValueTest, mul) { DecimalValue value11(std::string("3333333333.2222222222")); // 10 digits DecimalValue value12(std::string("-2222222222.1111111111")); // 10 digits DecimalValue mul_result1 = value11 * value12; - std::cout << "mul_result1: " << mul_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalValue(std::string("-7407407406790123456.71604938271975308642")), mul_result1); + EXPECT_EQ(DecimalValue(std::string("-7407407406790123456.71604938271975308642")), mul_result1); DecimalValue value21(std::string("0")); // zero DecimalValue mul_result2 = value11 * value21; - std::cout << "mul_result2: " << mul_result2.get_debug_info() << std::endl; - ASSERT_EQ(DecimalValue(std::string("0")), mul_result2); + EXPECT_EQ(DecimalValue(std::string("0")), mul_result2); { // test when carry is needed DecimalValue value1(std::string("3074062.5421333313")); DecimalValue value2(std::string("2169.957745029689045693")); DecimalValue mul_result = value1 * value2; - std::cout << "mul_result=" << mul_result.get_debug_info() << std::endl; - ASSERT_EQ(DecimalValue(std::string("6670585822.0078770603624547106640070909")), mul_result); + EXPECT_EQ(DecimalValue(std::string("6670585822.0078770603624547106640070909")), mul_result); } } @@ -264,15 +235,13 @@ TEST_F(DecimalValueTest, div) { DecimalValue value11(std::string("-7407407406790123456.71604938271975308642")); DecimalValue value12(std::string("-2222222222.1111111111")); // 10 digits DecimalValue div_result1 = value11 / value12; - std::cout << "div_result1: " << div_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalValue(std::string("3333333333.2222222222")), div_result1); - ASSERT_EQ("3333333333.222222222200000", div_result1.to_string(15)); + EXPECT_EQ(DecimalValue(std::string("3333333333.2222222222")), div_result1); + EXPECT_EQ("3333333333.222222222200000", div_result1.to_string(15)); { DecimalValue value11(std::string("32767")); DecimalValue value12(std::string("604587")); DecimalValue div_result1 = value11 / value12; - std::cout << "div_result1: " << div_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalValue(std::string("0.054197328")), div_result1); + EXPECT_EQ(DecimalValue(std::string("0.054197328")), div_result1); } } @@ -280,10 +249,8 @@ TEST_F(DecimalValueTest, unary_minus_operator) { { DecimalValue value1(std::string("111111111.222222222")); DecimalValue value2 = -value1; - std::cout << "value1: " << value1.get_debug_info() << std::endl; - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("111111111.222222222", value1.to_string(10)); - ASSERT_EQ("-111111111.222222222", value2.to_string(10)); + EXPECT_EQ("111111111.222222222", value1.to_string(10)); + EXPECT_EQ("-111111111.222222222", value2.to_string(10)); } } @@ -291,28 +258,28 @@ TEST_F(DecimalValueTest, to_int_frac_value) { // positive & negative { DecimalValue value(std::string("123456789123456789.987654321")); - ASSERT_EQ(123456789123456789, value.int_value()); - ASSERT_EQ(987654321, value.frac_value()); + EXPECT_EQ(123456789123456789, value.int_value()); + EXPECT_EQ(987654321, value.frac_value()); DecimalValue value2(std::string("-123456789123456789.987654321")); - ASSERT_EQ(-123456789123456789, value2.int_value()); - ASSERT_EQ(-987654321, value2.frac_value()); + EXPECT_EQ(-123456789123456789, value2.int_value()); + EXPECT_EQ(-987654321, value2.frac_value()); } // int or frac part is 0 { DecimalValue value(std::string("-123456789123456789")); - ASSERT_EQ(-123456789123456789, value.int_value()); - ASSERT_EQ(0, value.frac_value()); + EXPECT_EQ(-123456789123456789, value.int_value()); + EXPECT_EQ(0, value.frac_value()); DecimalValue value2(std::string("0.987654321")); - ASSERT_EQ(0, value2.int_value()); - ASSERT_EQ(987654321, value2.frac_value()); + EXPECT_EQ(0, value2.int_value()); + EXPECT_EQ(987654321, value2.frac_value()); } // truncate frac part { DecimalValue value(std::string("-123456789.987654321987654321")); - ASSERT_EQ(-123456789, value.int_value()); - ASSERT_EQ(-987654321, value.frac_value()); + EXPECT_EQ(-123456789, value.int_value()); + EXPECT_EQ(-987654321, value.frac_value()); } } @@ -323,90 +290,90 @@ TEST_F(DecimalValueTest, round_ops) { { DecimalValue dst; value.round(&dst, -1, HALF_UP); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); value.round(&dst, -1, CEILING); - ASSERT_EQ("10", dst.to_string()); + EXPECT_EQ("10", dst.to_string()); value.round(&dst, -1, FLOOR); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); value.round(&dst, -1, TRUNCATE); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); } { DecimalValue dst; value.round(&dst, 0, HALF_UP); - ASSERT_EQ("1", dst.to_string()); + EXPECT_EQ("1", dst.to_string()); value.round(&dst, 0, CEILING); - ASSERT_EQ("2", dst.to_string()); + EXPECT_EQ("2", dst.to_string()); value.round(&dst, 0, FLOOR); - ASSERT_EQ("1", dst.to_string()); + EXPECT_EQ("1", dst.to_string()); value.round(&dst, 0, TRUNCATE); - ASSERT_EQ("1", dst.to_string()); + EXPECT_EQ("1", dst.to_string()); } { DecimalValue dst; value.round(&dst, 1, HALF_UP); - ASSERT_EQ("1.2", dst.to_string()); + EXPECT_EQ("1.2", dst.to_string()); value.round(&dst, 1, CEILING); - ASSERT_EQ("1.3", dst.to_string()); + EXPECT_EQ("1.3", dst.to_string()); value.round(&dst, 1, FLOOR); - ASSERT_EQ("1.2", dst.to_string()); + EXPECT_EQ("1.2", dst.to_string()); value.round(&dst, 1, TRUNCATE); - ASSERT_EQ("1.2", dst.to_string()); + EXPECT_EQ("1.2", dst.to_string()); } { DecimalValue dst; value.round(&dst, 2, HALF_UP); - ASSERT_EQ("1.25", dst.to_string()); + EXPECT_EQ("1.25", dst.to_string()); value.round(&dst, 2, CEILING); - ASSERT_EQ("1.25", dst.to_string()); + EXPECT_EQ("1.25", dst.to_string()); value.round(&dst, 2, FLOOR); - ASSERT_EQ("1.24", dst.to_string()); + EXPECT_EQ("1.24", dst.to_string()); value.round(&dst, 2, TRUNCATE); - ASSERT_EQ("1.24", dst.to_string()); + EXPECT_EQ("1.24", dst.to_string()); } { DecimalValue dst; value.round(&dst, 3, HALF_UP); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 3, CEILING); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 3, FLOOR); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 3, TRUNCATE); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); } { DecimalValue dst; value.round(&dst, 4, HALF_UP); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 4, CEILING); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 4, FLOOR); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); value.round(&dst, 4, TRUNCATE); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("1.249", dst.to_string()); } } @@ -417,90 +384,90 @@ TEST_F(DecimalValueTest, round_minus) { { DecimalValue dst; value.round(&dst, -1, HALF_UP); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); value.round(&dst, -1, CEILING); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); value.round(&dst, -1, FLOOR); - ASSERT_EQ("-10", dst.to_string()); + EXPECT_EQ("-10", dst.to_string()); value.round(&dst, -1, TRUNCATE); - ASSERT_EQ("0", dst.to_string()); + EXPECT_EQ("0", dst.to_string()); } { DecimalValue dst; value.round(&dst, 0, HALF_UP); - ASSERT_EQ("-1", dst.to_string()); + EXPECT_EQ("-1", dst.to_string()); value.round(&dst, 0, CEILING); - ASSERT_EQ("-1", dst.to_string()); + EXPECT_EQ("-1", dst.to_string()); value.round(&dst, 0, FLOOR); - ASSERT_EQ("-2", dst.to_string()); + EXPECT_EQ("-2", dst.to_string()); value.round(&dst, 0, TRUNCATE); - ASSERT_EQ("-1", dst.to_string()); + EXPECT_EQ("-1", dst.to_string()); } { DecimalValue dst; value.round(&dst, 1, HALF_UP); - ASSERT_EQ("-1.2", dst.to_string()); + EXPECT_EQ("-1.2", dst.to_string()); value.round(&dst, 1, CEILING); - ASSERT_EQ("-1.2", dst.to_string()); + EXPECT_EQ("-1.2", dst.to_string()); value.round(&dst, 1, FLOOR); - ASSERT_EQ("-1.3", dst.to_string()); + EXPECT_EQ("-1.3", dst.to_string()); value.round(&dst, 1, TRUNCATE); - ASSERT_EQ("-1.2", dst.to_string()); + EXPECT_EQ("-1.2", dst.to_string()); } { DecimalValue dst; value.round(&dst, 2, HALF_UP); - ASSERT_EQ("-1.25", dst.to_string()); + EXPECT_EQ("-1.25", dst.to_string()); value.round(&dst, 2, CEILING); - ASSERT_EQ("-1.24", dst.to_string()); + EXPECT_EQ("-1.24", dst.to_string()); value.round(&dst, 2, FLOOR); - ASSERT_EQ("-1.25", dst.to_string()); + EXPECT_EQ("-1.25", dst.to_string()); value.round(&dst, 2, TRUNCATE); - ASSERT_EQ("-1.24", dst.to_string()); + EXPECT_EQ("-1.24", dst.to_string()); } { DecimalValue dst; value.round(&dst, 3, HALF_UP); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 3, CEILING); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 3, FLOOR); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 3, TRUNCATE); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); } { DecimalValue dst; value.round(&dst, 4, HALF_UP); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 4, CEILING); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 4, FLOOR); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); value.round(&dst, 4, TRUNCATE); - ASSERT_EQ("-1.249", dst.to_string()); + EXPECT_EQ("-1.249", dst.to_string()); } } @@ -511,7 +478,7 @@ TEST_F(DecimalValueTest, round_to_int) { { DecimalValue dst; value.round(&dst, 1, HALF_UP); - ASSERT_EQ("100.0", dst.to_string()); + EXPECT_EQ("100.0", dst.to_string()); } } { @@ -519,7 +486,7 @@ TEST_F(DecimalValueTest, round_to_int) { { DecimalValue dst; value.round(&dst, 4, HALF_UP); - ASSERT_EQ("123.124", dst.to_string()); + EXPECT_EQ("123.124", dst.to_string()); } } } @@ -528,7 +495,7 @@ TEST_F(DecimalValueTest, double_to_decimal) { double i = 1.2; DecimalValue* value = new DecimalValue(100, 9876); value->assign_from_double(i); - ASSERT_STREQ("1.2", value->to_string().c_str()); + EXPECT_STREQ("1.2", value->to_string().c_str()); delete value; } @@ -536,18 +503,7 @@ TEST_F(DecimalValueTest, float_to_decimal) { float i = 1.2; DecimalValue* value = new DecimalValue(100, 9876); value->assign_from_float(i); - ASSERT_STREQ("1.2", value->to_string().c_str()); + EXPECT_STREQ("1.2", value->to_string().c_str()); delete value; } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/decimalv2_value_test.cpp b/be/test/runtime/decimalv2_value_test.cpp index fcda932cb4..100f9e82d4 100644 --- a/be/test/runtime/decimalv2_value_test.cpp +++ b/be/test/runtime/decimalv2_value_test.cpp @@ -26,576 +26,531 @@ namespace doris { - class DecimalV2ValueTest : public testing::Test { - public: - DecimalV2ValueTest() {} +class DecimalV2ValueTest : public testing::Test { +public: + DecimalV2ValueTest() {} - protected: - virtual void SetUp() {} - virtual void TearDown() {} - }; +protected: + virtual void SetUp() {} + virtual void TearDown() {} +}; - TEST_F(DecimalV2ValueTest, string_to_decimal) { - char buffer[100]; - DecimalV2Value value(std::string("1.23")); - ASSERT_EQ("1.230", value.to_string(3)); - ASSERT_EQ("1.23", value.to_string()); - int len = value.to_buffer(buffer, 3); - ASSERT_EQ("1.230", std::string(buffer, len)); - len = value.to_buffer(buffer, -1); - ASSERT_EQ("1.23", std::string(buffer, len)); +TEST_F(DecimalV2ValueTest, string_to_decimal) { + char buffer[100]; + DecimalV2Value value(std::string("1.23")); + EXPECT_EQ("1.230", value.to_string(3)); + EXPECT_EQ("1.23", value.to_string()); + int len = value.to_buffer(buffer, 3); + EXPECT_EQ("1.230", std::string(buffer, len)); + len = value.to_buffer(buffer, -1); + EXPECT_EQ("1.23", std::string(buffer, len)); - DecimalV2Value value1(std::string("-0.23")); - ASSERT_EQ("-0.230", value1.to_string(3)); - ASSERT_EQ("-0.23", value1.to_string()); - len = value1.to_buffer(buffer, 3); - ASSERT_EQ("-0.230", std::string(buffer, len)); - len = value1.to_buffer(buffer, -1); - ASSERT_EQ("-0.23", std::string(buffer, len)); + DecimalV2Value value1(std::string("-0.23")); + EXPECT_EQ("-0.230", value1.to_string(3)); + EXPECT_EQ("-0.23", value1.to_string()); + len = value1.to_buffer(buffer, 3); + EXPECT_EQ("-0.230", std::string(buffer, len)); + len = value1.to_buffer(buffer, -1); + EXPECT_EQ("-0.23", std::string(buffer, len)); - DecimalV2Value value2(std::string("1234567890123456789.0")); - ASSERT_EQ("1234567890123456789.000", value2.to_string(3)); - ASSERT_EQ("1234567890123456789", value2.to_string()); - len = value2.to_buffer(buffer, 3); - ASSERT_EQ("1234567890123456789.000", std::string(buffer, len)); - len = value2.to_buffer(buffer, -1); - ASSERT_EQ("1234567890123456789", std::string(buffer, len)); + DecimalV2Value value2(std::string("1234567890123456789.0")); + EXPECT_EQ("1234567890123456789.000", value2.to_string(3)); + EXPECT_EQ("1234567890123456789", value2.to_string()); + len = value2.to_buffer(buffer, 3); + EXPECT_EQ("1234567890123456789.000", std::string(buffer, len)); + len = value2.to_buffer(buffer, -1); + EXPECT_EQ("1234567890123456789", std::string(buffer, len)); - DecimalV2Value value3(std::string("0")); - ASSERT_EQ("0.000", value3.to_string(3)); - ASSERT_EQ("0", value3.to_string()); - len = value3.to_buffer(buffer, 3); - ASSERT_EQ("0.000", std::string(buffer, len)); - len = value3.to_buffer(buffer, -1); - ASSERT_EQ("0", std::string(buffer, len)); + DecimalV2Value value3(std::string("0")); + EXPECT_EQ("0.000", value3.to_string(3)); + EXPECT_EQ("0", value3.to_string()); + len = value3.to_buffer(buffer, 3); + EXPECT_EQ("0.000", std::string(buffer, len)); + len = value3.to_buffer(buffer, -1); + EXPECT_EQ("0", std::string(buffer, len)); - DecimalV2Value value4(std::string("22")); - ASSERT_EQ("22.00", value4.to_string(2)); - ASSERT_EQ("22", value4.to_string()); - len = value4.to_buffer(buffer, 2); - ASSERT_EQ("22.00", std::string(buffer, len)); - len = value4.to_buffer(buffer, -1); - ASSERT_EQ("22", std::string(buffer, len)); + DecimalV2Value value4(std::string("22")); + EXPECT_EQ("22.00", value4.to_string(2)); + EXPECT_EQ("22", value4.to_string()); + len = value4.to_buffer(buffer, 2); + EXPECT_EQ("22.00", std::string(buffer, len)); + len = value4.to_buffer(buffer, -1); + EXPECT_EQ("22", std::string(buffer, len)); - DecimalV2Value value5(std::string("-0")); - ASSERT_EQ("0", value5.to_string()); - len = value5.to_buffer(buffer, -1); - ASSERT_EQ("0", std::string(buffer, len)); + DecimalV2Value value5(std::string("-0")); + EXPECT_EQ("0", value5.to_string()); + len = value5.to_buffer(buffer, -1); + EXPECT_EQ("0", std::string(buffer, len)); - DecimalV2Value value6(std::string("999999999999999999.999999999")); - ASSERT_EQ("999999999999999999.999", value6.to_string(3)); - ASSERT_EQ("999999999999999999.999999999", value6.to_string()); - len = value6.to_buffer(buffer, 3); - ASSERT_EQ("999999999999999999.999", std::string(buffer, len)); - len = value6.to_buffer(buffer, -1); - ASSERT_EQ("999999999999999999.999999999", std::string(buffer, len)); + DecimalV2Value value6(std::string("999999999999999999.999999999")); + EXPECT_EQ("999999999999999999.999", value6.to_string(3)); + EXPECT_EQ("999999999999999999.999999999", value6.to_string()); + len = value6.to_buffer(buffer, 3); + EXPECT_EQ("999999999999999999.999", std::string(buffer, len)); + len = value6.to_buffer(buffer, -1); + EXPECT_EQ("999999999999999999.999999999", std::string(buffer, len)); - DecimalV2Value value7(std::string("-999999999999999999.999999999")); - ASSERT_EQ("-999999999999999999.999", value7.to_string(3)); - ASSERT_EQ("-999999999999999999.999999999", value7.to_string()); - len = value7.to_buffer(buffer, 3); - ASSERT_EQ("-999999999999999999.999", std::string(buffer, len)); - len = value7.to_buffer(buffer, -1); - ASSERT_EQ("-999999999999999999.999999999", std::string(buffer, len)); + DecimalV2Value value7(std::string("-999999999999999999.999999999")); + EXPECT_EQ("-999999999999999999.999", value7.to_string(3)); + EXPECT_EQ("-999999999999999999.999999999", value7.to_string()); + len = value7.to_buffer(buffer, 3); + EXPECT_EQ("-999999999999999999.999", std::string(buffer, len)); + len = value7.to_buffer(buffer, -1); + EXPECT_EQ("-999999999999999999.999999999", std::string(buffer, len)); - DecimalV2Value value8(std::string("100.001")); - ASSERT_EQ("100.00100", value8.to_string(5)); - ASSERT_EQ("100.001", value8.to_string()); - len = value8.to_buffer(buffer, 5); - ASSERT_EQ("100.00100", std::string(buffer, len)); - len = value8.to_buffer(buffer, -1); - ASSERT_EQ("100.001", std::string(buffer, len)); + DecimalV2Value value8(std::string("100.001")); + EXPECT_EQ("100.00100", value8.to_string(5)); + EXPECT_EQ("100.001", value8.to_string()); + len = value8.to_buffer(buffer, 5); + EXPECT_EQ("100.00100", std::string(buffer, len)); + len = value8.to_buffer(buffer, -1); + EXPECT_EQ("100.001", std::string(buffer, len)); } - TEST_F(DecimalV2ValueTest, negative_zero) { - DecimalV2Value value(std::string("-0.00")); - std::cout << "value: " << value.get_debug_info() << std::endl; - { - // positive zero VS negative zero - DecimalV2Value value2(std::string("0.00")); - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_TRUE(value == value2); - ASSERT_FALSE(value < value2); - ASSERT_FALSE(value < value2); - ASSERT_TRUE(value <= value2); - ASSERT_TRUE(value >= value2); - } - { - // from string, positive - DecimalV2Value value3(std::string("5.0")); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); - } - { - // from string, negative - DecimalV2Value value3(std::string("-5.0")); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value > value3); - ASSERT_TRUE(value >= value3); - ASSERT_TRUE(value3 < value); - ASSERT_TRUE(value3 <= value); - } - { - // from int - DecimalV2Value value3(6); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); - - ASSERT_FALSE(!(value < value3)); - ASSERT_FALSE(!(value <= value3)); - ASSERT_FALSE(!(value3 > value)); - ASSERT_FALSE(!(value3 >= value)); - } - { - // from int - DecimalV2Value value3(4, 0); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); - } - { - // from int - DecimalV2Value value3(3, -0); - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_TRUE(value < value3); - ASSERT_TRUE(value <= value3); - ASSERT_TRUE(value3 > value); - ASSERT_TRUE(value3 >= value); - } +TEST_F(DecimalV2ValueTest, negative_zero) { + DecimalV2Value value(std::string("-0.00")); + { + // positive zero VS negative zero + DecimalV2Value value2(std::string("0.00")); + EXPECT_TRUE(value == value2); + EXPECT_FALSE(value < value2); + EXPECT_FALSE(value < value2); + EXPECT_TRUE(value <= value2); + EXPECT_TRUE(value >= value2); } - - TEST_F(DecimalV2ValueTest, int_to_decimal) { - DecimalV2Value value1(0); - ASSERT_EQ("0.000", value1.to_string(3)); - - DecimalV2Value value2(111111111, 0); // 9 digits - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("111111111.000", value2.to_string(3)); - - DecimalV2Value value3(111111111, 222222222); // 9 digits - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_EQ("111111111.222", value3.to_string(3)); - - DecimalV2Value value4(0, 222222222); // 9 digits - std::cout << "value4: " << value4.get_debug_info() << std::endl; - ASSERT_EQ("0.222", value4.to_string(3)); - - DecimalV2Value value5(111111111, 0); // 9 digits - std::cout << "value5: " << value5.get_debug_info() << std::endl; - ASSERT_EQ("111111111.000", value5.to_string(3)); - - DecimalV2Value value6(0, 0); // 9 digits - std::cout << "value6: " << value6.get_debug_info() << std::endl; - ASSERT_EQ("0.000", value6.to_string(3)); - - DecimalV2Value value7(0, 12345); // 9 digits - std::cout << "value7: " << value7.get_debug_info() << std::endl; - ASSERT_EQ("0.000012", value7.to_string(6)); - - DecimalV2Value value8(11, 0); - std::cout << "value8: " << value8.get_debug_info() << std::endl; - ASSERT_EQ("11.000", value8.to_string(3)); - - // more than 9digit, fraction will be truncated to 999999999 - DecimalV2Value value9(1230123456789, 1230123456789); - std::cout << "value9: " << value9.get_debug_info() << std::endl; - ASSERT_EQ("1230123456789.999999999", value9.to_string(10)); - - // negative - { - DecimalV2Value value2(-111111111, 0); // 9 digits - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("-111111111.000", value2.to_string(3)); - - DecimalV2Value value3(-111111111, 222222222); // 9 digits - std::cout << "value3: " << value3.get_debug_info() << std::endl; - ASSERT_EQ("-111111111.222", value3.to_string(3)); - - DecimalV2Value value4(0, -222222222); // 9 digits - std::cout << "value4: " << value4.get_debug_info() << std::endl; - ASSERT_EQ("-0.222", value4.to_string(3)); - - DecimalV2Value value5(-111111111, 0); // 9 digits - std::cout << "value5: " << value5.get_debug_info() << std::endl; - ASSERT_EQ("-111111111.000", value5.to_string(3)); - - DecimalV2Value value7(0, -12345); // 9 digits - std::cout << "value7: " << value7.get_debug_info() << std::endl; - ASSERT_EQ("-0.000012", value7.to_string(6)); - - DecimalV2Value value8(-11, 0); - std::cout << "value8: " << value8.get_debug_info() << std::endl; - ASSERT_EQ("-11.000", value8.to_string(3)); - } + { + // from string, positive + DecimalV2Value value3(std::string("5.0")); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } - - TEST_F(DecimalV2ValueTest, add) { - DecimalV2Value value11(std::string("1111111111.222222222")); // 9 digits - DecimalV2Value value12(std::string("2222222222.111111111")); // 9 digits - DecimalV2Value add_result1 = value11 + value12; - std::cout << "add_result1: " << add_result1.get_debug_info() << std::endl; - ASSERT_EQ("3333333333.333333333", add_result1.to_string(9)); - - DecimalV2Value value21(std::string("-3333333333.222222222")); // 9 digits - DecimalV2Value value22(std::string("2222222222.111111111")); // 9 digits - DecimalV2Value add_result2 = value21 + value22; - std::cout << "add_result2: " << add_result2.get_debug_info() << std::endl; - ASSERT_EQ("-1111111111.111111111", add_result2.to_string(9)); + { + // from string, negative + DecimalV2Value value3(std::string("-5.0")); + EXPECT_TRUE(value > value3); + EXPECT_TRUE(value >= value3); + EXPECT_TRUE(value3 < value); + EXPECT_TRUE(value3 <= value); } + { + // from int + DecimalV2Value value3(6); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); - TEST_F(DecimalV2ValueTest, compound_add) { - { - DecimalV2Value value1(std::string("111111111.222222222")); - DecimalV2Value value2(std::string("111111111.222222222")); - value1 += value2; - std::cout << "value1: " << value1.get_debug_info() << std::endl; - ASSERT_EQ("222222222.444444444", value1.to_string(9)); - } + EXPECT_FALSE(!(value < value3)); + EXPECT_FALSE(!(value <= value3)); + EXPECT_FALSE(!(value3 > value)); + EXPECT_FALSE(!(value3 >= value)); } - - TEST_F(DecimalV2ValueTest, sub) { - DecimalV2Value value11(std::string("3333333333.222222222")); // 9 digits - DecimalV2Value value12(std::string("2222222222.111111111")); // 9 digits - DecimalV2Value sub_result1 = value11 - value12; - std::cout << "sub_result1: " << sub_result1.get_debug_info() << std::endl; - ASSERT_EQ("1111111111.111111111", sub_result1.to_string(9)); - - DecimalV2Value value21(std::string("-2222222222.111111111")); // 9 digits - DecimalV2Value sub_result2 = value11 - value21; - std::cout << "sub_result2: " << sub_result2.get_debug_info() << std::endl; - ASSERT_EQ("5555555555.333333333", sub_result2.to_string(9)); - - // small - big - { - DecimalV2Value value1(std::string("8.0")); - DecimalV2Value value2(std::string("0")); - DecimalV2Value sub_result = value2 - value1; - std::cout << "sub_result: " << sub_result.get_debug_info() << std::endl; - DecimalV2Value expected_value(std::string("-8.0")); - ASSERT_EQ(expected_value, sub_result); - ASSERT_FALSE(sub_result.is_zero()); - } - // minimum - maximal - { - DecimalV2Value value1(std::string("999999999999999999.999999999")); // 27 digits - DecimalV2Value value2(std::string("-999999999999999999.999999999")); // 27 digits - DecimalV2Value sub_result = value2 - value1; - std::cout << "sub_result: " << sub_result.get_debug_info() << std::endl; - ASSERT_STREQ("-1999999999999999999.999999998", sub_result.to_string().c_str()); - ASSERT_FALSE(sub_result.is_zero()); - ASSERT_TRUE(value1 > value2); - } + { + // from int + DecimalV2Value value3(4, 0); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } - - TEST_F(DecimalV2ValueTest, mul) { - DecimalV2Value value11(std::string("333333333.2222")); - DecimalV2Value value12(std::string("-222222222.1111")); - DecimalV2Value mul_result1 = value11 * value12; - std::cout << "mul_result1: " << mul_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalV2Value(std::string("-74074074012337037.04938642")), mul_result1); - - DecimalV2Value value21(std::string("0")); // zero - DecimalV2Value mul_result2 = value11 * value21; - std::cout << "mul_result2: " << mul_result2.get_debug_info() << std::endl; - ASSERT_EQ(DecimalV2Value(std::string("0")), mul_result2); + { + // from int + DecimalV2Value value3(3, -0); + EXPECT_TRUE(value < value3); + EXPECT_TRUE(value <= value3); + EXPECT_TRUE(value3 > value); + EXPECT_TRUE(value3 >= value); } +} - TEST_F(DecimalV2ValueTest, div) { - DecimalV2Value value11(std::string("-74074074012337037.04938642")); - DecimalV2Value value12(std::string("-222222222.1111")); +TEST_F(DecimalV2ValueTest, int_to_decimal) { + DecimalV2Value value1(0); + EXPECT_EQ("0.000", value1.to_string(3)); + + DecimalV2Value value2(111111111, 0); // 9 digits + EXPECT_EQ("111111111.000", value2.to_string(3)); + + DecimalV2Value value3(111111111, 222222222); // 9 digits + EXPECT_EQ("111111111.222", value3.to_string(3)); + + DecimalV2Value value4(0, 222222222); // 9 digits + EXPECT_EQ("0.222", value4.to_string(3)); + + DecimalV2Value value5(111111111, 0); // 9 digits + EXPECT_EQ("111111111.000", value5.to_string(3)); + + DecimalV2Value value6(0, 0); // 9 digits + EXPECT_EQ("0.000", value6.to_string(3)); + + DecimalV2Value value7(0, 12345); // 9 digits + EXPECT_EQ("0.000012", value7.to_string(6)); + + DecimalV2Value value8(11, 0); + EXPECT_EQ("11.000", value8.to_string(3)); + + // more than 9digit, fraction will be truncated to 999999999 + DecimalV2Value value9(1230123456789, 1230123456789); + EXPECT_EQ("1230123456789.999999999", value9.to_string(10)); + + // negative + { + DecimalV2Value value2(-111111111, 0); // 9 digits + EXPECT_EQ("-111111111.000", value2.to_string(3)); + + DecimalV2Value value3(-111111111, 222222222); // 9 digits + EXPECT_EQ("-111111111.222", value3.to_string(3)); + + DecimalV2Value value4(0, -222222222); // 9 digits + EXPECT_EQ("-0.222", value4.to_string(3)); + + DecimalV2Value value5(-111111111, 0); // 9 digits + EXPECT_EQ("-111111111.000", value5.to_string(3)); + + DecimalV2Value value7(0, -12345); // 9 digits + EXPECT_EQ("-0.000012", value7.to_string(6)); + + DecimalV2Value value8(-11, 0); + EXPECT_EQ("-11.000", value8.to_string(3)); + } +} + +TEST_F(DecimalV2ValueTest, add) { + DecimalV2Value value11(std::string("1111111111.222222222")); // 9 digits + DecimalV2Value value12(std::string("2222222222.111111111")); // 9 digits + DecimalV2Value add_result1 = value11 + value12; + EXPECT_EQ("3333333333.333333333", add_result1.to_string(9)); + + DecimalV2Value value21(std::string("-3333333333.222222222")); // 9 digits + DecimalV2Value value22(std::string("2222222222.111111111")); // 9 digits + DecimalV2Value add_result2 = value21 + value22; + EXPECT_EQ("-1111111111.111111111", add_result2.to_string(9)); +} + +TEST_F(DecimalV2ValueTest, compound_add) { + { + DecimalV2Value value1(std::string("111111111.222222222")); + DecimalV2Value value2(std::string("111111111.222222222")); + value1 += value2; + EXPECT_EQ("222222222.444444444", value1.to_string(9)); + } +} + +TEST_F(DecimalV2ValueTest, sub) { + DecimalV2Value value11(std::string("3333333333.222222222")); // 9 digits + DecimalV2Value value12(std::string("2222222222.111111111")); // 9 digits + DecimalV2Value sub_result1 = value11 - value12; + EXPECT_EQ("1111111111.111111111", sub_result1.to_string(9)); + + DecimalV2Value value21(std::string("-2222222222.111111111")); // 9 digits + DecimalV2Value sub_result2 = value11 - value21; + EXPECT_EQ("5555555555.333333333", sub_result2.to_string(9)); + + // small - big + { + DecimalV2Value value1(std::string("8.0")); + DecimalV2Value value2(std::string("0")); + DecimalV2Value sub_result = value2 - value1; + DecimalV2Value expected_value(std::string("-8.0")); + EXPECT_EQ(expected_value, sub_result); + EXPECT_FALSE(sub_result.is_zero()); + } + // minimum - maximal + { + DecimalV2Value value1(std::string("999999999999999999.999999999")); // 27 digits + DecimalV2Value value2(std::string("-999999999999999999.999999999")); // 27 digits + DecimalV2Value sub_result = value2 - value1; + EXPECT_STREQ("-1999999999999999999.999999998", sub_result.to_string().c_str()); + EXPECT_FALSE(sub_result.is_zero()); + EXPECT_TRUE(value1 > value2); + } +} + +TEST_F(DecimalV2ValueTest, mul) { + DecimalV2Value value11(std::string("333333333.2222")); + DecimalV2Value value12(std::string("-222222222.1111")); + DecimalV2Value mul_result1 = value11 * value12; + EXPECT_EQ(DecimalV2Value(std::string("-74074074012337037.04938642")), mul_result1); + + DecimalV2Value value21(std::string("0")); // zero + DecimalV2Value mul_result2 = value11 * value21; + EXPECT_EQ(DecimalV2Value(std::string("0")), mul_result2); +} + +TEST_F(DecimalV2ValueTest, div) { + DecimalV2Value value11(std::string("-74074074012337037.04938642")); + DecimalV2Value value12(std::string("-222222222.1111")); + DecimalV2Value div_result1 = value11 / value12; + EXPECT_EQ(DecimalV2Value(std::string("333333333.2222")), div_result1); + EXPECT_EQ("333333333.2222", div_result1.to_string()); + { + DecimalV2Value value11(std::string("32766.999943536")); + DecimalV2Value value12(std::string("604587")); DecimalV2Value div_result1 = value11 / value12; - std::cout << "div_result1: " << div_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalV2Value(std::string("333333333.2222")), div_result1); - ASSERT_EQ("333333333.2222", div_result1.to_string()); - { - DecimalV2Value value11(std::string("32766.999943536")); - DecimalV2Value value12(std::string("604587")); - DecimalV2Value div_result1 = value11 / value12; - std::cout << "div_result1: " << div_result1.get_debug_info() << std::endl; - ASSERT_EQ(DecimalV2Value(std::string("0.054197328")), div_result1); - } + EXPECT_EQ(DecimalV2Value(std::string("0.054197328")), div_result1); } +} - TEST_F(DecimalV2ValueTest, unary_minus_operator) { - { - DecimalV2Value value1(std::string("111111111.222222222")); - DecimalV2Value value2 = -value1; - std::cout << "value1: " << value1.get_debug_info() << std::endl; - std::cout << "value2: " << value2.get_debug_info() << std::endl; - ASSERT_EQ("111111111.222222222", value1.to_string(10)); - ASSERT_EQ("-111111111.222222222", value2.to_string(10)); - } +TEST_F(DecimalV2ValueTest, unary_minus_operator) { + { + DecimalV2Value value1(std::string("111111111.222222222")); + DecimalV2Value value2 = -value1; + EXPECT_EQ("111111111.222222222", value1.to_string(10)); + EXPECT_EQ("-111111111.222222222", value2.to_string(10)); } +} - TEST_F(DecimalV2ValueTest, to_int_frac_value) { - // positive & negative - { - DecimalV2Value value(std::string("123456789123456789.987654321")); - ASSERT_EQ(123456789123456789, value.int_value()); - ASSERT_EQ(987654321, value.frac_value()); +TEST_F(DecimalV2ValueTest, to_int_frac_value) { + // positive & negative + { + DecimalV2Value value(std::string("123456789123456789.987654321")); + EXPECT_EQ(123456789123456789, value.int_value()); + EXPECT_EQ(987654321, value.frac_value()); - DecimalV2Value value2(std::string("-123456789123456789.987654321")); - ASSERT_EQ(-123456789123456789, value2.int_value()); - ASSERT_EQ(-987654321, value2.frac_value()); - } - // int or frac part is 0 - { - DecimalV2Value value(std::string("-123456789123456789")); - ASSERT_EQ(-123456789123456789, value.int_value()); - ASSERT_EQ(0, value.frac_value()); - - DecimalV2Value value2(std::string("0.987654321")); - ASSERT_EQ(0, value2.int_value()); - ASSERT_EQ(987654321, value2.frac_value()); - } - // truncate frac part - { - DecimalV2Value value(std::string("-123456789.987654321987654321")); - ASSERT_EQ(-123456789, value.int_value()); - ASSERT_EQ(-987654322, value.frac_value()); - } + DecimalV2Value value2(std::string("-123456789123456789.987654321")); + EXPECT_EQ(-123456789123456789, value2.int_value()); + EXPECT_EQ(-987654321, value2.frac_value()); } + // int or frac part is 0 + { + DecimalV2Value value(std::string("-123456789123456789")); + EXPECT_EQ(-123456789123456789, value.int_value()); + EXPECT_EQ(0, value.frac_value()); + + DecimalV2Value value2(std::string("0.987654321")); + EXPECT_EQ(0, value2.int_value()); + EXPECT_EQ(987654321, value2.frac_value()); + } + // truncate frac part + { + DecimalV2Value value(std::string("-123456789.987654321987654321")); + EXPECT_EQ(-123456789, value.int_value()); + EXPECT_EQ(-987654322, value.frac_value()); + } +} // Half up - TEST_F(DecimalV2ValueTest, round_ops) { - // less than 5 - DecimalV2Value value(std::string("1.249")); +TEST_F(DecimalV2ValueTest, round_ops) { + // less than 5 + DecimalV2Value value(std::string("1.249")); + { + DecimalV2Value dst(0); + value.round(&dst, -1, HALF_UP); + EXPECT_EQ("0", dst.to_string()); + + value.round(&dst, -1, CEILING); + EXPECT_EQ("10", dst.to_string()); + + value.round(&dst, -1, FLOOR); + EXPECT_EQ("0", dst.to_string()); + + value.round(&dst, -1, TRUNCATE); + EXPECT_EQ("0", dst.to_string()); + } + { + DecimalV2Value dst(0); + value.round(&dst, 0, HALF_UP); + EXPECT_EQ("1", dst.to_string()); + + value.round(&dst, 0, CEILING); + EXPECT_EQ("2", dst.to_string()); + + value.round(&dst, 0, FLOOR); + EXPECT_EQ("1", dst.to_string()); + + value.round(&dst, 0, TRUNCATE); + EXPECT_EQ("1", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 1, HALF_UP); + EXPECT_EQ("1.2", dst.to_string()); + + value.round(&dst, 1, CEILING); + EXPECT_EQ("1.3", dst.to_string()); + + value.round(&dst, 1, FLOOR); + EXPECT_EQ("1.2", dst.to_string()); + + value.round(&dst, 1, TRUNCATE); + EXPECT_EQ("1.2", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 2, HALF_UP); + EXPECT_EQ("1.25", dst.to_string()); + + value.round(&dst, 2, CEILING); + EXPECT_EQ("1.25", dst.to_string()); + + value.round(&dst, 2, FLOOR); + EXPECT_EQ("1.24", dst.to_string()); + + value.round(&dst, 2, TRUNCATE); + EXPECT_EQ("1.24", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 3, HALF_UP); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 3, CEILING); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 3, FLOOR); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 3, TRUNCATE); + EXPECT_EQ("1.249", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 4, HALF_UP); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 4, CEILING); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 4, FLOOR); + EXPECT_EQ("1.249", dst.to_string()); + + value.round(&dst, 4, TRUNCATE); + EXPECT_EQ("1.249", dst.to_string()); + } +} + +// Half up +TEST_F(DecimalV2ValueTest, round_minus) { + // less than 5 + DecimalV2Value value(std::string("-1.249")); + { + DecimalV2Value dst(0); + value.round(&dst, -1, HALF_UP); + EXPECT_EQ("0", dst.to_string()); + + value.round(&dst, -1, CEILING); + EXPECT_EQ("0", dst.to_string()); + + value.round(&dst, -1, FLOOR); + EXPECT_EQ("-10", dst.to_string()); + + value.round(&dst, -1, TRUNCATE); + EXPECT_EQ("0", dst.to_string()); + } + { + DecimalV2Value dst(0); + value.round(&dst, 0, HALF_UP); + EXPECT_EQ("-1", dst.to_string()); + + value.round(&dst, 0, CEILING); + EXPECT_EQ("-1", dst.to_string()); + + value.round(&dst, 0, FLOOR); + EXPECT_EQ("-2", dst.to_string()); + + value.round(&dst, 0, TRUNCATE); + EXPECT_EQ("-1", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 1, HALF_UP); + EXPECT_EQ("-1.2", dst.to_string()); + + value.round(&dst, 1, CEILING); + EXPECT_EQ("-1.2", dst.to_string()); + + value.round(&dst, 1, FLOOR); + EXPECT_EQ("-1.3", dst.to_string()); + + value.round(&dst, 1, TRUNCATE); + EXPECT_EQ("-1.2", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 2, HALF_UP); + EXPECT_EQ("-1.25", dst.to_string()); + + value.round(&dst, 2, CEILING); + EXPECT_EQ("-1.24", dst.to_string()); + + value.round(&dst, 2, FLOOR); + EXPECT_EQ("-1.25", dst.to_string()); + + value.round(&dst, 2, TRUNCATE); + EXPECT_EQ("-1.24", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 3, HALF_UP); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 3, CEILING); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 3, FLOOR); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 3, TRUNCATE); + EXPECT_EQ("-1.249", dst.to_string()); + } + + { + DecimalV2Value dst(0); + value.round(&dst, 4, HALF_UP); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 4, CEILING); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 4, FLOOR); + EXPECT_EQ("-1.249", dst.to_string()); + + value.round(&dst, 4, TRUNCATE); + EXPECT_EQ("-1.249", dst.to_string()); + } +} + +// Half up +TEST_F(DecimalV2ValueTest, round_to_int) { + { + DecimalV2Value value(std::string("99.99")); { - DecimalV2Value dst(0); - value.round(&dst, -1, HALF_UP); - ASSERT_EQ("0", dst.to_string()); - - value.round(&dst, -1, CEILING); - ASSERT_EQ("10", dst.to_string()); - - value.round(&dst, -1, FLOOR); - ASSERT_EQ("0", dst.to_string()); - - value.round(&dst, -1, TRUNCATE); - ASSERT_EQ("0", dst.to_string()); - } - { - DecimalV2Value dst(0); - value.round(&dst, 0, HALF_UP); - ASSERT_EQ("1", dst.to_string()); - - value.round(&dst, 0, CEILING); - ASSERT_EQ("2", dst.to_string()); - - value.round(&dst, 0, FLOOR); - ASSERT_EQ("1", dst.to_string()); - - value.round(&dst, 0, TRUNCATE); - ASSERT_EQ("1", dst.to_string()); - } - - { - DecimalV2Value dst(0); + DecimalV2Value dst; value.round(&dst, 1, HALF_UP); - ASSERT_EQ("1.2", dst.to_string()); - - value.round(&dst, 1, CEILING); - ASSERT_EQ("1.3", dst.to_string()); - - value.round(&dst, 1, FLOOR); - ASSERT_EQ("1.2", dst.to_string()); - - value.round(&dst, 1, TRUNCATE); - ASSERT_EQ("1.2", dst.to_string()); + EXPECT_EQ("100", dst.to_string()); } - + } + { + DecimalV2Value value(std::string("123.12399")); { - DecimalV2Value dst(0); - value.round(&dst, 2, HALF_UP); - ASSERT_EQ("1.25", dst.to_string()); - - value.round(&dst, 2, CEILING); - ASSERT_EQ("1.25", dst.to_string()); - - value.round(&dst, 2, FLOOR); - ASSERT_EQ("1.24", dst.to_string()); - - value.round(&dst, 2, TRUNCATE); - ASSERT_EQ("1.24", dst.to_string()); - } - - { - DecimalV2Value dst(0); - value.round(&dst, 3, HALF_UP); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 3, CEILING); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 3, FLOOR); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 3, TRUNCATE); - ASSERT_EQ("1.249", dst.to_string()); - } - - { - DecimalV2Value dst(0); + DecimalV2Value dst; value.round(&dst, 4, HALF_UP); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 4, CEILING); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 4, FLOOR); - ASSERT_EQ("1.249", dst.to_string()); - - value.round(&dst, 4, TRUNCATE); - ASSERT_EQ("1.249", dst.to_string()); + EXPECT_EQ("123.124", dst.to_string()); } } +} -// Half up - TEST_F(DecimalV2ValueTest, round_minus) { - // less than 5 - DecimalV2Value value(std::string("-1.249")); - { - DecimalV2Value dst(0); - value.round(&dst, -1, HALF_UP); - ASSERT_EQ("0", dst.to_string()); +TEST_F(DecimalV2ValueTest, double_to_decimal) { + double i = 1.2; + DecimalV2Value* value = new DecimalV2Value(100, 9876); + value->assign_from_double(i); + EXPECT_STREQ("1.2", value->to_string().c_str()); + delete value; +} - value.round(&dst, -1, CEILING); - ASSERT_EQ("0", dst.to_string()); - - value.round(&dst, -1, FLOOR); - ASSERT_EQ("-10", dst.to_string()); - - value.round(&dst, -1, TRUNCATE); - ASSERT_EQ("0", dst.to_string()); - } - { - DecimalV2Value dst(0); - value.round(&dst, 0, HALF_UP); - ASSERT_EQ("-1", dst.to_string()); - - value.round(&dst, 0, CEILING); - ASSERT_EQ("-1", dst.to_string()); - - value.round(&dst, 0, FLOOR); - ASSERT_EQ("-2", dst.to_string()); - - value.round(&dst, 0, TRUNCATE); - ASSERT_EQ("-1", dst.to_string()); - } - - { - DecimalV2Value dst(0); - value.round(&dst, 1, HALF_UP); - ASSERT_EQ("-1.2", dst.to_string()); - - value.round(&dst, 1, CEILING); - ASSERT_EQ("-1.2", dst.to_string()); - - value.round(&dst, 1, FLOOR); - ASSERT_EQ("-1.3", dst.to_string()); - - value.round(&dst, 1, TRUNCATE); - ASSERT_EQ("-1.2", dst.to_string()); - } - - { - DecimalV2Value dst(0); - value.round(&dst, 2, HALF_UP); - ASSERT_EQ("-1.25", dst.to_string()); - - value.round(&dst, 2, CEILING); - ASSERT_EQ("-1.24", dst.to_string()); - - value.round(&dst, 2, FLOOR); - ASSERT_EQ("-1.25", dst.to_string()); - - value.round(&dst, 2, TRUNCATE); - ASSERT_EQ("-1.24", dst.to_string()); - } - - { - DecimalV2Value dst(0); - value.round(&dst, 3, HALF_UP); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 3, CEILING); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 3, FLOOR); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 3, TRUNCATE); - ASSERT_EQ("-1.249", dst.to_string()); - } - - { - DecimalV2Value dst(0); - value.round(&dst, 4, HALF_UP); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 4, CEILING); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 4, FLOOR); - ASSERT_EQ("-1.249", dst.to_string()); - - value.round(&dst, 4, TRUNCATE); - ASSERT_EQ("-1.249", dst.to_string()); - } - } - -// Half up - TEST_F(DecimalV2ValueTest, round_to_int) { - { - DecimalV2Value value(std::string("99.99")); - { - DecimalV2Value dst; - value.round(&dst, 1, HALF_UP); - ASSERT_EQ("100", dst.to_string()); - } - } - { - DecimalV2Value value(std::string("123.12399")); - { - DecimalV2Value dst; - value.round(&dst, 4, HALF_UP); - ASSERT_EQ("123.124", dst.to_string()); - } - } - } - - TEST_F(DecimalV2ValueTest, double_to_decimal) { - double i = 1.2; - DecimalV2Value* value = new DecimalV2Value(100, 9876); - value->assign_from_double(i); - ASSERT_STREQ("1.2", value->to_string().c_str()); - delete value; - } - - TEST_F(DecimalV2ValueTest, float_to_decimal) { - float i = 1.2; - DecimalV2Value* value = new DecimalV2Value(100, 9876); - value->assign_from_float(i); - ASSERT_STREQ("1.2", value->to_string().c_str()); - delete value; - } +TEST_F(DecimalV2ValueTest, float_to_decimal) { + float i = 1.2; + DecimalV2Value* value = new DecimalV2Value(100, 9876); + value->assign_from_float(i); + EXPECT_STREQ("1.2", value->to_string().c_str()); + delete value; +} } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/runtime/disk_io_mgr_test.cpp b/be/test/runtime/disk_io_mgr_test.cpp index dbbc604dfa..f370aed7ff 100644 --- a/be/test/runtime/disk_io_mgr_test.cpp +++ b/be/test/runtime/disk_io_mgr_test.cpp @@ -120,8 +120,8 @@ protected: int expected_len = -1) { DiskIoMgr::BufferDescriptor* buffer; Status status = io_mgr->read(reader, range, &buffer); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(buffer != nullptr); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(buffer != nullptr); EXPECT_EQ(buffer->len(), range->len()); if (expected_len < 0) { expected_len = strlen(expected); @@ -139,12 +139,12 @@ protected: while (true) { DiskIoMgr::BufferDescriptor* buffer = nullptr; Status status = range->get_next(&buffer); - ASSERT_TRUE(status.ok() || status.code() == expected_status.code()); + EXPECT_TRUE(status.ok() || status.code() == expected_status.code()); if (buffer == nullptr || !status.ok()) { if (buffer != nullptr) buffer->return_buffer(); break; } - ASSERT_LE(buffer->len(), expected_len); + EXPECT_LE(buffer->len(), expected_len); memcpy(result + range->offset() + buffer->scan_range_offset(), buffer->buffer(), buffer->len()); buffer->return_buffer(); @@ -162,7 +162,7 @@ protected: while (max_ranges == 0 || num_ranges < max_ranges) { DiskIoMgr::ScanRange* range; Status status = io_mgr->get_next_range(reader, &range); - ASSERT_TRUE(status.ok() || status.code() == expected_status.code()); + EXPECT_TRUE(status.ok() || status.code() == expected_status.code()); if (range == nullptr) break; validate_scan_range(range, expected_result, expected_len, expected_status); ++(*num_ranges_processed); @@ -206,16 +206,16 @@ TEST_F(DiskIoMgrTest, SingleWriter) { std::unique_ptr read_io_mgr(new DiskIoMgr(1, 1, 1, 10)); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); Status status = read_io_mgr->init(reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::RequestContext* reader; status = read_io_mgr->register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int num_threads_per_disk = 1; num_threads_per_disk <= 5; ++num_threads_per_disk) { for (int num_disks = 1; num_disks <= 5; num_disks += 2) { _pool.reset(new ObjectPool); DiskIoMgr io_mgr(num_disks, num_threads_per_disk, 1, 10); status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::RequestContext* writer; io_mgr.register_context(&writer, mem_tracker); for (int i = 0; i < num_ranges; ++i) { @@ -256,7 +256,7 @@ TEST_F(DiskIoMgrTest, InvalidWrite) { string tmp_file = "/tmp/non-existent.txt"; DiskIoMgr io_mgr(1, 1, 1, 10); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::RequestContext* writer; status = io_mgr.register_context(&writer); _pool.reset(new ObjectPool); @@ -323,10 +323,10 @@ TEST_F(DiskIoMgrTest, SingleWriterCancel) { std::unique_ptr read_io_mgr(new DiskIoMgr(1, 1, 1, 10)); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); Status status = read_io_mgr->init(reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::RequestContext* reader; status = read_io_mgr->register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int num_threads_per_disk = 1; num_threads_per_disk <= 5; ++num_threads_per_disk) { for (int num_disks = 1; num_disks <= 5; num_disks += 2) { _pool.reset(new ObjectPool); @@ -399,11 +399,11 @@ TEST_F(DiskIoMgrTest, SingleReader) { DiskIoMgr io_mgr(num_disks, num_threads_per_disk, 1, 1); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector ranges; for (int i = 0; i < len; ++i) { @@ -412,7 +412,7 @@ TEST_F(DiskIoMgrTest, SingleReader) { stat_val.st_mtime)); } status = io_mgr.add_scan_ranges(reader, ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::atomic num_ranges_processed; ThreadGroup threads; @@ -456,11 +456,11 @@ TEST_F(DiskIoMgrTest, AddScanRangeTest) { DiskIoMgr io_mgr(num_disks, num_threads_per_disk, 1, 1); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector ranges_first_half; std::vector ranges_second_half; @@ -478,7 +478,7 @@ TEST_F(DiskIoMgrTest, AddScanRangeTest) { // Issue first half the scan ranges. status = io_mgr.add_scan_ranges(reader, ranges_first_half); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Read a couple of them scan_range_thread(&io_mgr, reader, data, strlen(data), Status::OK(), 2, @@ -486,7 +486,7 @@ TEST_F(DiskIoMgrTest, AddScanRangeTest) { // Issue second half status = io_mgr.add_scan_ranges(reader, ranges_second_half); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Start up some threads and then cancel ThreadGroup threads; @@ -535,11 +535,11 @@ TEST_F(DiskIoMgrTest, SyncReadTest) { DiskIoMgr io_mgr(num_disks, num_threads_per_disk, MIN_BUFFER_SIZE, MAX_BUFFER_SIZE); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::ScanRange* complete_range = init_range(1, tmp_file, 0, strlen(data), 0, stat_val.st_mtime); @@ -555,7 +555,7 @@ TEST_F(DiskIoMgrTest, SyncReadTest) { init_range(num_buffers, tmp_file, 0, len, disk_id, stat_val.st_mtime)); } status = io_mgr.add_scan_ranges(reader, ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::atomic num_ranges_processed; ThreadGroup threads; @@ -609,11 +609,11 @@ TEST_F(DiskIoMgrTest, SingleReaderCancel) { DiskIoMgr io_mgr(num_disks, num_threads_per_disk, 1, 1); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector ranges; for (int i = 0; i < len; ++i) { @@ -622,7 +622,7 @@ TEST_F(DiskIoMgrTest, SingleReaderCancel) { init_range(num_buffers, tmp_file, 0, len, disk_id, stat_val.st_mtime)); } status = io_mgr.add_scan_ranges(reader, ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::atomic num_ranges_processed; int num_succesful_ranges = ranges.size() / 2; @@ -681,18 +681,18 @@ TEST_F(DiskIoMgrTest, MemTrackers) { DiskIoMgr io_mgr(1, 1, MIN_BUFFER_SIZE, MAX_BUFFER_SIZE); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector ranges; for (int i = 0; i < num_buffers; ++i) { ranges.push_back(init_range(num_buffers, tmp_file, 0, len, 0, stat_val.st_mtime)); } status = io_mgr.add_scan_ranges(reader, ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // Don't return buffers to force memory pressure std::vector buffers; @@ -708,13 +708,13 @@ TEST_F(DiskIoMgrTest, MemTrackers) { memset(result, 0, strlen(data) + 1); DiskIoMgr::ScanRange* range = nullptr; status = io_mgr.get_next_range(reader, &range); - ASSERT_TRUE(status.ok() || status.is_mem_limit_exceeded()); + EXPECT_TRUE(status.ok() || status.is_mem_limit_exceeded()); if (range == nullptr) break; while (true) { DiskIoMgr::BufferDescriptor* buffer = nullptr; Status status = range->get_next(&buffer); - ASSERT_TRUE(status.ok() || status.is_mem_limit_exceeded()); + EXPECT_TRUE(status.ok() || status.is_mem_limit_exceeded()); if (buffer == nullptr) break; memcpy(result + range->offset() + buffer->scan_range_offset(), buffer->buffer(), buffer->len()); @@ -758,11 +758,11 @@ TEST_F(DiskIoMgrTest, CachedReads) { DiskIoMgr io_mgr(num_disks, 1, MIN_BUFFER_SIZE, MAX_BUFFER_SIZE); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker()); DiskIoMgr::RequestContext* reader; status = io_mgr.register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); DiskIoMgr::ScanRange* complete_range = init_range(1, tmp_file, 0, strlen(data), 0, stat_val.st_mtime, nullptr, true); @@ -778,7 +778,7 @@ TEST_F(DiskIoMgrTest, CachedReads) { stat_val.st_mtime, nullptr, true)); } status = io_mgr.add_scan_ranges(reader, ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::atomic num_ranges_processed; ThreadGroup threads; @@ -819,7 +819,7 @@ TEST_F(DiskIoMgrTest, MultipleReaderWriter) { int success = CreateTempFile(file_name.c_str(), file_size); if (success != 0) { LOG(ERROR) << "Error creating temp file " << file_name.c_str() << " of size " << file_size; - ASSERT_TRUE(false); + EXPECT_TRUE(false); } // Get mtime for file @@ -836,7 +836,7 @@ TEST_F(DiskIoMgrTest, MultipleReaderWriter) { io_mgr.init(mem_tracker); for (int file_index = 0; file_index < num_contexts; ++file_index) { status = io_mgr.register_context(&contexts[file_index]); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } _pool.reset(new ObjectPool); int read_offset = 0; @@ -954,11 +954,11 @@ TEST_F(DiskIoMgrTest, MultipleReader) { DiskIoMgr io_mgr(num_disks, threads_per_disk, MIN_BUFFER_SIZE, MAX_BUFFER_SIZE); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); for (int i = 0; i < NUM_READERS; ++i) { status = io_mgr.register_context(&readers[i], nullptr); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::vector ranges; for (int j = 0; j < DATA_LEN; ++j) { @@ -967,7 +967,7 @@ TEST_F(DiskIoMgrTest, MultipleReader) { disk_id, mtimes[i])); } status = io_mgr.add_scan_ranges(readers[i], ranges); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } std::atomic num_ranges_processed; @@ -1010,8 +1010,8 @@ TEST_F(DiskIoMgrTest, Buffers) { DiskIoMgr io_mgr(1, 1, min_buffer_size, max_buffer_size); Status status = io_mgr.init(mem_tracker); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(mem_tracker->consumption(), 0); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(mem_tracker->consumption(), 0); // buffer length should be rounded up to min buffer size int64_t buffer_len = 1; @@ -1074,20 +1074,20 @@ TEST_F(DiskIoMgrTest, PartialRead) { std::unique_ptr io_mgr(new DiskIoMgr(1, 1, read_len, read_len)); Status status = io_mgr->init(mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr reader_mem_tracker(new MemTracker(LARGE_MEM_LIMIT)); DiskIoMgr::RequestContext* reader; status = io_mgr->register_context(&reader, reader_mem_tracker); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // We should not read past the end of file. DiskIoMgr::ScanRange* range = init_range(1, tmp_file, 0, read_len, 0, stat_val.st_mtime); DiskIoMgr::BufferDescriptor* buffer; status = io_mgr->read(reader, range, &buffer); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(buffer->eosr()); - ASSERT_EQ(len, buffer->len()); - ASSERT_TRUE(memcmp(buffer->buffer(), data, len) == 0); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(buffer->eosr()); + EXPECT_EQ(len, buffer->len()); + EXPECT_TRUE(memcmp(buffer->buffer(), data, len) == 0); buffer->return_buffer(); io_mgr->unregister_context(reader); @@ -1098,21 +1098,3 @@ TEST_F(DiskIoMgrTest, PartialRead) { } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::config::query_scratch_dirs = "/tmp"; - doris::config::max_free_io_buffers = 128; - doris::config::disable_mem_pools = false; - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::CpuInfo::init(); - doris::DiskInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/dpp_sink_internal_test.cpp b/be/test/runtime/dpp_sink_internal_test.cpp index 7f4aebd706..aa6c170231 100644 --- a/be/test/runtime/dpp_sink_internal_test.cpp +++ b/be/test/runtime/dpp_sink_internal_test.cpp @@ -67,8 +67,8 @@ TEST_F(DppSinkInternalTest, PartitionInfoNormal) { PartitionInfo info; - ASSERT_TRUE(PartitionInfo::from_thrift(&pool, t_partition, &info).ok()); - ASSERT_TRUE(info.prepare(nullptr, RowDescriptor()).ok()); + EXPECT_TRUE(PartitionInfo::from_thrift(&pool, t_partition, &info).ok()); + EXPECT_TRUE(info.prepare(nullptr, RowDescriptor()).ok()); } TEST_F(DppSinkInternalTest, ZeroBucket) { @@ -90,12 +90,7 @@ TEST_F(DppSinkInternalTest, ZeroBucket) { PartitionInfo info; - ASSERT_FALSE(PartitionInfo::from_thrift(&pool, t_partition, &info).ok()); + EXPECT_FALSE(PartitionInfo::from_thrift(&pool, t_partition, &info).ok()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/etl_job_mgr_test.cpp b/be/test/runtime/etl_job_mgr_test.cpp index e8bcec1b78..edb8d140c3 100644 --- a/be/test/runtime/etl_job_mgr_test.cpp +++ b/be/test/runtime/etl_job_mgr_test.cpp @@ -57,26 +57,26 @@ TEST_F(EtlJobMgrTest, NormalCase) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing EtlJobResult job_result; job_result.file_map["abc"] = 100L; - ASSERT_TRUE(mgr.finish_job(id, Status::OK(), job_result).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::FINISHED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.file_map.size()); - ASSERT_EQ(100, res.file_map["abc"]); + EXPECT_TRUE(mgr.finish_job(id, Status::OK(), job_result).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::FINISHED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.file_map.size()); + EXPECT_EQ(100, res.file_map["abc"]); // erase it - ASSERT_TRUE(mgr.erase_job(del_req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::CANCELLED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.erase_job(del_req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::CANCELLED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(EtlJobMgrTest, DuplicateCase) { @@ -90,16 +90,16 @@ TEST_F(EtlJobMgrTest, DuplicateCase) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(EtlJobMgrTest, RunAfterSuccess) { @@ -115,28 +115,28 @@ TEST_F(EtlJobMgrTest, RunAfterSuccess) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing EtlJobResult job_result; job_result.file_map["abc"] = 100L; - ASSERT_TRUE(mgr.finish_job(id, Status::OK(), job_result).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::FINISHED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.file_map.size()); - ASSERT_EQ(100, res.file_map["abc"]); + EXPECT_TRUE(mgr.finish_job(id, Status::OK(), job_result).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::FINISHED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.file_map.size()); + EXPECT_EQ(100, res.file_map["abc"]); // Put it twice - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::FINISHED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.file_map.size()); - ASSERT_EQ(100, res.file_map["abc"]); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::FINISHED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.file_map.size()); + EXPECT_EQ(100, res.file_map["abc"]); } TEST_F(EtlJobMgrTest, RunAfterFail) { @@ -150,24 +150,24 @@ TEST_F(EtlJobMgrTest, RunAfterFail) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing EtlJobResult job_result; job_result.debug_path = "abc"; - ASSERT_TRUE(mgr.finish_job(id, Status::ThriftRpcError("Thrift rpc error"), job_result).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::CANCELLED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.finish_job(id, Status::ThriftRpcError("Thrift rpc error"), job_result).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::CANCELLED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(EtlJobMgrTest, CancelJob) { @@ -181,24 +181,24 @@ TEST_F(EtlJobMgrTest, CancelJob) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing EtlJobResult job_result; job_result.debug_path = "abc"; - ASSERT_TRUE(mgr.cancel_job(id).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::CANCELLED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.cancel_job(id).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::CANCELLED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_job(req).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::RUNNING, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_job(req).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::RUNNING, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(EtlJobMgrTest, FinishUnknownJob) { @@ -212,21 +212,10 @@ TEST_F(EtlJobMgrTest, FinishUnknownJob) { // make it finishing EtlJobResult job_result; job_result.debug_path = "abc"; - ASSERT_FALSE(mgr.finish_job(id, Status::ThriftRpcError("Thrift rpc error"), job_result).ok()); - ASSERT_TRUE(mgr.get_job_state(id, &res).ok()); - ASSERT_EQ(TEtlState::CANCELLED, res.etl_state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_FALSE(mgr.finish_job(id, Status::ThriftRpcError("Thrift rpc error"), job_result).ok()); + EXPECT_TRUE(mgr.get_job_state(id, &res).ok()); + EXPECT_EQ(TEtlState::CANCELLED, res.etl_state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/export_task_mgr_test.cpp b/be/test/runtime/export_task_mgr_test.cpp index bb4a358d51..b3fc91f5cc 100644 --- a/be/test/runtime/export_task_mgr_test.cpp +++ b/be/test/runtime/export_task_mgr_test.cpp @@ -58,25 +58,25 @@ TEST_F(ExportTaskMgrTest, NormalCase) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing ExportTaskResult task_result; task_result.files.push_back("path/file1"); - ASSERT_TRUE(mgr.finish_task(id, Status::OK(), task_result).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::FINISHED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.files.size()); + EXPECT_TRUE(mgr.finish_task(id, Status::OK(), task_result).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::FINISHED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.files.size()); // erase it - ASSERT_TRUE(mgr.erase_task(id).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::CANCELLED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.erase_task(id).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::CANCELLED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(ExportTaskMgrTest, DuplicateCase) { @@ -90,16 +90,16 @@ TEST_F(ExportTaskMgrTest, DuplicateCase) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(ExportTaskMgrTest, RunAfterSuccess) { @@ -113,28 +113,28 @@ TEST_F(ExportTaskMgrTest, RunAfterSuccess) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing ExportTaskResult task_result; task_result.files.push_back("path/file1"); - ASSERT_TRUE(mgr.finish_task(id, Status::OK(), task_result).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::FINISHED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.files.size()); - ASSERT_EQ("path/file1", res.files[0]); + EXPECT_TRUE(mgr.finish_task(id, Status::OK(), task_result).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::FINISHED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.files.size()); + EXPECT_EQ("path/file1", res.files[0]); // Put it twice - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::FINISHED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); - ASSERT_EQ(1, res.files.size()); - ASSERT_EQ("path/file1", res.files[0]); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::FINISHED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_EQ(1, res.files.size()); + EXPECT_EQ("path/file1", res.files[0]); } TEST_F(ExportTaskMgrTest, RunAfterFail) { @@ -148,23 +148,23 @@ TEST_F(ExportTaskMgrTest, RunAfterFail) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing ExportTaskResult task_result; - ASSERT_TRUE(mgr.finish_task(id, Status::ThriftRpcError("Thrift rpc error"), task_result).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::CANCELLED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.finish_task(id, Status::ThriftRpcError("Thrift rpc error"), task_result).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::CANCELLED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(ExportTaskMgrTest, CancelJob) { @@ -178,23 +178,23 @@ TEST_F(ExportTaskMgrTest, CancelJob) { req.params.params.fragment_instance_id = id; // make it running - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // make it finishing ExportTaskResult task_result; - ASSERT_TRUE(mgr.cancel_task(id).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::CANCELLED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.cancel_task(id).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::CANCELLED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); // Put it twice - ASSERT_TRUE(mgr.start_task(req).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::RUNNING, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_TRUE(mgr.start_task(req).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::RUNNING, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } TEST_F(ExportTaskMgrTest, FinishUnknownJob) { @@ -207,27 +207,10 @@ TEST_F(ExportTaskMgrTest, FinishUnknownJob) { // make it finishing ExportTaskResult task_result; - ASSERT_FALSE(mgr.finish_task(id, Status::ThriftRpcError("Thrift rpc error"), task_result).ok()); - ASSERT_TRUE(mgr.get_task_state(id, &res).ok()); - ASSERT_EQ(TExportState::CANCELLED, res.state); - ASSERT_EQ(TStatusCode::OK, res.status.status_code); + EXPECT_FALSE(mgr.finish_task(id, Status::ThriftRpcError("Thrift rpc error"), task_result).ok()); + EXPECT_TRUE(mgr.get_task_state(id, &res).ok()); + EXPECT_EQ(TExportState::CANCELLED, res.state); + EXPECT_EQ(TStatusCode::OK, res.status.status_code); } } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - - doris::config::read_size = 8388608; - doris::config::min_buffer_size = 1024; - doris::CpuInfo::init(); - doris::DiskInfo::init(); - doris::config::pull_load_task_dir = "/tmp"; - - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/external_scan_context_mgr_test.cpp b/be/test/runtime/external_scan_context_mgr_test.cpp index f82f8967cb..a9d1660f55 100644 --- a/be/test/runtime/external_scan_context_mgr_test.cpp +++ b/be/test/runtime/external_scan_context_mgr_test.cpp @@ -56,22 +56,22 @@ TEST_F(ExternalScanContextMgrTest, create_normal) { std::shared_ptr context; ExternalScanContextMgr context_mgr(&_exec_env); Status st = context_mgr.create_scan_context(&context); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(context != nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(context != nullptr); } TEST_F(ExternalScanContextMgrTest, get_normal) { std::shared_ptr context; ExternalScanContextMgr context_mgr(&_exec_env); Status st = context_mgr.create_scan_context(&context); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(context != nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(context != nullptr); std::string context_id = context->context_id; std::shared_ptr result; st = context_mgr.get_scan_context(context_id, &result); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(context != nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(context != nullptr); } TEST_F(ExternalScanContextMgrTest, get_abnormal) { @@ -79,36 +79,24 @@ TEST_F(ExternalScanContextMgrTest, get_abnormal) { std::shared_ptr result; ExternalScanContextMgr context_mgr(&_exec_env); Status st = context_mgr.get_scan_context(context_id, &result); - ASSERT_TRUE(!st.ok()); - ASSERT_TRUE(result == nullptr); + EXPECT_TRUE(!st.ok()); + EXPECT_TRUE(result == nullptr); } TEST_F(ExternalScanContextMgrTest, clear_context) { std::shared_ptr context; ExternalScanContextMgr context_mgr(&_exec_env); Status st = context_mgr.create_scan_context(&context); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(context != nullptr); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(context != nullptr); std::string context_id = context->context_id; st = context_mgr.clear_scan_context(context_id); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::shared_ptr result; st = context_mgr.get_scan_context(context_id, &result); - ASSERT_TRUE(!st.ok()); - ASSERT_TRUE(result == nullptr); + EXPECT_TRUE(!st.ok()); + EXPECT_TRUE(result == nullptr); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/fragment_mgr_test.cpp b/be/test/runtime/fragment_mgr_test.cpp index 304d6d8f77..4bb2cb58c5 100644 --- a/be/test/runtime/fragment_mgr_test.cpp +++ b/be/test/runtime/fragment_mgr_test.cpp @@ -79,9 +79,9 @@ TEST_F(FragmentMgrTest, Normal) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100); params.params.fragment_instance_id.__set_lo(200); - ASSERT_TRUE(mgr.exec_plan_fragment(params).ok()); + EXPECT_TRUE(mgr.exec_plan_fragment(params).ok()); // Duplicated - ASSERT_TRUE(mgr.exec_plan_fragment(params).ok()); + EXPECT_TRUE(mgr.exec_plan_fragment(params).ok()); } TEST_F(FragmentMgrTest, AddNormal) { @@ -91,7 +91,7 @@ TEST_F(FragmentMgrTest, AddNormal) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100 + i); params.params.fragment_instance_id.__set_lo(200); - ASSERT_TRUE(mgr.exec_plan_fragment(params).ok()); + EXPECT_TRUE(mgr.exec_plan_fragment(params).ok()); } } @@ -101,9 +101,9 @@ TEST_F(FragmentMgrTest, CancelNormal) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100); params.params.fragment_instance_id.__set_lo(200); - ASSERT_TRUE(mgr.exec_plan_fragment(params).ok()); + EXPECT_TRUE(mgr.exec_plan_fragment(params).ok()); // Cancel after add - ASSERT_TRUE(mgr.cancel(params.params.fragment_instance_id).ok()); + EXPECT_TRUE(mgr.cancel(params.params.fragment_instance_id).ok()); } TEST_F(FragmentMgrTest, CancelWithoutAdd) { @@ -112,7 +112,7 @@ TEST_F(FragmentMgrTest, CancelWithoutAdd) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100); params.params.fragment_instance_id.__set_lo(200); - ASSERT_TRUE(mgr.cancel(params.params.fragment_instance_id).ok()); + EXPECT_TRUE(mgr.cancel(params.params.fragment_instance_id).ok()); } TEST_F(FragmentMgrTest, PrepareFailed) { @@ -122,7 +122,7 @@ TEST_F(FragmentMgrTest, PrepareFailed) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100); params.params.fragment_instance_id.__set_lo(200); - ASSERT_FALSE(mgr.exec_plan_fragment(params).ok()); + EXPECT_FALSE(mgr.exec_plan_fragment(params).ok()); } TEST_F(FragmentMgrTest, OfferPoolFailed) { @@ -136,7 +136,7 @@ TEST_F(FragmentMgrTest, OfferPoolFailed) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100); params.params.fragment_instance_id.__set_lo(200); - ASSERT_TRUE(mgr.exec_plan_fragment(params).ok()); + EXPECT_TRUE(mgr.exec_plan_fragment(params).ok()); // the first plan open will cost 50ms, so the next 3 plans will be aborted. for (int i = 1; i < 4; ++i) { @@ -144,15 +144,9 @@ TEST_F(FragmentMgrTest, OfferPoolFailed) { params.params.fragment_instance_id = TUniqueId(); params.params.fragment_instance_id.__set_hi(100 + i); params.params.fragment_instance_id.__set_lo(200); - ASSERT_FALSE(mgr.exec_plan_fragment(params).ok()); + EXPECT_FALSE(mgr.exec_plan_fragment(params).ok()); } - ASSERT_EQ(3, s_abort_cnt); + EXPECT_EQ(3, s_abort_cnt); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/free_list_test.cpp b/be/test/runtime/free_list_test.cpp index e67aa533e6..875c97ad8c 100644 --- a/be/test/runtime/free_list_test.cpp +++ b/be/test/runtime/free_list_test.cpp @@ -151,16 +151,3 @@ TEST(FreeListTest, Basic) { } } // namespace doris - -int main(int argc, char** argv) { -#if 0 - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); -#endif - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/heartbeat_flags_test.cpp b/be/test/runtime/heartbeat_flags_test.cpp index 022be2191a..b7970bbdcc 100644 --- a/be/test/runtime/heartbeat_flags_test.cpp +++ b/be/test/runtime/heartbeat_flags_test.cpp @@ -27,16 +27,11 @@ private: }; TEST_F(HeartbeatFlagsTest, normal) { - ASSERT_FALSE(_flags.is_set_default_rowset_type_to_beta()); + EXPECT_FALSE(_flags.is_set_default_rowset_type_to_beta()); _flags.update(1); - ASSERT_TRUE(_flags.is_set_default_rowset_type_to_beta()); + EXPECT_TRUE(_flags.is_set_default_rowset_type_to_beta()); _flags.update(2); - ASSERT_FALSE(_flags.is_set_default_rowset_type_to_beta()); + EXPECT_FALSE(_flags.is_set_default_rowset_type_to_beta()); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/kafka_consumer_pipe_test.cpp b/be/test/runtime/kafka_consumer_pipe_test.cpp index 9b19c124e5..ee10e42eee 100644 --- a/be/test/runtime/kafka_consumer_pipe_test.cpp +++ b/be/test/runtime/kafka_consumer_pipe_test.cpp @@ -41,32 +41,26 @@ TEST_F(KafkaConsumerPipeTest, append_read) { Status st; st = k_pipe.append_with_line_delimiter(msg1.c_str(), msg1.length()); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = k_pipe.append_with_line_delimiter(msg2.c_str(), msg2.length()); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = k_pipe.finish(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); char buf[1024]; int64_t data_size = 1024; int64_t read_bytes = 0; bool eof = false; st = k_pipe.read((uint8_t*)buf, data_size, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(read_bytes, msg1.length() + msg2.length() + 2); - ASSERT_EQ(eof, false); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(read_bytes, msg1.length() + msg2.length() + 2); + EXPECT_EQ(eof, false); data_size = 1024; st = k_pipe.read((uint8_t*)buf, data_size, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(read_bytes, 0); - ASSERT_EQ(eof, true); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(read_bytes, 0); + EXPECT_EQ(eof, true); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/large_int_value_test.cpp b/be/test/runtime/large_int_value_test.cpp index eabb1d2167..af77e190d0 100644 --- a/be/test/runtime/large_int_value_test.cpp +++ b/be/test/runtime/large_int_value_test.cpp @@ -17,9 +17,9 @@ #include "runtime/large_int_value.h" +#include #include -#include #include #include #include @@ -45,7 +45,7 @@ TEST_F(LargeIntValueTest, string_to_largeint) { ss << str; __int128 v; ss >> v; - ASSERT_EQ(v, 1024); + EXPECT_EQ(v, 1024); } { @@ -54,7 +54,7 @@ TEST_F(LargeIntValueTest, string_to_largeint) { ss << str; __int128 v; ss >> v; - ASSERT_TRUE(v == MAX_INT128); + EXPECT_TRUE(v == MAX_INT128); } { @@ -63,7 +63,7 @@ TEST_F(LargeIntValueTest, string_to_largeint) { ss << str; __int128 v; ss >> v; - ASSERT_TRUE(v == MIN_INT128); + EXPECT_TRUE(v == MIN_INT128); } } @@ -72,7 +72,7 @@ TEST_F(LargeIntValueTest, largeint_to_string) { __int128 v1 = std::numeric_limits::max(); std::stringstream ss; ss << v1; - ASSERT_EQ(ss.str(), "9223372036854775807"); + EXPECT_EQ(ss.str(), "9223372036854775807"); } { @@ -90,22 +90,12 @@ TEST_F(LargeIntValueTest, largeint_to_string) { } } -TEST_F(LargeIntValueTest, largeint_to_string_benchmark) { +TEST_F(LargeIntValueTest, DISABLED_largeint_to_string_benchmark) { for (int i = 0; i < 10000000; i++) { __int128 v2 = MAX_INT128; - EXPECT_EQ(LargeIntValue::to_string(v2), "170141183460469231731687303715884105727"); - LargeIntValue::to_string(v2); + EXPECT_EQ(LargeIntValue::to_string(v2), "170141183460469231731687303715884105727"); + LargeIntValue::to_string(v2); } } } // end namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/load_channel_mgr_test.cpp b/be/test/runtime/load_channel_mgr_test.cpp index 6e683ed17c..1d6d30ae5b 100644 --- a/be/test/runtime/load_channel_mgr_test.cpp +++ b/be/test/runtime/load_channel_mgr_test.cpp @@ -45,8 +45,7 @@ OLAPStatus close_status; int64_t wait_lock_time_ns; // mock -DeltaWriter::DeltaWriter(WriteRequest* req, StorageEngine* storage_engine) - : _req(*req) {} +DeltaWriter::DeltaWriter(WriteRequest* req, StorageEngine* storage_engine) : _req(*req) {} DeltaWriter::~DeltaWriter() {} @@ -83,7 +82,8 @@ OLAPStatus DeltaWriter::close() { return OLAP_SUCCESS; } -OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, bool is_broken) { +OLAPStatus DeltaWriter::close_wait(google::protobuf::RepeatedPtrField* tablet_vec, + bool is_broken) { return close_status; } @@ -119,7 +119,6 @@ public: } private: - size_t uncompressed_size = 0; size_t compressed_size = 0; }; @@ -140,10 +139,10 @@ TEST_F(LoadChannelMgrTest, check_builder) { ObjectPool obj_pool; DescriptorTbl::create(&obj_pool, table_builder.desc_tbl(), &desc_tbl); auto tuple = desc_tbl->get_tuple_descriptor(0); - ASSERT_EQ(32, tuple->byte_size()); - ASSERT_EQ(4, tuple->slots()[0]->tuple_offset()); - ASSERT_EQ(8, tuple->slots()[1]->tuple_offset()); - ASSERT_EQ(16, tuple->slots()[2]->tuple_offset()); + EXPECT_EQ(32, tuple->byte_size()); + EXPECT_EQ(4, tuple->slots()[0]->tuple_offset()); + EXPECT_EQ(8, tuple->slots()[1]->tuple_offset()); + EXPECT_EQ(16, tuple->slots()[2]->tuple_offset()); } TDescriptorTable create_descriptor_table() { @@ -208,7 +207,7 @@ TEST_F(LoadChannelMgrTest, normal) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -260,11 +259,11 @@ TEST_F(LoadChannelMgrTest, normal) { PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // check content - ASSERT_EQ(_k_tablet_recorder[20], 2); - ASSERT_EQ(_k_tablet_recorder[21], 1); + EXPECT_EQ(_k_tablet_recorder[20], 2); + EXPECT_EQ(_k_tablet_recorder[21], 1); } TEST_F(LoadChannelMgrTest, cancel) { @@ -296,7 +295,7 @@ TEST_F(LoadChannelMgrTest, cancel) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -306,7 +305,7 @@ TEST_F(LoadChannelMgrTest, cancel) { request.set_index_id(4); auto st = mgr.cancel(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } } @@ -340,7 +339,7 @@ TEST_F(LoadChannelMgrTest, open_failed) { open_status = OLAP_ERR_TABLE_NOT_FOUND; auto st = mgr.open(request); request.release_id(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } } @@ -374,7 +373,7 @@ TEST_F(LoadChannelMgrTest, add_failed) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -429,8 +428,8 @@ TEST_F(LoadChannelMgrTest, add_failed) { auto st = mgr.add_batch(request, &response); request.release_id(); // st is still ok. - ASSERT_TRUE(st.ok()); - ASSERT_EQ(2, response.tablet_errors().size()); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(2, response.tablet_errors().size()); } } @@ -463,7 +462,7 @@ TEST_F(LoadChannelMgrTest, close_failed) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -520,8 +519,8 @@ TEST_F(LoadChannelMgrTest, close_failed) { auto st = mgr.add_batch(request, &response); request.release_id(); // even if delta close failed, the return status is still ok, but tablet_vec is empty - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(response.tablet_vec().empty()); + EXPECT_TRUE(st.ok()); + EXPECT_TRUE(response.tablet_vec().empty()); } } @@ -554,7 +553,7 @@ TEST_F(LoadChannelMgrTest, unknown_tablet) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -606,7 +605,7 @@ TEST_F(LoadChannelMgrTest, unknown_tablet) { PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); request.release_id(); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } } @@ -639,7 +638,7 @@ TEST_F(LoadChannelMgrTest, duplicate_packet) { request.set_need_gen_rollup(false); auto st = mgr.open(request); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // add a batch @@ -690,11 +689,11 @@ TEST_F(LoadChannelMgrTest, duplicate_packet) { row_batch.serialize(request.mutable_row_batch(), &uncompressed_size, &compressed_size); PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); PTabletWriterAddBatchResult response2; st = mgr.add_batch(request, &response2); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // close { @@ -707,17 +706,11 @@ TEST_F(LoadChannelMgrTest, duplicate_packet) { PTabletWriterAddBatchResult response; auto st = mgr.add_batch(request, &response); request.release_id(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } // check content - ASSERT_EQ(_k_tablet_recorder[20], 2); - ASSERT_EQ(_k_tablet_recorder[21], 1); + EXPECT_EQ(_k_tablet_recorder[20], 2); + EXPECT_EQ(_k_tablet_recorder[21], 1); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/mem_limit_test.cpp b/be/test/runtime/mem_limit_test.cpp index 378b9c5d08..a5fe7bfaf8 100644 --- a/be/test/runtime/mem_limit_test.cpp +++ b/be/test/runtime/mem_limit_test.cpp @@ -142,15 +142,3 @@ TEST(MemTestTest, TrackerHierarchyTryConsume) { } } // end namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::MemInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/mem_pool_test.cpp b/be/test/runtime/mem_pool_test.cpp index 088a604802..4ec20cbd10 100644 --- a/be/test/runtime/mem_pool_test.cpp +++ b/be/test/runtime/mem_pool_test.cpp @@ -185,15 +185,3 @@ TEST(MemPoolTest, MaxAllocation) { p3.free_all(); } } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/memory/chunk_allocator_test.cpp b/be/test/runtime/memory/chunk_allocator_test.cpp index 78c623ef20..aaf3d91b13 100644 --- a/be/test/runtime/memory/chunk_allocator_test.cpp +++ b/be/test/runtime/memory/chunk_allocator_test.cpp @@ -31,17 +31,10 @@ TEST(ChunkAllocatorTest, Normal) { config::use_mmap_allocate_chunk = true; for (size_t size = 4096; size <= 1024 * 1024; size <<= 1) { Chunk chunk; - ASSERT_TRUE(ChunkAllocator::instance()->allocate(size, &chunk).ok()); - ASSERT_NE(nullptr, chunk.data); - ASSERT_EQ(size, chunk.size); + EXPECT_TRUE(ChunkAllocator::instance()->allocate(size, &chunk).ok()); + EXPECT_NE(nullptr, chunk.data); + EXPECT_EQ(size, chunk.size); ChunkAllocator::instance()->free(chunk); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - doris::ChunkAllocator::init_instance(1024 * 1024); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/memory/system_allocator_test.cpp b/be/test/runtime/memory/system_allocator_test.cpp index 0974bc1e73..3d7a471aa5 100644 --- a/be/test/runtime/memory/system_allocator_test.cpp +++ b/be/test/runtime/memory/system_allocator_test.cpp @@ -28,14 +28,14 @@ void test_normal() { config::use_mmap_allocate_chunk = use_mmap; { auto ptr = SystemAllocator::allocate(4096); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(0, (uint64_t)ptr % 4096); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(0, (uint64_t)ptr % 4096); SystemAllocator::free(ptr, 4096); } { auto ptr = SystemAllocator::allocate(100); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(0, (uint64_t)ptr % 4096); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(0, (uint64_t)ptr % 4096); SystemAllocator::free(ptr, 100); } } @@ -46,8 +46,3 @@ TEST(SystemAllocatorTest, TestNormal) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/memory_scratch_sink_test.cpp b/be/test/runtime/memory_scratch_sink_test.cpp index c39b099dee..450b21ee6d 100644 --- a/be/test/runtime/memory_scratch_sink_test.cpp +++ b/be/test/runtime/memory_scratch_sink_test.cpp @@ -71,16 +71,16 @@ public: config::periodic_counter_update_period_ms = 500; config::storage_root_path = "./data"; - ASSERT_EQ(system("mkdir -p ./test_run/output/"), 0); - ASSERT_EQ(system("pwd"), 0); - ASSERT_EQ(system("cp -r ./be/test/runtime/test_data/ ./test_run/."), 0); + EXPECT_EQ(system("mkdir -p ./test_run/output/"), 0); + EXPECT_EQ(system("pwd"), 0); + EXPECT_EQ(system("cp -r ./be/test/runtime/test_data/ ./test_run/."), 0); init(); } virtual void TearDown() { _obj_pool.clear(); - ASSERT_EQ(system("rm -rf ./test_run"), 0); + EXPECT_EQ(system("rm -rf ./test_run"), 0); } void init(); @@ -212,8 +212,8 @@ TEST_F(MemoryScratchSinkTest, work_flow_normal) { MemoryScratchSink sink(*_row_desc, _exprs, _tsink); TDataSink data_sink; data_sink.memory_scratch_sink = _tsink; - ASSERT_TRUE(sink.init(data_sink).ok()); - ASSERT_TRUE(sink.prepare(_state).ok()); + EXPECT_TRUE(sink.init(data_sink).ok()); + EXPECT_TRUE(sink.prepare(_state).ok()); std::vector file_paths; file_paths.push_back("./test_run/test_data/csv_data"); _tnode.csv_scan_node.__set_file_paths(file_paths); @@ -221,37 +221,26 @@ TEST_F(MemoryScratchSinkTest, work_flow_normal) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - ASSERT_EQ(6, num); - ASSERT_TRUE(sink.send(_state, &row_batch).ok()); - ASSERT_TRUE(sink.close(_state, Status::OK()).ok()); + EXPECT_EQ(6, num); + EXPECT_TRUE(sink.send(_state, &row_batch).ok()); + EXPECT_TRUE(sink.close(_state, Status::OK()).ok()); } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/minidump_test.cpp b/be/test/runtime/minidump_test.cpp index e46ca6a749..c37b8a3ea5 100644 --- a/be/test/runtime/minidump_test.cpp +++ b/be/test/runtime/minidump_test.cpp @@ -15,10 +15,10 @@ // specific language governing permissions and limitations // under the License. -#include - #include "runtime/minidump.h" +#include + #include "common/config.h" #include "env/env.h" #include "util/file_utils.h" @@ -71,11 +71,4 @@ TEST_F(MinidumpTest, testNormal) { EXPECT_EQ(5, files.size()); } - } // end namespace doris - -int main(int argc, char** argv) { - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/qsorter_test.cpp b/be/test/runtime/qsorter_test.cpp index 609ab56135..44074e5243 100644 --- a/be/test/runtime/qsorter_test.cpp +++ b/be/test/runtime/qsorter_test.cpp @@ -239,51 +239,41 @@ TEST_F(QSorterTest, normalCase) { QSorter sorter(*_row_desc, _order_expr); - ASSERT_TRUE(sorter.prepare(_state).ok()); - ASSERT_TRUE(sorter.add_batch(&batch).ok()); - ASSERT_TRUE(sorter.input_done().ok()); + EXPECT_TRUE(sorter.prepare(_state).ok()); + EXPECT_TRUE(sorter.add_batch(&batch).ok()); + EXPECT_TRUE(sorter.input_done().ok()); RowBatch result(*_row_desc, 1024); bool eos = false; - ASSERT_TRUE(sorter.get_next(&result, &eos).ok()); - ASSERT_TRUE(eos); - ASSERT_EQ(5, result.num_rows()); + EXPECT_TRUE(sorter.get_next(&result, &eos).ok()); + EXPECT_TRUE(eos); + EXPECT_EQ(5, result.num_rows()); // 0, 195 { - ASSERT_EQ(0, *(int*)_order_expr[0]->get_value(result.get_row(0))); - ASSERT_EQ(195, *(int*)_order_expr[1]->get_value(result.get_row(0))); + EXPECT_EQ(0, *(int*)_order_expr[0]->get_value(result.get_row(0))); + EXPECT_EQ(195, *(int*)_order_expr[1]->get_value(result.get_row(0))); } // 1, 10 { - ASSERT_EQ(1, *(int*)_order_expr[0]->get_value(result.get_row(1))); - ASSERT_EQ(10, *(int*)_order_expr[1]->get_value(result.get_row(1))); + EXPECT_EQ(1, *(int*)_order_expr[0]->get_value(result.get_row(1))); + EXPECT_EQ(10, *(int*)_order_expr[1]->get_value(result.get_row(1))); } // 5, 5 { - ASSERT_EQ(5, *(int*)_order_expr[0]->get_value(result.get_row(2))); - ASSERT_EQ(5, *(int*)_order_expr[1]->get_value(result.get_row(2))); + EXPECT_EQ(5, *(int*)_order_expr[0]->get_value(result.get_row(2))); + EXPECT_EQ(5, *(int*)_order_expr[1]->get_value(result.get_row(2))); } // 5, 100 { - ASSERT_EQ(5, *(int*)_order_expr[0]->get_value(result.get_row(3))); - ASSERT_EQ(100, *(int*)_order_expr[1]->get_value(result.get_row(3))); + EXPECT_EQ(5, *(int*)_order_expr[0]->get_value(result.get_row(3))); + EXPECT_EQ(100, *(int*)_order_expr[1]->get_value(result.get_row(3))); } // 10000, 5 { - ASSERT_EQ(10000, *(int*)_order_expr[0]->get_value(result.get_row(4))); - ASSERT_EQ(5, *(int*)_order_expr[1]->get_value(result.get_row(4))); + EXPECT_EQ(10000, *(int*)_order_expr[0]->get_value(result.get_row(4))); + EXPECT_EQ(5, *(int*)_order_expr[1]->get_value(result.get_row(4))); } } } // namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/raw_value_test.cpp b/be/test/runtime/raw_value_test.cpp index 2ca7749e3f..f33061dc90 100644 --- a/be/test/runtime/raw_value_test.cpp +++ b/be/test/runtime/raw_value_test.cpp @@ -43,15 +43,3 @@ TEST_F(RawValueTest, Compare) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/result_buffer_mgr_test.cpp b/be/test/runtime/result_buffer_mgr_test.cpp index 574dcc9088..492efe0f4b 100644 --- a/be/test/runtime/result_buffer_mgr_test.cpp +++ b/be/test/runtime/result_buffer_mgr_test.cpp @@ -43,7 +43,7 @@ TEST_F(ResultBufferMgrTest, create_normal) { query_id.hi = 100; std::shared_ptr control_block1; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); } TEST_F(ResultBufferMgrTest, create_same_buffer) { @@ -53,11 +53,11 @@ TEST_F(ResultBufferMgrTest, create_same_buffer) { query_id.hi = 100; std::shared_ptr control_block1; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); std::shared_ptr control_block2; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block2).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block2).ok()); - ASSERT_EQ(control_block1.get(), control_block1.get()); + EXPECT_EQ(control_block1.get(), control_block1.get()); } TEST_F(ResultBufferMgrTest, fetch_data_normal) { @@ -67,15 +67,15 @@ TEST_F(ResultBufferMgrTest, fetch_data_normal) { query_id.hi = 100; std::shared_ptr control_block1; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); TFetchDataResult* result = new TFetchDataResult(); result->result_batch.rows.push_back("hello test"); control_block1->add_batch(result); TFetchDataResult get_result; - ASSERT_TRUE(buffer_mgr.fetch_data(query_id, &get_result).ok()); - ASSERT_EQ(1U, get_result.result_batch.rows.size()); - ASSERT_STREQ("hello test", get_result.result_batch.rows[0].c_str()); + EXPECT_TRUE(buffer_mgr.fetch_data(query_id, &get_result).ok()); + EXPECT_EQ(1U, get_result.result_batch.rows.size()); + EXPECT_STREQ("hello test", get_result.result_batch.rows[0].c_str()); } TEST_F(ResultBufferMgrTest, fetch_data_no_block) { @@ -85,12 +85,12 @@ TEST_F(ResultBufferMgrTest, fetch_data_no_block) { query_id.hi = 100; std::shared_ptr control_block1; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); TFetchDataResult* result = new TFetchDataResult(); query_id.lo = 11; query_id.hi = 100; - ASSERT_FALSE(buffer_mgr.fetch_data(query_id, result).ok()); + EXPECT_FALSE(buffer_mgr.fetch_data(query_id, result).ok()); delete result; } @@ -101,9 +101,9 @@ TEST_F(ResultBufferMgrTest, normal_cancel) { query_id.hi = 100; std::shared_ptr control_block1; - ASSERT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); + EXPECT_TRUE(buffer_mgr.create_sender(query_id, 1024, &control_block1).ok()); - ASSERT_TRUE(buffer_mgr.cancel(query_id).ok()); + EXPECT_TRUE(buffer_mgr.cancel(query_id).ok()); } TEST_F(ResultBufferMgrTest, cancel_no_block) { @@ -112,18 +112,6 @@ TEST_F(ResultBufferMgrTest, cancel_no_block) { query_id.lo = 10; query_id.hi = 100; - ASSERT_TRUE(buffer_mgr.cancel(query_id).ok()); + EXPECT_TRUE(buffer_mgr.cancel(query_id).ok()); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - // doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} -/* vim: set ts=4 sw=4 sts=4 tw=100 */ diff --git a/be/test/runtime/result_queue_mgr_test.cpp b/be/test/runtime/result_queue_mgr_test.cpp index a40e2faddd..3403df0b8e 100644 --- a/be/test/runtime/result_queue_mgr_test.cpp +++ b/be/test/runtime/result_queue_mgr_test.cpp @@ -22,11 +22,11 @@ #include #include #include -#include #include #include "gen_cpp/DorisExternalService_types.h" +#include "testutil/test_util.h" #include "util/blocking_queue.hpp" namespace doris { @@ -40,7 +40,7 @@ TEST_F(ResultQueueMgrTest, create_normal) { query_id.hi = 100; ResultQueueMgr queue_mgr; queue_mgr.create_queue(query_id, &block_queue_t); - ASSERT_TRUE(block_queue_t != nullptr); + EXPECT_TRUE(block_queue_t != nullptr); } TEST_F(ResultQueueMgrTest, create_same_queue) { @@ -51,13 +51,13 @@ TEST_F(ResultQueueMgrTest, create_same_queue) { BlockQueueSharedPtr block_queue_t_1; queue_mgr.create_queue(query_id, &block_queue_t_1); - ASSERT_TRUE(block_queue_t_1 != nullptr); + EXPECT_TRUE(block_queue_t_1 != nullptr); BlockQueueSharedPtr block_queue_t_2; queue_mgr.create_queue(query_id, &block_queue_t_2); - ASSERT_TRUE(block_queue_t_2 != nullptr); + EXPECT_TRUE(block_queue_t_2 != nullptr); - ASSERT_EQ(block_queue_t_1.get(), block_queue_t_2.get()); + EXPECT_EQ(block_queue_t_1.get(), block_queue_t_2.get()); } TEST_F(ResultQueueMgrTest, fetch_result_normal) { @@ -68,7 +68,7 @@ TEST_F(ResultQueueMgrTest, fetch_result_normal) { BlockQueueSharedPtr block_queue_t; queue_mgr.create_queue(query_id, &block_queue_t); - ASSERT_TRUE(block_queue_t != nullptr); + EXPECT_TRUE(block_queue_t != nullptr); std::shared_ptr field = arrow::field("k1", arrow::int32(), true); std::vector> fields; @@ -101,10 +101,10 @@ TEST_F(ResultQueueMgrTest, fetch_result_normal) { std::shared_ptr result; bool eos; - ASSERT_TRUE(queue_mgr.fetch_result(query_id, &result, &eos).ok()); - ASSERT_FALSE(eos); - ASSERT_EQ(1, result->num_rows()); - ASSERT_EQ(1, result->num_columns()); + EXPECT_TRUE(queue_mgr.fetch_result(query_id, &result, &eos).ok()); + EXPECT_FALSE(eos); + EXPECT_EQ(1, result->num_rows()); + EXPECT_EQ(1, result->num_columns()); } TEST_F(ResultQueueMgrTest, fetch_result_end) { @@ -115,14 +115,14 @@ TEST_F(ResultQueueMgrTest, fetch_result_end) { BlockQueueSharedPtr block_queue_t; queue_mgr.create_queue(query_id, &block_queue_t); - ASSERT_TRUE(block_queue_t != nullptr); + EXPECT_TRUE(block_queue_t != nullptr); block_queue_t->blocking_put(nullptr); std::shared_ptr result; bool eos; - ASSERT_TRUE(queue_mgr.fetch_result(query_id, &result, &eos).ok()); - ASSERT_TRUE(eos); - ASSERT_TRUE(result == nullptr); + EXPECT_TRUE(queue_mgr.fetch_result(query_id, &result, &eos).ok()); + EXPECT_TRUE(eos); + EXPECT_TRUE(result == nullptr); } TEST_F(ResultQueueMgrTest, normal_cancel) { @@ -132,8 +132,8 @@ TEST_F(ResultQueueMgrTest, normal_cancel) { ResultQueueMgr queue_mgr; BlockQueueSharedPtr block_queue_t; queue_mgr.create_queue(query_id, &block_queue_t); - ASSERT_TRUE(block_queue_t != nullptr); - ASSERT_TRUE(queue_mgr.cancel(query_id).ok()); + EXPECT_TRUE(block_queue_t != nullptr); + EXPECT_TRUE(queue_mgr.cancel(query_id).ok()); } TEST_F(ResultQueueMgrTest, cancel_no_block) { @@ -143,15 +143,7 @@ TEST_F(ResultQueueMgrTest, cancel_no_block) { ResultQueueMgr queue_mgr; BlockQueueSharedPtr block_queue_t; queue_mgr.create_queue(query_id, &block_queue_t); - ASSERT_TRUE(block_queue_t != nullptr); - ASSERT_TRUE(queue_mgr.cancel(query_id).ok()); + EXPECT_TRUE(block_queue_t != nullptr); + EXPECT_TRUE(queue_mgr.cancel(query_id).ok()); } } // namespace doris - -int main(int argc, char** argv) { - doris::InitConfig(); - - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/result_sink_test.cpp b/be/test/runtime/result_sink_test.cpp index f2542d8e25..fa6f3a5686 100644 --- a/be/test/runtime/result_sink_test.cpp +++ b/be/test/runtime/result_sink_test.cpp @@ -81,26 +81,14 @@ private: TEST_F(ResultSinkTest, init_normal) { ResultSink sink(_row_desc, _exprs, _tsink, 1024); - ASSERT_TRUE(sink.init(_runtime_state).ok()); + EXPECT_TRUE(sink.init(_runtime_state).ok()); RowBatch row_batch(_row_desc, 1024); row_batch.add_row(); row_batch.commit_last_row(); - ASSERT_TRUE(sink.send(_runtime_state, &row_batch).ok()); - ASSERT_TRUE(sink.close(_runtime_state, Status::OK()).ok()); + EXPECT_TRUE(sink.send(_runtime_state, &row_batch).ok()); + EXPECT_TRUE(sink.close(_runtime_state, Status::OK()).ok()); } } // namespace doris -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} - /* vim: set ts=4 sw=4 sts=4 tw=100 */ diff --git a/be/test/runtime/routine_load_task_executor_test.cpp b/be/test/runtime/routine_load_task_executor_test.cpp index 384a8593e1..01fc299c67 100644 --- a/be/test/runtime/routine_load_task_executor_test.cpp +++ b/be/test/runtime/routine_load_task_executor_test.cpp @@ -98,31 +98,25 @@ TEST_F(RoutineLoadTaskExecutorTest, exec_task) { // submit task Status st; st = executor.submit_task(task); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); usleep(200); k_info.brokers = "127.0.0.1:9092"; task.__set_kafka_load_info(k_info); st = executor.submit_task(task); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); usleep(200); k_info.brokers = "192.0.0.2:9092"; task.__set_kafka_load_info(k_info); st = executor.submit_task(task); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); usleep(200); k_info.brokers = "192.0.0.2:9092"; task.__set_kafka_load_info(k_info); st = executor.submit_task(task); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } } // namespace doris - -int main(int argc, char* argv[]) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/small_file_mgr_test.cpp b/be/test/runtime/small_file_mgr_test.cpp index f47a88a6a5..f5f8a7be49 100644 --- a/be/test/runtime/small_file_mgr_test.cpp +++ b/be/test/runtime/small_file_mgr_test.cpp @@ -29,116 +29,3 @@ #include "http/http_handler.h" #include "http/http_request.h" #include "runtime/exec_env.h" - -int main(int argc, char* argv[]); - -namespace doris { - -std::string g_download_path = "./be/test/runtime/test_data/small_file/downloaded/"; -std::string g_src_path = "./be/test/runtime/test_data/small_file/source/"; -std::string g_md5_12345 = "5dd39cab1c53c2c77cd352983f9641e1"; -std::string g_md5_67890 = "a06e26ae5511b0acea8273cf180ca7bf"; -int64_t g_file_12345 = 12345L; // ready to be downloaded file -int64_t g_file_67890 = 67890L; // already exist file -std::string src_file = "small_file.txt"; - -class SmallFileMgrTestHandler : public HttpHandler { -public: - void handle(HttpRequest* req) override { - auto it = req->query_params().find("file_id"); - if (it == req->query_params().end()) { - HttpChannel::send_error(req, INTERNAL_SERVER_ERROR); - return; - } - if (std::stol(it->second) != g_file_12345) { - HttpChannel::send_error(req, INTERNAL_SERVER_ERROR); - return; - } - - std::string file_path = g_src_path + "/small_file.txt"; - FILE* fp = fopen(file_path.c_str(), "r"); - if (fp == nullptr) { - HttpChannel::send_error(req, INTERNAL_SERVER_ERROR); - return; - } - std::string response; - char buf[1024]; - while (true) { - auto size = fread(buf, 1, 1024, fp); - response.append(buf, size); - if (size < 1024) { - break; - } - } - HttpChannel::send_reply(req, response); - fclose(fp); - } -}; - -static SmallFileMgrTestHandler s_test_handler = SmallFileMgrTestHandler(); -static EvHttpServer* s_server = nullptr; -static int real_port = 0; - -class SmallFileMgrTest : public testing::Test { -public: - SmallFileMgrTest() {} - virtual ~SmallFileMgrTest() {} - - static void SetUpTestCase() { - s_server = new EvHttpServer(0); - s_server->register_handler(GET, "/api/get_small_file", &s_test_handler); - s_server->start(); - real_port = s_server->get_real_port(); - ASSERT_NE(0, real_port); - } - - static void TearDownTestCase() { - delete s_server; - std::stringstream ss; - ss << g_download_path << "/" << g_file_12345 << "." << g_md5_12345; - remove(ss.str().c_str()); - } - - void SetUp() override {} -}; - -TEST_F(SmallFileMgrTest, test_get_file) { - TNetworkAddress addr; - addr.__set_hostname("http://127.0.0.1"); - TMasterInfo info; - info.__set_network_address(addr); - info.__set_http_port(real_port); - ExecEnv* env = ExecEnv::GetInstance(); - env->_master_info = &info; - SmallFileMgr mgr(env, g_download_path); - Status st = mgr.init(); - ASSERT_TRUE(st.ok()); - - // get already exist file - std::string file_path; - st = mgr.get_file(g_file_67890, g_md5_67890, &file_path); - ASSERT_TRUE(st.ok()) << st.to_string(); - std::stringstream expected; - expected << g_download_path << "/" << g_file_67890 << "." << g_md5_67890; - ASSERT_EQ(expected.str(), file_path); - - // get ready to be downloaded file - std::string file_path_2; - st = mgr.get_file(g_file_12345, g_md5_12345, &file_path_2); - ASSERT_TRUE(st.ok()) << st.to_string(); - std::stringstream expected2; - expected2 << g_download_path << "/" << g_file_12345 << "." << g_md5_12345; - ASSERT_EQ(expected2.str(), file_path_2); - - // get wrong file - std::string file_path_3; - st = mgr.get_file(13579, "xxxx", &file_path_3); - ASSERT_TRUE(!st.ok()); -} - -} // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/snapshot_loader_test.cpp b/be/test/runtime/snapshot_loader_test.cpp index 1342a0045b..5e0349efe6 100644 --- a/be/test/runtime/snapshot_loader_test.cpp +++ b/be/test/runtime/snapshot_loader_test.cpp @@ -40,73 +40,62 @@ private: TEST_F(SnapshotLoaderTest, NormalCase) { SnapshotLoader loader(_exec_env, 1L, 2L); - ASSERT_TRUE(loader._end_with("abt.dat", ".dat")); - ASSERT_FALSE(loader._end_with("abt.dat", ".da")); + EXPECT_TRUE(loader._end_with("abt.dat", ".dat")); + EXPECT_FALSE(loader._end_with("abt.dat", ".da")); int64_t tablet_id = 0; int32_t schema_hash = 0; Status st = loader._get_tablet_id_and_schema_hash_from_file_path("/path/to/1234/5678", &tablet_id, &schema_hash); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(1234, tablet_id); - ASSERT_EQ(5678, schema_hash); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(1234, tablet_id); + EXPECT_EQ(5678, schema_hash); st = loader._get_tablet_id_and_schema_hash_from_file_path("/path/to/1234/5678/", &tablet_id, &schema_hash); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); std::filesystem::remove_all("./ss_test/"); std::map src_to_dest; src_to_dest["./ss_test/"] = "./ss_test"; st = loader._check_local_snapshot_paths(src_to_dest, true); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); st = loader._check_local_snapshot_paths(src_to_dest, false); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); std::filesystem::create_directory("./ss_test/"); st = loader._check_local_snapshot_paths(src_to_dest, true); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = loader._check_local_snapshot_paths(src_to_dest, false); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::filesystem::remove_all("./ss_test/"); std::filesystem::create_directory("./ss_test/"); std::vector files; st = loader._get_existing_files_from_local("./ss_test/", &files); - ASSERT_EQ(0, files.size()); + EXPECT_EQ(0, files.size()); std::filesystem::remove_all("./ss_test/"); std::string new_name; st = loader._replace_tablet_id("12345.hdr", 5678, &new_name); - ASSERT_TRUE(st.ok()); - ASSERT_EQ("5678.hdr", new_name); + EXPECT_TRUE(st.ok()); + EXPECT_EQ("5678.hdr", new_name); st = loader._replace_tablet_id("1234_2_5_12345_1.dat", 5678, &new_name); - ASSERT_TRUE(st.ok()); - ASSERT_EQ("1234_2_5_12345_1.dat", new_name); + EXPECT_TRUE(st.ok()); + EXPECT_EQ("1234_2_5_12345_1.dat", new_name); st = loader._replace_tablet_id("1234_2_5_12345_1.idx", 5678, &new_name); - ASSERT_TRUE(st.ok()); - ASSERT_EQ("1234_2_5_12345_1.idx", new_name); + EXPECT_TRUE(st.ok()); + EXPECT_EQ("1234_2_5_12345_1.idx", new_name); st = loader._replace_tablet_id("1234_2_5_12345_1.xxx", 5678, &new_name); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); st = loader._get_tablet_id_from_remote_path("/__tbl_10004/__part_10003/__idx_10004/__10005", &tablet_id); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(10005, tablet_id); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(10005, tablet_id); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/sorter_test.cpp b/be/test/runtime/sorter_test.cpp index 7fda5e13d1..fe709ca935 100644 --- a/be/test/runtime/sorter_test.cpp +++ b/be/test/runtime/sorter_test.cpp @@ -177,13 +177,13 @@ TEST_F(SorterTest, init_sort_exec_exprs) { { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, nullptr, get_object_pool()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } // full sort_tuple_slot_expr { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, &_sort_tuple_slot_expr, get_object_pool()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } } @@ -191,17 +191,17 @@ TEST_F(SorterTest, prepare_sort_exec_exprs) { { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, nullptr, get_object_pool()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = exec_exprs.prepare(_runtime_state, *_child_row_desc, *_output_row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, &_sort_tuple_slot_expr, get_object_pool()); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = exec_exprs.prepare(_runtime_state, *_child_row_desc, *_output_row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } } @@ -225,9 +225,9 @@ RowBatch* SorterTest::CreateRowBatch(int num_rows) { TEST_F(SorterTest, sorter_run_asc) { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, &_sort_tuple_slot_expr, _object_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = exec_exprs.prepare(_runtime_state, *_child_row_desc, *_output_row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); TupleRowComparator less_than(exec_exprs.lhs_ordering_expr_ctxs(), exec_exprs.rhs_ordering_expr_ctxs(), _is_asc_order, _nulls_first); @@ -237,30 +237,26 @@ TEST_F(SorterTest, sorter_run_asc) { int num_rows = 5; RowBatch* batch = CreateRowBatch(num_rows); status = sorter->add_batch(batch); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = sorter->add_batch(batch); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); sorter->input_done(); RowBatch output_batch(*_child_row_desc, 2 * num_rows); bool eos; status = sorter->get_next(&output_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); - //for (int i = 0; i < num_rows; i ++) { - // TupleRow* row = output_batch.GetRow(i); - // std::cout << "output row: " << PrintRow(row, *_child_row_desc) << std::endl; - //} - ASSERT_EQ("[(0)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); - ASSERT_EQ("[(0)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); - ASSERT_EQ("[(1)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); - ASSERT_EQ("[(1)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); - ASSERT_EQ("[(2)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); - ASSERT_EQ("[(2)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(6), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(7), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(8), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(9), *_child_row_desc)); + EXPECT_EQ("[(0)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); + EXPECT_EQ("[(0)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); + EXPECT_EQ("[(1)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); + EXPECT_EQ("[(1)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); + EXPECT_EQ("[(2)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); + EXPECT_EQ("[(2)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(6), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(7), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(8), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(9), *_child_row_desc)); delete sorter; } @@ -269,9 +265,9 @@ TEST_F(SorterTest, sorter_run_asc) { TEST_F(SorterTest, sorter_run_desc_with_quick_sort) { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, &_sort_tuple_slot_expr, _object_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = exec_exprs.prepare(_runtime_state, *_child_row_desc, *_output_row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); _is_asc_order.clear(); _is_asc_order.push_back(false); @@ -284,7 +280,7 @@ TEST_F(SorterTest, sorter_run_desc_with_quick_sort) { RowBatch* batch = CreateRowBatch(num_rows); for (int i = 0; i < 5; i++) { status = sorter->add_batch(batch); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } sorter->input_done(); @@ -292,14 +288,14 @@ TEST_F(SorterTest, sorter_run_desc_with_quick_sort) { RowBatch output_batch(*_child_row_desc, 2 * num_rows); bool eos; status = sorter->get_next(&output_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); delete sorter; } @@ -307,9 +303,9 @@ TEST_F(SorterTest, sorter_run_desc_with_quick_sort) { TEST_F(SorterTest, sorter_run_desc) { SortExecExprs exec_exprs; Status status = exec_exprs.init(_ordering_exprs, &_sort_tuple_slot_expr, _object_pool); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = exec_exprs.prepare(_runtime_state, *_child_row_desc, *_output_row_desc); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); _is_asc_order.clear(); _is_asc_order.push_back(false); @@ -321,39 +317,29 @@ TEST_F(SorterTest, sorter_run_desc) { int num_rows = 5; RowBatch* batch = CreateRowBatch(num_rows); status = sorter->add_batch(batch); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = sorter->add_batch(batch); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); sorter->input_done(); RowBatch output_batch(*_child_row_desc, 2 * num_rows); bool eos; status = sorter->get_next(&output_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); - // for (int i = 0; i < num_rows; i ++) { - // TupleRow* row = output_batch.GetRow(i); - // std::cout << "output row: " << PrintRow(row, *_child_row_desc) << std::endl; - //} - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); - ASSERT_EQ("[(4)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); - ASSERT_EQ("[(3)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); - ASSERT_EQ("[(2)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); - ASSERT_EQ("[(2)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); - ASSERT_EQ("[(1)]", PrintRow(output_batch.GetRow(6), *_child_row_desc)); - ASSERT_EQ("[(1)]", PrintRow(output_batch.GetRow(7), *_child_row_desc)); - ASSERT_EQ("[(0)]", PrintRow(output_batch.GetRow(8), *_child_row_desc)); - ASSERT_EQ("[(0)]", PrintRow(output_batch.GetRow(9), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(0), *_child_row_desc)); + EXPECT_EQ("[(4)]", PrintRow(output_batch.GetRow(1), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(2), *_child_row_desc)); + EXPECT_EQ("[(3)]", PrintRow(output_batch.GetRow(3), *_child_row_desc)); + EXPECT_EQ("[(2)]", PrintRow(output_batch.GetRow(4), *_child_row_desc)); + EXPECT_EQ("[(2)]", PrintRow(output_batch.GetRow(5), *_child_row_desc)); + EXPECT_EQ("[(1)]", PrintRow(output_batch.GetRow(6), *_child_row_desc)); + EXPECT_EQ("[(1)]", PrintRow(output_batch.GetRow(7), *_child_row_desc)); + EXPECT_EQ("[(0)]", PrintRow(output_batch.GetRow(8), *_child_row_desc)); + EXPECT_EQ("[(0)]", PrintRow(output_batch.GetRow(9), *_child_row_desc)); delete sorter; } } // namespace doris -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - impala::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} - -/* vim: set ts=4 sw=4 sts=4 tw=100 noet: */ +\n \ No newline at end of file diff --git a/be/test/runtime/stream_load_pipe_test.cpp b/be/test/runtime/stream_load_pipe_test.cpp index 48fc58003d..2f50e85517 100644 --- a/be/test/runtime/stream_load_pipe_test.cpp +++ b/be/test/runtime/stream_load_pipe_test.cpp @@ -56,16 +56,16 @@ TEST_F(StreamLoadPipeTest, append_buffer) { int64_t read_bytes = 0; bool eof = false; auto st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(128, read_bytes); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(128, read_bytes); + EXPECT_FALSE(eof); for (int i = 0; i < 128; ++i) { - ASSERT_EQ('0' + (i % 10), buf[i]); + EXPECT_EQ('0' + (i % 10), buf[i]); } st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, read_bytes); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, read_bytes); + EXPECT_TRUE(eof); t1.join(); } @@ -87,16 +87,16 @@ TEST_F(StreamLoadPipeTest, append_bytes) { int64_t read_bytes = 0; bool eof = false; auto st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(128, read_bytes); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(128, read_bytes); + EXPECT_FALSE(eof); for (int i = 0; i < 128; ++i) { - ASSERT_EQ('0' + (i % 10), buf[i]); + EXPECT_EQ('0' + (i % 10), buf[i]); } st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, read_bytes); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, read_bytes); + EXPECT_TRUE(eof); t1.join(); } @@ -118,25 +118,25 @@ TEST_F(StreamLoadPipeTest, append_bytes2) { int64_t read_bytes = 0; bool eof = false; auto st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(62, read_bytes); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(62, read_bytes); + EXPECT_FALSE(eof); for (int i = 0; i < 62; ++i) { - ASSERT_EQ('0' + (i % 10), buf[i]); + EXPECT_EQ('0' + (i % 10), buf[i]); } for (int i = 62; i < 128; ++i) { char ch; buf_len = 1; auto st = pipe.read((uint8_t*)&ch, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(1, read_bytes); - ASSERT_FALSE(eof); - ASSERT_EQ('0' + (i % 10), ch); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(1, read_bytes); + EXPECT_FALSE(eof); + EXPECT_EQ('0' + (i % 10), ch); } st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, read_bytes); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, read_bytes); + EXPECT_TRUE(eof); t1.join(); } @@ -187,16 +187,16 @@ TEST_F(StreamLoadPipeTest, append_mix) { int64_t read_bytes = 0; bool eof = false; auto st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(128, read_bytes); - ASSERT_FALSE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(128, read_bytes); + EXPECT_FALSE(eof); for (int i = 0; i < 128; ++i) { - ASSERT_EQ('0' + (i % 10), buf[i]); + EXPECT_EQ('0' + (i % 10), buf[i]); } st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(0, read_bytes); - ASSERT_TRUE(eof); + EXPECT_TRUE(st.ok()); + EXPECT_EQ(0, read_bytes); + EXPECT_TRUE(eof); t1.join(); } @@ -220,7 +220,7 @@ TEST_F(StreamLoadPipeTest, cancel) { int64_t read_bytes = 0; bool eof = false; auto st = pipe.read((uint8_t*)buf, buf_len, &read_bytes, &eof); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); t1.join(); } @@ -248,7 +248,7 @@ TEST_F(StreamLoadPipeTest, close) { byte_buf->put_bytes(buf, 64); byte_buf->flip(); auto st = pipe.append(byte_buf); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } }; std::thread t1(appender); @@ -261,8 +261,3 @@ TEST_F(StreamLoadPipeTest, close) { } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/string_buffer_test.cpp b/be/test/runtime/string_buffer_test.cpp index 655784122c..376d6fb7be 100644 --- a/be/test/runtime/string_buffer_test.cpp +++ b/be/test/runtime/string_buffer_test.cpp @@ -74,16 +74,3 @@ TEST(StringBufferTest, Basic) { } } // namespace doris - -int main(int argc, char** argv) { -#if 0 - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); -#endif - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/string_value_test.cpp b/be/test/runtime/string_value_test.cpp index 849b73f5a9..5e063929b6 100644 --- a/be/test/runtime/string_value_test.cpp +++ b/be/test/runtime/string_value_test.cpp @@ -83,18 +83,3 @@ TEST(StringValueTest, TestCompare) { } } // namespace doris - -int main(int argc, char** argv) { -#if 0 - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - doris::CpuInfo::Init(); -#endif - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/thread_resource_mgr_test.cpp b/be/test/runtime/thread_resource_mgr_test.cpp index ea006b839d..21951a8105 100644 --- a/be/test/runtime/thread_resource_mgr_test.cpp +++ b/be/test/runtime/thread_resource_mgr_test.cpp @@ -64,15 +64,3 @@ TEST(ThreadResourceMgr, BasicTest) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/tmp_file_mgr_test.cpp b/be/test/runtime/tmp_file_mgr_test.cpp index cc83240aea..3338819dcb 100644 --- a/be/test/runtime/tmp_file_mgr_test.cpp +++ b/be/test/runtime/tmp_file_mgr_test.cpp @@ -215,18 +215,3 @@ TEST_F(TmpFileMgrTest, TestAllocateFails) { } } // end namespace doris - -int main(int argc, char** argv) { - // std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::config::query_scratch_dirs = "/tmp"; - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - - doris::DiskInfo::init(); - - return RUN_ALL_TESTS(); -} diff --git a/be/test/runtime/user_function_cache_test.cpp b/be/test/runtime/user_function_cache_test.cpp index 96767e5f0f..0142f0ef53 100644 --- a/be/test/runtime/user_function_cache_test.cpp +++ b/be/test/runtime/user_function_cache_test.cpp @@ -29,195 +29,3 @@ #include "http/http_request.h" #include "util/file_utils.h" #include "util/md5.h" - -int main(int argc, char* argv[]); - -namespace doris { - -bool k_is_downloaded = false; -class UserFunctionTestHandler : public HttpHandler { -public: - void handle(HttpRequest* req) override { - auto& file_name = req->param("FILE"); - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/lib"; - auto lib_file = lib_dir + "/" + file_name; - FILE* fp = fopen(lib_file.c_str(), "r"); - if (fp == nullptr) { - HttpChannel::send_error(req, INTERNAL_SERVER_ERROR); - return; - } - std::string response; - char buf[1024]; - while (true) { - auto size = fread(buf, 1, 1024, fp); - response.append(buf, size); - if (size < 1024) { - break; - } - } - HttpChannel::send_reply(req, response); - k_is_downloaded = true; - fclose(fp); - } -}; - -static UserFunctionTestHandler s_test_handler = UserFunctionTestHandler(); -static EvHttpServer* s_server = nullptr; -static int real_port = 0; -static std::string hostname = ""; - -std::string my_add_md5sum; - -static std::string compute_md5(const std::string& file) { - FILE* fp = fopen(file.c_str(), "r"); - Md5Digest md5; - char buf[1024]; - while (true) { - auto size = fread(buf, 1, 1024, fp); - md5.update(buf, size); - if (size < 1024) { - break; - } - } - fclose(fp); - md5.digest(); - return md5.hex(); -} -class UserFunctionCacheTest : public testing::Test { -public: - UserFunctionCacheTest() {} - virtual ~UserFunctionCacheTest() {} - static void SetUpTestCase() { - s_server = new EvHttpServer(0); - s_server->register_handler(GET, "/{FILE}", &s_test_handler); - s_server->start(); - real_port = s_server->get_real_port(); - ASSERT_NE(0, real_port); - hostname = "http://127.0.0.1:" + std::to_string(real_port); - - // compile code to so - ASSERT_EQ(system("g++ -shared -fPIC " - "./be/test/runtime/test_data/user_function_cache/lib/my_add.cc -o " - "./be/test/runtime/test_data/user_function_cache/lib/my_add.so"), - 0); - - my_add_md5sum = - compute_md5("./be/test/runtime/test_data/user_function_cache/lib/my_add.so"); - } - static void TearDownTestCase() { - delete s_server; - ASSERT_EQ(system("rm -rf ./be/test/runtime/test_data/user_function_cache/lib/my_add.so"), - 0); - } - void SetUp() override { k_is_downloaded = false; } -}; - -TEST_F(UserFunctionCacheTest, process_symbol) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/normal"; - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - st = cache.get_function_ptr(0, "main", "", "", &fn_ptr, &entry); - ASSERT_TRUE(st.ok()); - ASSERT_EQ(&main, fn_ptr); - ASSERT_EQ(nullptr, entry); - cache.release_entry(entry); -} - -TEST_F(UserFunctionCacheTest, download_normal) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/download"; - FileUtils::remove_all(lib_dir); - - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - // get my_add - st = cache.get_function_ptr(1, "_Z6my_addv", hostname + "/my_add.so", my_add_md5sum, &fn_ptr, - &entry); - ASSERT_TRUE(st.ok()); - ASSERT_TRUE(k_is_downloaded); - ASSERT_NE(nullptr, fn_ptr); - ASSERT_NE(nullptr, entry); - - // get my_del - st = cache.get_function_ptr(1, "_Z6my_delv", hostname + "/my_add.so", my_add_md5sum, &fn_ptr, - &entry); - ASSERT_TRUE(st.ok()); - ASSERT_NE(nullptr, fn_ptr); - ASSERT_NE(nullptr, entry); - - // get my_mul - st = cache.get_function_ptr(1, "_Z6my_mulv", hostname + "/my_add.so", my_add_md5sum, &fn_ptr, - &entry); - ASSERT_FALSE(st.ok()); - - cache.release_entry(entry); -} - -TEST_F(UserFunctionCacheTest, load_normal) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/download"; - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - st = cache.get_function_ptr(1, "_Z6my_addv", hostname + "/my_add.so", my_add_md5sum, &fn_ptr, - &entry); - ASSERT_TRUE(st.ok()); - ASSERT_FALSE(k_is_downloaded); - ASSERT_NE(nullptr, fn_ptr); - ASSERT_NE(nullptr, entry); - cache.release_entry(entry); -} - -TEST_F(UserFunctionCacheTest, download_fail) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/download"; - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - st = cache.get_function_ptr(2, "_Z6my_delv", hostname + "/my_del.so", my_add_md5sum, &fn_ptr, - &entry); - ASSERT_FALSE(st.ok()); -} - -TEST_F(UserFunctionCacheTest, md5_fail) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/download"; - FileUtils::remove_all(lib_dir); - - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - st = cache.get_function_ptr(1, "_Z6my_addv", hostname + "/my_add.so", "1234", &fn_ptr, &entry); - ASSERT_FALSE(st.ok()); -} - -TEST_F(UserFunctionCacheTest, bad_so) { - UserFunctionCache cache; - std::string lib_dir = "./be/test/runtime/test_data/user_function_cache/bad"; - FileUtils::create_dir(lib_dir + "/2"); - auto so_file = lib_dir + "/2/2.abc.so"; - FILE* fp = fopen(so_file.c_str(), "w"); - fwrite(&fp, sizeof(FILE*), 1, fp); - fclose(fp); - auto st = cache.init(lib_dir); - ASSERT_TRUE(st.ok()); - void* fn_ptr = nullptr; - UserFunctionCacheEntry* entry = nullptr; - st = cache.get_function_ptr(2, "_Z6my_addv", hostname + "/my_add.so", "abc", &fn_ptr, &entry); - ASSERT_FALSE(st.ok()); -} - -} // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/test_util/CMakeLists.txt b/be/test/test_util/CMakeLists.txt deleted file mode 100644 index 223df85022..0000000000 --- a/be/test/test_util/CMakeLists.txt +++ /dev/null @@ -1,31 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/test_util") - -set(TEST_UTIL_FILES - test_util.cpp - array_utils.cpp -) - -add_library(Test_util STATIC - ${TEST_UTIL_FILES} -) - -target_compile_options(Test_util PRIVATE "-fno-access-control") -target_link_libraries(Test_util Common Util Gutil ${Boost_LIBRARIES} glog gflags protobuf) diff --git a/be/test/test_util/array_utils.cpp b/be/test/testutil/array_utils.cpp similarity index 97% rename from be/test/test_util/array_utils.cpp rename to be/test/testutil/array_utils.cpp index 4fb0da5e8b..1cb2d88d38 100644 --- a/be/test/test_util/array_utils.cpp +++ b/be/test/testutil/array_utils.cpp @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -#include "test_util/array_utils.h" +#include "testutil/array_utils.h" #include "common/status.h" #include "exprs/anyval_util.h" @@ -25,7 +25,7 @@ #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" #include "udf/udf_internal.h" -#include "util/array_parser.hpp" +#include "util/array_parser.h" namespace doris { diff --git a/be/test/test_util/array_utils.h b/be/test/testutil/array_utils.h similarity index 100% rename from be/test/test_util/array_utils.h rename to be/test/testutil/array_utils.h diff --git a/be/src/testutil/desc_tbl_builder.cc b/be/test/testutil/desc_tbl_builder.cc similarity index 100% rename from be/src/testutil/desc_tbl_builder.cc rename to be/test/testutil/desc_tbl_builder.cc diff --git a/be/src/testutil/desc_tbl_builder.h b/be/test/testutil/desc_tbl_builder.h similarity index 100% rename from be/src/testutil/desc_tbl_builder.h rename to be/test/testutil/desc_tbl_builder.h diff --git a/be/src/testutil/function_utils.cpp b/be/test/testutil/function_utils.cpp similarity index 100% rename from be/src/testutil/function_utils.cpp rename to be/test/testutil/function_utils.cpp diff --git a/be/src/testutil/function_utils.h b/be/test/testutil/function_utils.h similarity index 100% rename from be/src/testutil/function_utils.h rename to be/test/testutil/function_utils.h diff --git a/be/test/testutil/run_all_tests.cpp b/be/test/testutil/run_all_tests.cpp new file mode 100644 index 0000000000..842282e8c6 --- /dev/null +++ b/be/test/testutil/run_all_tests.cpp @@ -0,0 +1,44 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include + +#include "common/config.h" +#include "olap/page_cache.h" +#include "olap/segment_loader.h" +#include "service/backend_options.h" +#include "util/cpu_info.h" +#include "util/disk_info.h" +#include "util/logging.h" +#include "util/mem_info.h" + +int main(int argc, char** argv) { + doris::StoragePageCache::create_global_cache(1 << 30, 10); + doris::SegmentLoader::create_global_instance(1000); + std::string conf = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; + if (!doris::config::init(conf.c_str(), false)) { + fprintf(stderr, "error read config file. \n"); + return -1; + } + doris::init_glog("be-test"); + ::testing::InitGoogleTest(&argc, argv); + doris::CpuInfo::init(); + doris::DiskInfo::init(); + doris::MemInfo::init(); + doris::BackendOptions::init(); + return RUN_ALL_TESTS(); +} diff --git a/be/test/test_util/test_util.cpp b/be/test/testutil/test_util.cpp similarity index 99% rename from be/test/test_util/test_util.cpp rename to be/test/testutil/test_util.cpp index f9b034c825..dc14f97328 100644 --- a/be/test/test_util/test_util.cpp +++ b/be/test/testutil/test_util.cpp @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include #include diff --git a/be/test/test_util/test_util.h b/be/test/testutil/test_util.h similarity index 100% rename from be/test/test_util/test_util.h rename to be/test/testutil/test_util.h diff --git a/be/test/tools/CMakeLists.txt b/be/test/tools/CMakeLists.txt deleted file mode 100644 index 2389387704..0000000000 --- a/be/test/tools/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/env") -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/tools") - -ADD_BE_TEST(benchmark_tool) diff --git a/be/test/tools/benchmark_tool.cpp b/be/test/tools/benchmark_tool.cpp index b1337fa28f..833ad026e0 100644 --- a/be/test/tools/benchmark_tool.cpp +++ b/be/test/tools/benchmark_tool.cpp @@ -34,6 +34,7 @@ #include "gutil/strings/split.h" #include "gutil/strings/substitute.h" #include "olap/comparison_predicate.h" +#include "olap/data_dir.h" #include "olap/fs/block_manager.h" #include "olap/fs/fs_util.h" #include "olap/in_list_predicate.h" @@ -51,7 +52,7 @@ #include "olap/types.h" #include "runtime/mem_pool.h" #include "runtime/mem_tracker.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/debug_util.h" #include "util/file_utils.h" @@ -345,7 +346,9 @@ public: std::string storage_name; fs::fs_util::block_manager(storage_name)->create_block(block_opts, &wblock); SegmentWriterOptions opts; - SegmentWriter writer(wblock.get(), 0, &_tablet_schema, opts); + DataDir data_dir(kSegmentDir); + data_dir.init(); + SegmentWriter writer(wblock.get(), 0, &_tablet_schema, &data_dir, opts); writer.init(1024); RowCursor row; @@ -616,7 +619,6 @@ private: }; } //namespace doris - int main(int argc, char** argv) { std::string usage = get_usage(argv[0]); gflags::SetUsageMessage(usage); diff --git a/be/test/udf/CMakeLists.txt b/be/test/udf/CMakeLists.txt deleted file mode 100644 index 9bedd9fee0..0000000000 --- a/be/test/udf/CMakeLists.txt +++ /dev/null @@ -1,25 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(LIBRARY_OUTPUT_PATH "${BUILD_DIR}/test/udf") - -# where to put generated binaries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/udf") - -#ADD_BE_TEST(udf_test) -#ADD_BE_TEST(uda_test) diff --git a/be/test/udf/uda_test.cpp b/be/test/udf/uda_test.cpp index dcd7ac3524..0c025fcffa 100644 --- a/be/test/udf/uda_test.cpp +++ b/be/test/udf/uda_test.cpp @@ -314,14 +314,3 @@ TEST(MinTest, Basic) { EXPECT_TRUE(test.execute(values, StringVal("ZZZ"))) << test.get_error_msg(); } } // namespace doris_udf - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/udf/udf_test.cpp b/be/test/udf/udf_test.cpp index c3b15012b9..33ea42d2e5 100644 --- a/be/test/udf/udf_test.cpp +++ b/be/test/udf/udf_test.cpp @@ -198,14 +198,3 @@ TEST(UdfTest, TestVarArgs) { num_var_args, BigIntVal(0), args, IntVal(args.size())))); } } // namespace doris_udf - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/CMakeLists.txt b/be/test/util/CMakeLists.txt deleted file mode 100644 index 74d486c4cd..0000000000 --- a/be/test/util/CMakeLists.txt +++ /dev/null @@ -1,81 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/util") - -ADD_BE_TEST(bit_util_test) -ADD_BE_TEST(brpc_client_cache_test) -ADD_BE_TEST(path_trie_test) -ADD_BE_TEST(coding_test) -ADD_BE_TEST(crc32c_test) -ADD_BE_TEST(lru_cache_util_test) -ADD_BE_TEST(filesystem_util_test) -ADD_BE_TEST(internal_queue_test) -ADD_BE_TEST(cidr_test) -ADD_BE_TEST(new_metrics_test) -ADD_BE_TEST(doris_metrics_test) -ADD_BE_TEST(system_metrics_test) -ADD_BE_TEST(string_util_test) -ADD_BE_TEST(string_parser_test) -ADD_BE_TEST(core_local_test) -ADD_BE_TEST(json_util_test) -ADD_BE_TEST(byte_buffer2_test) -ADD_BE_TEST(uid_util_test) -ADD_BE_TEST(encryption_util_test) -ADD_BE_TEST(md5_test) -ADD_BE_TEST(sm3_test) -ADD_BE_TEST(bitmap_test) -ADD_BE_TEST(bitmap_value_test) -ADD_BE_TEST(faststring_test) -ADD_BE_TEST(rle_encoding_test) -ADD_BE_TEST(tdigest_test) -ADD_BE_TEST(block_compression_test) -ADD_BE_TEST(arrow/arrow_row_block_test) -ADD_BE_TEST(arrow/arrow_row_batch_test) -ADD_BE_TEST(arrow/arrow_work_flow_test) -ADD_BE_TEST(counter_cond_variable_test) -ADD_BE_TEST(frame_of_reference_coding_test) -ADD_BE_TEST(bit_stream_utils_test) -ADD_BE_TEST(radix_sort_test) -ADD_BE_TEST(zip_util_test) -ADD_BE_TEST(utf8_check_test) -ADD_BE_TEST(cgroup_util_test) -ADD_BE_TEST(path_util_test) -ADD_BE_TEST(file_cache_test) -ADD_BE_TEST(parse_util_test) -ADD_BE_TEST(countdown_latch_test) -ADD_BE_TEST(monotime_test) -ADD_BE_TEST(scoped_cleanup_test) -ADD_BE_TEST(thread_test) -ADD_BE_TEST(threadpool_test) -ADD_BE_TEST(mysql_row_buffer_test) -ADD_BE_TEST(trace_test) -ADD_BE_TEST(easy_json-test) -ADD_BE_TEST(http_channel_test) -ADD_BE_TEST(histogram_test) -ADD_BE_TEST(s3_uri_test) -ADD_BE_TEST(s3_storage_backend_test) -ADD_BE_TEST(broker_storage_backend_test) -ADD_BE_TEST(sort_heap_test) -ADD_BE_TEST(counts_test) -ADD_BE_TEST(date_func_test) -ADD_BE_TEST(tuple_row_zorder_compare_test) -ADD_BE_TEST(array_parser_test) -ADD_BE_TEST(quantile_state_test) - -target_link_libraries(Test_util Common Util Gutil ${Boost_LIBRARIES} glog gflags fmt protobuf) diff --git a/be/test/util/array_parser_test.cpp b/be/test/util/array_parser_test.cpp index 19c749ee39..9ae3e53913 100644 --- a/be/test/util/array_parser_test.cpp +++ b/be/test/util/array_parser_test.cpp @@ -23,7 +23,7 @@ #include "olap/types.h" #include "runtime/mem_tracker.h" #include "runtime/string_value.h" -#include "test_util/array_utils.h" +#include "testutil/array_utils.h" namespace doris { @@ -43,21 +43,21 @@ ColumnPB create_column_pb(const std::string& type, const Ts&... sub_column_types return column; } -const TypeInfo* get_type_info(const ColumnPB& column_pb) { +static const TypeInfo* get_type_info(const ColumnPB& column_pb) { TabletColumn tablet_column; tablet_column.init_from_pb(column_pb); return get_type_info(&tablet_column); } -void test_array_parser(const ColumnPB& column_pb, const std::string& json, - const CollectionValue& expect) { +static void test_array_parser(const ColumnPB& column_pb, const std::string& json, + const CollectionValue& expect) { MemTracker tracker(1024 * 1024, "ArrayParserTest"); MemPool mem_pool(&tracker); FunctionContext context; ArrayUtils::prepare_context(context, mem_pool, column_pb); CollectionValue actual; auto status = ArrayUtils::create_collection_value(&actual, &context, json); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); EXPECT_TRUE(get_type_info(column_pb)->equal(&expect, &actual)); } @@ -118,8 +118,3 @@ TEST(ArrayParserTest, TestNestedArray) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/arrow/arrow_row_batch_test.cpp b/be/test/util/arrow/arrow_row_batch_test.cpp index bbcdc6db28..cf5bf79d32 100644 --- a/be/test/util/arrow/arrow_row_batch_test.cpp +++ b/be/test/util/arrow/arrow_row_batch_test.cpp @@ -38,21 +38,22 @@ namespace doris { -class ArrowRowBatchTest : public testing::Test {}; - -std::string test_str() { - return R"( +class ArrowRowBatchTest : public testing::Test { +public: + std::string test_str() { + return R"( { "c1": 1, "c2": 1.1 } { "c1": 2, "c2": 2.2 } { "c1": 3, "c2": 3.3 } )"; -} + } -void MakeBuffer(const std::string& data, std::shared_ptr* out) { - auto res = arrow::AllocateBuffer(data.size(), arrow::default_memory_pool()); - *out = std::move(res.ValueOrDie()); - std::copy(std::begin(data), std::end(data), (*out)->mutable_data()); -} + void MakeBuffer(const std::string& data, std::shared_ptr* out) { + auto res = arrow::AllocateBuffer(data.size(), arrow::default_memory_pool()); + *out = std::move(res.ValueOrDie()); + std::copy(std::begin(data), std::end(data), (*out)->mutable_data()); + } +}; TEST_F(ArrowRowBatchTest, PrettyPrint) { auto json = test_str(); @@ -64,34 +65,29 @@ TEST_F(ArrowRowBatchTest, PrettyPrint) { }); auto arrow_st = arrow::json::ParseOne(parse_opts, buffer); - ASSERT_TRUE(arrow_st.ok()); + EXPECT_TRUE(arrow_st.ok()); std::shared_ptr record_batch = arrow_st.ValueOrDie(); ObjectPool obj_pool; RowDescriptor* row_desc; auto doris_st = convert_to_row_desc(&obj_pool, *record_batch->schema(), &row_desc); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); std::shared_ptr row_batch; doris_st = convert_to_row_batch(*record_batch, *row_desc, &row_batch); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); { std::shared_ptr check_schema; doris_st = convert_to_arrow_schema(*row_desc, &check_schema); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); arrow::MemoryPool* pool = arrow::default_memory_pool(); std::shared_ptr check_batch; doris_st = convert_to_arrow_batch(*row_batch, check_schema, pool, &check_batch); - ASSERT_TRUE(doris_st.ok()); - ASSERT_EQ(3, check_batch->num_rows()); - ASSERT_TRUE(record_batch->Equals(*check_batch)); + EXPECT_TRUE(doris_st.ok()); + EXPECT_EQ(3, check_batch->num_rows()); + EXPECT_TRUE(record_batch->Equals(*check_batch)); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/arrow/arrow_row_block_test.cpp b/be/test/util/arrow/arrow_row_block_test.cpp index 450ae4c001..be86a51d25 100644 --- a/be/test/util/arrow/arrow_row_block_test.cpp +++ b/be/test/util/arrow/arrow_row_block_test.cpp @@ -41,21 +41,19 @@ class ArrowRowBlockTest : public testing::Test { public: ArrowRowBlockTest() {} virtual ~ArrowRowBlockTest() {} -}; - -std::string test_str() { - return R"( + std::string test_str() { + return R"( { "c1": 1, "c2": 1.1 } { "c1": 2, "c2": 2.2 } { "c1": 3, "c2": 3.3 } )"; -} - -void MakeBuffer(const std::string& data, std::shared_ptr* out) { - auto buffer_res = arrow::AllocateBuffer(data.size(), arrow::default_memory_pool()); - *out = std::move(buffer_res.ValueOrDie()); - std::copy(std::begin(data), std::end(data), (*out)->mutable_data()); -} + } + void MakeBuffer(const std::string& data, std::shared_ptr* out) { + auto buffer_res = arrow::AllocateBuffer(data.size(), arrow::default_memory_pool()); + *out = std::move(buffer_res.ValueOrDie()); + std::copy(std::begin(data), std::end(data), (*out)->mutable_data()); + } +}; TEST_F(ArrowRowBlockTest, Normal) { auto json = test_str(); @@ -67,33 +65,28 @@ TEST_F(ArrowRowBlockTest, Normal) { }); auto arrow_st = arrow::json::ParseOne(parse_opts, buffer); - ASSERT_TRUE(arrow_st.ok()); + EXPECT_TRUE(arrow_st.ok()); std::shared_ptr record_batch = arrow_st.ValueOrDie(); std::shared_ptr schema; auto doris_st = convert_to_doris_schema(*record_batch->schema(), &schema); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); std::shared_ptr row_block; doris_st = convert_to_row_block(*record_batch, *schema, &row_block); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); { std::shared_ptr check_schema; doris_st = convert_to_arrow_schema(*schema, &check_schema); - ASSERT_TRUE(doris_st.ok()); + EXPECT_TRUE(doris_st.ok()); arrow::MemoryPool* pool = arrow::default_memory_pool(); std::shared_ptr check_batch; doris_st = convert_to_arrow_batch(*row_block, check_schema, pool, &check_batch); - ASSERT_TRUE(doris_st.ok()); - ASSERT_EQ(3, check_batch->num_rows()); - ASSERT_TRUE(record_batch->Equals(*check_batch)); + EXPECT_TRUE(doris_st.ok()); + EXPECT_EQ(3, check_batch->num_rows()); + EXPECT_TRUE(record_batch->Equals(*check_batch)); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/arrow/arrow_work_flow_test.cpp b/be/test/util/arrow/arrow_work_flow_test.cpp index d723a6ec04..1e22cc9fb9 100644 --- a/be/test/util/arrow/arrow_work_flow_test.cpp +++ b/be/test/util/arrow/arrow_work_flow_test.cpp @@ -54,15 +54,15 @@ protected: config::periodic_counter_update_period_ms = 500; config::storage_root_path = "./data"; - ASSERT_EQ(system("mkdir -p ./test_run/output/"), 0); - ASSERT_EQ(system("pwd"), 0); - ASSERT_EQ(system("cp -r ./be/test/util/test_data/ ./test_run/."), 0); + EXPECT_EQ(system("mkdir -p ./test_run/output/"), 0); + EXPECT_EQ(system("pwd"), 0); + EXPECT_EQ(system("cp -r ./be/test/util/test_data/ ./test_run/."), 0); init(); } virtual void TearDown() { _obj_pool.clear(); - ASSERT_EQ(system("rm -rf ./test_run"), 0); + EXPECT_EQ(system("rm -rf ./test_run"), 0); delete _state; } @@ -300,43 +300,37 @@ TEST_F(ArrowWorkFlowTest, NormalUse) { CsvScanNode scan_node(&_obj_pool, _tnode, *_desc_tbl); scan_node.init(_tnode); Status status = scan_node.prepare(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = scan_node.open(_state); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); RowBatch row_batch(scan_node._row_descriptor, _state->batch_size()); bool eos = false; while (!eos) { status = scan_node.get_next(_state, &row_batch, &eos); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // int num = std::min(row_batch.num_rows(), 10); int num = row_batch.num_rows(); - ASSERT_EQ(6, num); + EXPECT_EQ(6, num); std::shared_ptr schema; status = convert_to_arrow_schema(scan_node._row_descriptor, &schema); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::shared_ptr record_batch; status = convert_to_arrow_batch(row_batch, schema, arrow::default_memory_pool(), &record_batch); - ASSERT_TRUE(status.ok()); - ASSERT_EQ(6, record_batch->num_rows()); - ASSERT_EQ(5, record_batch->num_columns()); + EXPECT_TRUE(status.ok()); + EXPECT_EQ(6, record_batch->num_rows()); + EXPECT_EQ(5, record_batch->num_columns()); std::string result; status = serialize_record_batch(*record_batch, &result); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); size_t len = result.length(); - ASSERT_TRUE(len > 0); + EXPECT_TRUE(len > 0); } - ASSERT_TRUE(scan_node.close(_state).ok()); + EXPECT_TRUE(scan_node.close(_state).ok()); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/bit_stream_utils_test.cpp b/be/test/util/bit_stream_utils_test.cpp index 6e2a73b515..2ac8a3a42a 100644 --- a/be/test/util/bit_stream_utils_test.cpp +++ b/be/test/util/bit_stream_utils_test.cpp @@ -185,16 +185,16 @@ TEST(TestBitStreamUtil, TestSeekToBit) { reader.SeekToBit(buffer.size() * 8 - 8 * 8); uint32_t second_value; reader.GetValue(32, &second_value); - ASSERT_EQ(second_value, 2020); + EXPECT_EQ(second_value, 2020); uint32_t third_value; reader.GetValue(32, &third_value); - ASSERT_EQ(third_value, 2021); + EXPECT_EQ(third_value, 2021); reader.SeekToBit(0); uint32_t first_value; reader.GetValue(32, &first_value); - ASSERT_EQ(first_value, 2019); + EXPECT_EQ(first_value, 2019); } TEST(TestBitStreamUtil, TestUint64) { @@ -210,23 +210,18 @@ TEST(TestBitStreamUtil, TestUint64) { uint64_t v1; reader.GetValue(64, &v1); - ASSERT_EQ(v1, 18446744073709551614U); + EXPECT_EQ(v1, 18446744073709551614U); uint64_t v2; reader.GetValue(64, &v2); - ASSERT_EQ(v2, 18446744073709551613U); + EXPECT_EQ(v2, 18446744073709551613U); uint64_t v3; reader.GetValue(32, &v3); - ASSERT_EQ(v3, 128); + EXPECT_EQ(v3, 128); uint64_t v4; reader.GetValue(16, &v4); - ASSERT_EQ(v4, 126); + EXPECT_EQ(v4, 126); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/bit_util_test.cpp b/be/test/util/bit_util_test.cpp index 1034f785f8..cdfc2c1a39 100644 --- a/be/test/util/bit_util_test.cpp +++ b/be/test/util/bit_util_test.cpp @@ -52,15 +52,3 @@ TEST(BitUtil, Popcount) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/bitmap_test.cpp b/be/test/util/bitmap_test.cpp index 587c08a142..9296dbe961 100644 --- a/be/test/util/bitmap_test.cpp +++ b/be/test/util/bitmap_test.cpp @@ -33,47 +33,47 @@ public: TEST_F(BitMapTest, normal) { // bitmap size - ASSERT_EQ(0, BitmapSize(0)); - ASSERT_EQ(1, BitmapSize(1)); - ASSERT_EQ(1, BitmapSize(8)); - ASSERT_EQ(2, BitmapSize(9)); + EXPECT_EQ(0, BitmapSize(0)); + EXPECT_EQ(1, BitmapSize(1)); + EXPECT_EQ(1, BitmapSize(8)); + EXPECT_EQ(2, BitmapSize(9)); // set, test, clear uint8_t bitmap[1024]; memset(bitmap, 0, 1024); - ASSERT_FALSE(BitmapTest(bitmap, 123)); + EXPECT_FALSE(BitmapTest(bitmap, 123)); BitmapSet(bitmap, 123); - ASSERT_TRUE(BitmapTest(bitmap, 123)); + EXPECT_TRUE(BitmapTest(bitmap, 123)); BitmapClear(bitmap, 123); - ASSERT_FALSE(BitmapTest(bitmap, 123)); + EXPECT_FALSE(BitmapTest(bitmap, 123)); BitmapChange(bitmap, 112, true); - ASSERT_TRUE(BitmapTest(bitmap, 112)); + EXPECT_TRUE(BitmapTest(bitmap, 112)); BitmapChange(bitmap, 112, false); - ASSERT_FALSE(BitmapTest(bitmap, 112)); + EXPECT_FALSE(BitmapTest(bitmap, 112)); // change bits BitmapChangeBits(bitmap, 100, 200, true); for (int i = 0; i < 200; i++) { - ASSERT_TRUE(BitmapTest(bitmap, 100 + i)); + EXPECT_TRUE(BitmapTest(bitmap, 100 + i)); } // Find fist bool found = false; size_t idx; found = BitmapFindFirstSet(bitmap, 0, 1024 * 8, &idx); - ASSERT_TRUE(found); - ASSERT_EQ(100, idx); + EXPECT_TRUE(found); + EXPECT_EQ(100, idx); found = BitmapFindFirstZero(bitmap, 200, 1024 * 8, &idx); - ASSERT_TRUE(found); - ASSERT_EQ(300, idx); + EXPECT_TRUE(found); + EXPECT_EQ(300, idx); found = BitmapFindFirstSet(bitmap, 300, 1024 * 8, &idx); - ASSERT_FALSE(found); + EXPECT_FALSE(found); found = BitmapFindFirstZero(bitmap, 300, 1024 * 8, &idx); - ASSERT_TRUE(found); - ASSERT_EQ(300, idx); + EXPECT_TRUE(found); + EXPECT_EQ(300, idx); } TEST_F(BitMapTest, iterator) { @@ -89,50 +89,45 @@ TEST_F(BitMapTest, iterator) { } BitmapIterator iter(bitmap, 1024 * 8); - ASSERT_FALSE(iter.done()); + EXPECT_FALSE(iter.done()); bool value; // 0,100 --- false auto run = iter.Next(&value); - ASSERT_FALSE(value); - ASSERT_EQ(100, run); + EXPECT_FALSE(value); + EXPECT_EQ(100, run); // 100,2000 -- true run = iter.Next(&value); - ASSERT_TRUE(value); - ASSERT_EQ(2000 - 100, run); + EXPECT_TRUE(value); + EXPECT_EQ(2000 - 100, run); // 2000,2100 -- false run = iter.Next(&value); - ASSERT_FALSE(value); - ASSERT_EQ(2100 - 2000, run); + EXPECT_FALSE(value); + EXPECT_EQ(2100 - 2000, run); // 2100,3000 -- true run = iter.Next(&value); - ASSERT_TRUE(value); - ASSERT_EQ(3000 - 2100, run); + EXPECT_TRUE(value); + EXPECT_EQ(3000 - 2100, run); // 3000,8*1024 -- false run = iter.Next(&value); - ASSERT_FALSE(value); - ASSERT_EQ(8 * 1024 - 3000, run); - ASSERT_TRUE(iter.done()); + EXPECT_FALSE(value); + EXPECT_EQ(8 * 1024 - 3000, run); + EXPECT_TRUE(iter.done()); // seek to 8000 iter.SeekTo(8000); run = iter.Next(&value); - ASSERT_FALSE(value); - ASSERT_EQ(8 * 1024 - 8000, run); - ASSERT_TRUE(iter.done()); + EXPECT_FALSE(value); + EXPECT_EQ(8 * 1024 - 8000, run); + EXPECT_TRUE(iter.done()); // with max_run iter.SeekTo(200); run = iter.Next(&value, 500); - ASSERT_TRUE(value); - ASSERT_EQ(500, run); + EXPECT_TRUE(value); + EXPECT_EQ(500, run); run = iter.Next(&value); - ASSERT_TRUE(value); - ASSERT_EQ(2000 - 500 - 200, run); + EXPECT_TRUE(value); + EXPECT_EQ(2000 - 500 - 200, run); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/bitmap_value_test.cpp b/be/test/util/bitmap_value_test.cpp index cb2083d77d..0e0cdbe0db 100644 --- a/be/test/util/bitmap_value_test.cpp +++ b/be/test/util/bitmap_value_test.cpp @@ -32,38 +32,38 @@ TEST(BitmapValueTest, bitmap_union) { BitmapValue single(1024); BitmapValue bitmap({1024, 1025, 1026}); - ASSERT_EQ(0, empty.cardinality()); - ASSERT_EQ(1, single.cardinality()); - ASSERT_EQ(3, bitmap.cardinality()); + EXPECT_EQ(0, empty.cardinality()); + EXPECT_EQ(1, single.cardinality()); + EXPECT_EQ(3, bitmap.cardinality()); BitmapValue empty2; empty2 |= empty; - ASSERT_EQ(0, empty2.cardinality()); + EXPECT_EQ(0, empty2.cardinality()); empty2 |= single; - ASSERT_EQ(1, empty2.cardinality()); + EXPECT_EQ(1, empty2.cardinality()); BitmapValue empty3; empty3 |= bitmap; - ASSERT_EQ(3, empty3.cardinality()); + EXPECT_EQ(3, empty3.cardinality()); BitmapValue single2(1025); single2 |= empty; - ASSERT_EQ(1, single2.cardinality()); + EXPECT_EQ(1, single2.cardinality()); single2 |= single; - ASSERT_EQ(2, single2.cardinality()); + EXPECT_EQ(2, single2.cardinality()); BitmapValue single3(1027); single3 |= bitmap; - ASSERT_EQ(4, single3.cardinality()); + EXPECT_EQ(4, single3.cardinality()); BitmapValue bitmap2; bitmap2.add(1024); bitmap2.add(2048); bitmap2.add(4096); bitmap2 |= empty; - ASSERT_EQ(3, bitmap2.cardinality()); + EXPECT_EQ(3, bitmap2.cardinality()); bitmap2 |= single; - ASSERT_EQ(3, bitmap2.cardinality()); + EXPECT_EQ(3, bitmap2.cardinality()); bitmap2 |= bitmap; - ASSERT_EQ(5, bitmap2.cardinality()); + EXPECT_EQ(5, bitmap2.cardinality()); } TEST(BitmapValueTest, bitmap_intersect) { @@ -73,60 +73,60 @@ TEST(BitmapValueTest, bitmap_intersect) { BitmapValue empty2; empty2 &= empty; - ASSERT_EQ(0, empty2.cardinality()); + EXPECT_EQ(0, empty2.cardinality()); empty2 &= single; - ASSERT_EQ(0, empty2.cardinality()); + EXPECT_EQ(0, empty2.cardinality()); empty2 &= bitmap; - ASSERT_EQ(0, empty2.cardinality()); + EXPECT_EQ(0, empty2.cardinality()); BitmapValue single2(1025); single2 &= empty; - ASSERT_EQ(0, single2.cardinality()); + EXPECT_EQ(0, single2.cardinality()); BitmapValue single4(1025); single4 &= single; - ASSERT_EQ(0, single4.cardinality()); + EXPECT_EQ(0, single4.cardinality()); BitmapValue single3(1024); single3 &= single; - ASSERT_EQ(1, single3.cardinality()); + EXPECT_EQ(1, single3.cardinality()); single3 &= bitmap; - ASSERT_EQ(1, single3.cardinality()); + EXPECT_EQ(1, single3.cardinality()); BitmapValue single5(2048); single5 &= bitmap; - ASSERT_EQ(0, single5.cardinality()); + EXPECT_EQ(0, single5.cardinality()); BitmapValue bitmap2; bitmap2.add(1024); bitmap2.add(2048); bitmap2 &= empty; - ASSERT_EQ(0, bitmap2.cardinality()); + EXPECT_EQ(0, bitmap2.cardinality()); BitmapValue bitmap3; bitmap3.add(1024); bitmap3.add(2048); bitmap3 &= single; - ASSERT_EQ(1, bitmap3.cardinality()); + EXPECT_EQ(1, bitmap3.cardinality()); BitmapValue bitmap4; bitmap4.add(2049); bitmap4.add(2048); bitmap4 &= single; - ASSERT_EQ(0, bitmap4.cardinality()); + EXPECT_EQ(0, bitmap4.cardinality()); BitmapValue bitmap5; bitmap5.add(2049); bitmap5.add(2048); bitmap5 &= bitmap; - ASSERT_EQ(0, bitmap5.cardinality()); + EXPECT_EQ(0, bitmap5.cardinality()); BitmapValue bitmap6; bitmap6.add(1024); bitmap6.add(1025); bitmap6 &= bitmap; - ASSERT_EQ(2, bitmap6.cardinality()); + EXPECT_EQ(2, bitmap6.cardinality()); } std::string convert_bitmap_to_string(BitmapValue& bitmap) { @@ -141,10 +141,10 @@ TEST(BitmapValueTest, bitmap_serde) { BitmapValue empty; std::string buffer = convert_bitmap_to_string(empty); std::string expect_buffer(1, BitmapTypeCode::EMPTY); - ASSERT_EQ(expect_buffer, buffer); + EXPECT_EQ(expect_buffer, buffer); BitmapValue out(buffer.data()); - ASSERT_EQ(0, out.cardinality()); + EXPECT_EQ(0, out.cardinality()); } { // SINGLE32 uint32_t i = UINT32_MAX; @@ -152,11 +152,11 @@ TEST(BitmapValueTest, bitmap_serde) { std::string buffer = convert_bitmap_to_string(single32); std::string expect_buffer(1, BitmapTypeCode::SINGLE32); put_fixed32_le(&expect_buffer, i); - ASSERT_EQ(expect_buffer, buffer); + EXPECT_EQ(expect_buffer, buffer); BitmapValue out(buffer.data()); - ASSERT_EQ(1, out.cardinality()); - ASSERT_TRUE(out.contains(i)); + EXPECT_EQ(1, out.cardinality()); + EXPECT_TRUE(out.contains(i)); } { // BITMAP32 BitmapValue bitmap32({0, UINT32_MAX}); @@ -168,12 +168,12 @@ TEST(BitmapValueTest, bitmap_serde) { std::string expect_buffer(1, BitmapTypeCode::BITMAP32); expect_buffer.resize(1 + roaring.getSizeInBytes()); roaring.write(&expect_buffer[1]); - ASSERT_EQ(expect_buffer, buffer); + EXPECT_EQ(expect_buffer, buffer); BitmapValue out(buffer.data()); - ASSERT_EQ(2, out.cardinality()); - ASSERT_TRUE(out.contains(0)); - ASSERT_TRUE(out.contains(UINT32_MAX)); + EXPECT_EQ(2, out.cardinality()); + EXPECT_TRUE(out.contains(0)); + EXPECT_TRUE(out.contains(UINT32_MAX)); } { // SINGLE64 uint64_t i = static_cast(UINT32_MAX) + 1; @@ -181,11 +181,11 @@ TEST(BitmapValueTest, bitmap_serde) { std::string buffer = convert_bitmap_to_string(single64); std::string expect_buffer(1, BitmapTypeCode::SINGLE64); put_fixed64_le(&expect_buffer, i); - ASSERT_EQ(expect_buffer, buffer); + EXPECT_EQ(expect_buffer, buffer); BitmapValue out(buffer.data()); - ASSERT_EQ(1, out.cardinality()); - ASSERT_TRUE(out.contains(i)); + EXPECT_EQ(1, out.cardinality()); + EXPECT_TRUE(out.contains(i)); } { // BITMAP64 BitmapValue bitmap64({0, static_cast(UINT32_MAX) + 1}); @@ -203,12 +203,12 @@ TEST(BitmapValueTest, bitmap_serde) { expect_buffer.append(map_entry); } - ASSERT_EQ(expect_buffer, buffer); + EXPECT_EQ(expect_buffer, buffer); BitmapValue out(buffer.data()); - ASSERT_EQ(2, out.cardinality()); - ASSERT_TRUE(out.contains(0)); - ASSERT_TRUE(out.contains(static_cast(UINT32_MAX) + 1)); + EXPECT_EQ(2, out.cardinality()); + EXPECT_TRUE(out.contains(0)); + EXPECT_TRUE(out.contains(static_cast(UINT32_MAX) + 1)); } } @@ -227,37 +227,37 @@ TEST(BitmapValueTest, Roaring64Map) { r1.add(i); r1_sum += i; } - ASSERT_TRUE(r1.contains((uint64_t)14000000000000000500ull)); - ASSERT_EQ(1800, r1.cardinality()); + EXPECT_TRUE(r1.contains((uint64_t)14000000000000000500ull)); + EXPECT_EQ(1800, r1.cardinality()); size_t size_before = r1.getSizeInBytes(); r1.runOptimize(); size_t size_after = r1.getSizeInBytes(); - ASSERT_LT(size_after, size_before); + EXPECT_LT(size_after, size_before); Roaring64Map r2 = Roaring64Map::bitmapOf(5, 1ull, 2ull, 234294967296ull, 195839473298ull, 14000000000000000100ull); - ASSERT_EQ(1ull, r2.minimum()); - ASSERT_EQ(14000000000000000100ull, r2.maximum()); - ASSERT_EQ(4ull, r2.rank(234294967296ull)); + EXPECT_EQ(1ull, r2.minimum()); + EXPECT_EQ(14000000000000000100ull, r2.maximum()); + EXPECT_EQ(4ull, r2.rank(234294967296ull)); // we can also create a bitmap from a pointer to 32-bit integers const uint32_t values[] = {2, 3, 4}; Roaring64Map r3(3, values); - ASSERT_EQ(3, r3.cardinality()); + EXPECT_EQ(3, r3.cardinality()); // we can also go in reverse and go from arrays to bitmaps uint64_t card1 = r1.cardinality(); uint64_t* arr1 = new uint64_t[card1]; - ASSERT_TRUE(arr1 != nullptr); + EXPECT_TRUE(arr1 != nullptr); r1.toUint64Array(arr1); Roaring64Map r1f(card1, arr1); delete[] arr1; // bitmaps shall be equal - ASSERT_TRUE(r1 == r1f); + EXPECT_TRUE(r1 == r1f); // we can copy and compare bitmaps Roaring64Map z(r3); - ASSERT_TRUE(r3 == z); + EXPECT_TRUE(r3 == z); // we can compute union two-by-two Roaring64Map r1_2_3 = r1 | r2; @@ -266,19 +266,19 @@ TEST(BitmapValueTest, Roaring64Map) { // we can compute a big union const Roaring64Map* allmybitmaps[] = {&r1, &r2, &r3}; Roaring64Map bigunion = Roaring64Map::fastunion(3, allmybitmaps); - ASSERT_TRUE(r1_2_3 == bigunion); - ASSERT_EQ(1806, r1_2_3.cardinality()); + EXPECT_TRUE(r1_2_3 == bigunion); + EXPECT_EQ(1806, r1_2_3.cardinality()); // we can compute intersection two-by-two Roaring64Map i1_2 = r1 & r2; - ASSERT_EQ(1, i1_2.cardinality()); + EXPECT_EQ(1, i1_2.cardinality()); // we can write a bitmap to a pointer and recover it later uint32_t expectedsize = r1.getSizeInBytes(); char* serializedbytes = new char[expectedsize]; r1.write(serializedbytes); Roaring64Map t = Roaring64Map::read(serializedbytes); - ASSERT_TRUE(r1 == t); + EXPECT_TRUE(r1 == t); delete[] serializedbytes; // we can iterate over all values using custom functions @@ -288,104 +288,99 @@ TEST(BitmapValueTest, Roaring64Map) { return true; // we always process all values }; r1.iterate(func, &sum); - ASSERT_EQ(r1_sum, sum); + EXPECT_EQ(r1_sum, sum); // we can also iterate the C++ way sum = 0; for (Roaring64Map::const_iterator i = t.begin(); i != t.end(); i++) { sum += *i; } - ASSERT_EQ(r1_sum, sum); + EXPECT_EQ(r1_sum, sum); } TEST(BitmapValueTest, bitmap_to_string) { BitmapValue empty; - ASSERT_STREQ("", empty.to_string().c_str()); + EXPECT_STREQ("", empty.to_string().c_str()); empty.add(1); - ASSERT_STREQ("1", empty.to_string().c_str()); + EXPECT_STREQ("1", empty.to_string().c_str()); empty.add(2); - ASSERT_STREQ("1,2", empty.to_string().c_str()); + EXPECT_STREQ("1,2", empty.to_string().c_str()); } TEST(BitmapValueTest, sub_limit) { - BitmapValue bitmap({1,2,3,10,11,5,6,7,8,9}); + BitmapValue bitmap({1, 2, 3, 10, 11, 5, 6, 7, 8, 9}); BitmapValue ret_bitmap1; - ASSERT_EQ(5, bitmap.sub_limit(0, 5, &ret_bitmap1)); - ASSERT_STREQ("1,2,3,5,6", ret_bitmap1.to_string().c_str()); + EXPECT_EQ(5, bitmap.sub_limit(0, 5, &ret_bitmap1)); + EXPECT_STREQ("1,2,3,5,6", ret_bitmap1.to_string().c_str()); BitmapValue ret_bitmap2; - ASSERT_EQ(6, bitmap.sub_limit(6, 10, &ret_bitmap2)); - ASSERT_STREQ("6,7,8,9,10,11", ret_bitmap2.to_string().c_str()); + EXPECT_EQ(6, bitmap.sub_limit(6, 10, &ret_bitmap2)); + EXPECT_STREQ("6,7,8,9,10,11", ret_bitmap2.to_string().c_str()); BitmapValue ret_bitmap3; - ASSERT_EQ(3, bitmap.sub_limit(5, 3, &ret_bitmap3)); - ASSERT_STREQ("5,6,7", ret_bitmap3.to_string().c_str()); + EXPECT_EQ(3, bitmap.sub_limit(5, 3, &ret_bitmap3)); + EXPECT_STREQ("5,6,7", ret_bitmap3.to_string().c_str()); BitmapValue ret_bitmap4; - ASSERT_EQ(5, bitmap.sub_limit(2, 5, &ret_bitmap4)); - ASSERT_STREQ("2,3,5,6,7", ret_bitmap4.to_string().c_str()); + EXPECT_EQ(5, bitmap.sub_limit(2, 5, &ret_bitmap4)); + EXPECT_STREQ("2,3,5,6,7", ret_bitmap4.to_string().c_str()); } TEST(BitmapValueTest, bitmap_single_convert) { BitmapValue bitmap; - ASSERT_STREQ("", bitmap.to_string().c_str()); + EXPECT_STREQ("", bitmap.to_string().c_str()); bitmap.add(1); - ASSERT_STREQ("1", bitmap.to_string().c_str()); + EXPECT_STREQ("1", bitmap.to_string().c_str()); bitmap.add(1); - ASSERT_STREQ("1", bitmap.to_string().c_str()); - ASSERT_EQ(BitmapValue::SINGLE, bitmap._type); + EXPECT_STREQ("1", bitmap.to_string().c_str()); + EXPECT_EQ(BitmapValue::SINGLE, bitmap._type); BitmapValue bitmap_u; bitmap_u.add(1); bitmap |= bitmap_u; - ASSERT_EQ(BitmapValue::SINGLE, bitmap._type); + EXPECT_EQ(BitmapValue::SINGLE, bitmap._type); bitmap_u.add(2); - ASSERT_EQ(BitmapValue::BITMAP, bitmap_u._type); + EXPECT_EQ(BitmapValue::BITMAP, bitmap_u._type); bitmap |= bitmap_u; - ASSERT_EQ(BitmapValue::BITMAP, bitmap._type); + EXPECT_EQ(BitmapValue::BITMAP, bitmap._type); } TEST(BitmapValueTest, bitmap_value_iterator_test) { BitmapValue empty; for (auto iter = empty.begin(); iter != empty.end(); ++iter) { // should not goes here - ASSERT_TRUE(false); + EXPECT_TRUE(false); } BitmapValue single(1024); for (auto iter = single.begin(); iter != single.end(); ++iter) { - ASSERT_EQ(1024, *iter); + EXPECT_EQ(1024, *iter); } int i = 0; BitmapValue bitmap({0, 1025, 1026, UINT32_MAX, UINT64_MAX}); for (auto iter = bitmap.begin(); iter != bitmap.end(); ++iter, ++i) { switch (i) { - case 0: - ASSERT_EQ(0, *iter); - break; - case 1: - ASSERT_EQ(1025, *iter); - break; - case 2: - ASSERT_EQ(1026, *iter); - break; - case 3: - ASSERT_EQ(UINT32_MAX, *iter); - break; - case 4: - ASSERT_EQ(UINT64_MAX, *iter); - break; - default: - ASSERT_TRUE(false); + case 0: + EXPECT_EQ(0, *iter); + break; + case 1: + EXPECT_EQ(1025, *iter); + break; + case 2: + EXPECT_EQ(1026, *iter); + break; + case 3: + EXPECT_EQ(UINT32_MAX, *iter); + break; + case 4: + EXPECT_EQ(UINT64_MAX, *iter); + break; + default: + EXPECT_TRUE(false); } } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/block_compression_test.cpp b/be/test/util/block_compression_test.cpp index 3eabd735b8..cec2ac48da 100644 --- a/be/test/util/block_compression_test.cpp +++ b/be/test/util/block_compression_test.cpp @@ -44,7 +44,7 @@ static std::string generate_str(size_t len) { void test_single_slice(segment_v2::CompressionTypePB type) { const BlockCompressionCodec* codec = nullptr; auto st = get_block_compression_codec(type, &codec); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); size_t test_sizes[] = {0, 1, 10, 1000, 1000000}; for (auto size : test_sizes) { @@ -55,16 +55,16 @@ void test_single_slice(segment_v2::CompressionTypePB type) { { Slice compressed_slice(compressed); st = codec->compress(orig, &compressed_slice); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::string uncompressed; uncompressed.resize(size); { Slice uncompressed_slice(uncompressed); st = codec->decompress(compressed_slice, &uncompressed_slice); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_STREQ(orig.c_str(), uncompressed.c_str()); + EXPECT_STREQ(orig.c_str(), uncompressed.c_str()); } // buffer not enough for decompress // snappy has no return value if given buffer is not enough @@ -75,14 +75,14 @@ void test_single_slice(segment_v2::CompressionTypePB type) { Slice uncompressed_slice(uncompressed); uncompressed_slice.size -= 1; st = codec->decompress(compressed_slice, &uncompressed_slice); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } // corrupt compressed data if (type != segment_v2::CompressionTypePB::SNAPPY) { Slice uncompressed_slice(uncompressed); compressed_slice.size -= 1; st = codec->decompress(compressed_slice, &uncompressed_slice); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); compressed_slice.size += 1; } } @@ -91,7 +91,7 @@ void test_single_slice(segment_v2::CompressionTypePB type) { Slice compressed_slice(compressed); compressed_slice.size = 1; st = codec->compress(orig, &compressed_slice); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } } } @@ -106,7 +106,7 @@ TEST_F(BlockCompressionTest, single) { void test_multi_slices(segment_v2::CompressionTypePB type) { const BlockCompressionCodec* codec = nullptr; auto st = get_block_compression_codec(type, &codec); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); size_t test_sizes[] = {0, 1, 10, 1000, 1000000}; std::vector orig_strs; @@ -128,7 +128,7 @@ void test_multi_slices(segment_v2::CompressionTypePB type) { { Slice compressed_slice(compressed); st = codec->compress(orig_slices, &compressed_slice); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); std::string uncompressed; uncompressed.resize(total_size); @@ -136,9 +136,9 @@ void test_multi_slices(segment_v2::CompressionTypePB type) { { Slice uncompressed_slice(uncompressed); st = codec->decompress(compressed_slice, &uncompressed_slice); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); - ASSERT_STREQ(orig.c_str(), uncompressed.c_str()); + EXPECT_STREQ(orig.c_str(), uncompressed.c_str()); } } @@ -147,7 +147,7 @@ void test_multi_slices(segment_v2::CompressionTypePB type) { Slice compressed_slice(compressed); compressed_slice.size = 10; st = codec->compress(orig, &compressed_slice); - ASSERT_FALSE(st.ok()); + EXPECT_FALSE(st.ok()); } } @@ -159,8 +159,3 @@ TEST_F(BlockCompressionTest, multi) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/blocking_queue_test.cpp b/be/test/util/blocking_queue_test.cpp index eb87eb02e5..419ffe49ca 100644 --- a/be/test/util/blocking_queue_test.cpp +++ b/be/test/util/blocking_queue_test.cpp @@ -29,26 +29,26 @@ namespace doris { TEST(BlockingQueueTest, TestBasic) { int32_t i; BlockingQueue test_queue(5); - ASSERT_TRUE(test_queue.blocking_put(1)); - ASSERT_TRUE(test_queue.blocking_put(2)); - ASSERT_TRUE(test_queue.blocking_put(3)); - ASSERT_TRUE(test_queue.blocking_get(&i)); - ASSERT_EQ(1, i); - ASSERT_TRUE(test_queue.blocking_get(&i)); - ASSERT_EQ(2, i); - ASSERT_TRUE(test_queue.blocking_get(&i)); - ASSERT_EQ(3, i); + EXPECT_TRUE(test_queue.blocking_put(1)); + EXPECT_TRUE(test_queue.blocking_put(2)); + EXPECT_TRUE(test_queue.blocking_put(3)); + EXPECT_TRUE(test_queue.blocking_get(&i)); + EXPECT_EQ(1, i); + EXPECT_TRUE(test_queue.blocking_get(&i)); + EXPECT_EQ(2, i); + EXPECT_TRUE(test_queue.blocking_get(&i)); + EXPECT_EQ(3, i); } TEST(BlockingQueueTest, TestGetFromShutdownQueue) { int64_t i; BlockingQueue test_queue(2); - ASSERT_TRUE(test_queue.blocking_put(123)); + EXPECT_TRUE(test_queue.blocking_put(123)); test_queue.shutdown(); - ASSERT_FALSE(test_queue.blocking_put(456)); - ASSERT_TRUE(test_queue.blocking_get(&i)); - ASSERT_EQ(123, i); - ASSERT_FALSE(test_queue.blocking_get(&i)); + EXPECT_FALSE(test_queue.blocking_put(456)); + EXPECT_TRUE(test_queue.blocking_get(&i)); + EXPECT_EQ(123, i); + EXPECT_FALSE(test_queue.blocking_get(&i)); } class MultiThreadTest { @@ -110,13 +110,13 @@ public: std::lock_guard guard(_lock); for (int i = 0; i < _nthreads; ++i) { - ASSERT_EQ(_iterations, _gotten[i]); + EXPECT_EQ(_iterations, _gotten[i]); } // And there were _nthreads * (_iterations + 1) elements removed, but only // _nthreads * _iterations elements added. So some removers hit the shutdown // case. - ASSERT_EQ(_iterations, _gotten[-1]); + EXPECT_EQ(_iterations, _gotten[-1]); } private: diff --git a/be/test/util/broker_storage_backend_test.cpp b/be/test/util/broker_storage_backend_test.cpp index 7ff0d05e65..bbf0af69d1 100644 --- a/be/test/util/broker_storage_backend_test.cpp +++ b/be/test/util/broker_storage_backend_test.cpp @@ -37,6 +37,8 @@ static const std::string SK = "SK"; static const std::string ENDPOINT = "http://bj.bcebos.com"; static const std::string BUCKET = "bos://yang-repo/"; static const std::string BROKER_IP = "127.0.0.1"; + +#define StorageBackendTest DISABLED_StorageBackendTest class StorageBackendTest : public testing::Test { public: StorageBackendTest() @@ -88,109 +90,100 @@ protected: TEST_F(StorageBackendTest, broker_upload) { Status status = _broker->upload(_test_file, _broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _broker->download(_broker_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); status = _broker->upload(_test_file + "_not_found", _broker_base_path + "/Ode_to_the_West_Wind1.txt"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind1.txt"); - ASSERT_EQ(TStatusCode::NOT_FOUND, status.code()); + EXPECT_EQ(TStatusCode::NOT_FOUND, status.code()); } TEST_F(StorageBackendTest, broker_direct_upload) { Status status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _broker->download(_broker_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); } TEST_F(StorageBackendTest, broker_download) { Status status = _broker->upload(_test_file, _broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _broker->download(_broker_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); status = _broker->download(_broker_base_path + "/Ode_to_the_West_Wind.txt.not_found", _test_file + ".download"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = _broker->download(_broker_base_path + "/Ode_to_the_West_Wind.txt.not_found", "/not_permitted.download"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(StorageBackendTest, broker_rename) { Status status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->rename(_broker_base_path + "/Ode_to_the_West_Wind.txt", _broker_base_path + "/Ode_to_the_West_Wind.txt.new"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); // rm by broker old file may exist for a few moment // status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - // ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + // EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt.new"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(StorageBackendTest, broker_list) { Status status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind1.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind2.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::map files; status = _broker->list(_broker_base_path, true, false, &files); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind") != files.end()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind1") != files.end()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind2") != files.end()); - ASSERT_EQ(3, files.size()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind") != files.end()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind1") != files.end()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind2") != files.end()); + EXPECT_EQ(3, files.size()); } TEST_F(StorageBackendTest, broker_rm) { Status status = _broker->direct_upload(_broker_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->rm(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _broker->exist(_broker_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - int ret = 0; - // ak sk is secret - // ret = RUN_ALL_TESTS(); - return ret; -} \ No newline at end of file diff --git a/be/test/util/brpc_client_cache_test.cpp b/be/test/util/brpc_client_cache_test.cpp index c6ece74175..13a6a09790 100644 --- a/be/test/util/brpc_client_cache_test.cpp +++ b/be/test/util/brpc_client_cache_test.cpp @@ -33,14 +33,14 @@ TEST_F(BrpcClientCacheTest, normal) { address.hostname = "127.0.0.1"; address.port = 123; auto stub1 = cache.get_client(address); - ASSERT_NE(nullptr, stub1); + EXPECT_NE(nullptr, stub1); address.port = 124; auto stub2 = cache.get_client(address); - ASSERT_NE(nullptr, stub2); - ASSERT_NE(stub1, stub2); + EXPECT_NE(nullptr, stub2); + EXPECT_NE(stub1, stub2); address.port = 123; auto stub3 = cache.get_client(address); - ASSERT_EQ(stub1, stub3); + EXPECT_EQ(stub1, stub3); } TEST_F(BrpcClientCacheTest, invalid) { @@ -49,12 +49,7 @@ TEST_F(BrpcClientCacheTest, invalid) { address.hostname = "invalid.cm.invalid"; address.port = 123; auto stub1 = cache.get_client(address); - ASSERT_EQ(nullptr, stub1); + EXPECT_EQ(nullptr, stub1); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/byte_buffer2_test.cpp b/be/test/util/byte_buffer2_test.cpp index 86d8dffd06..21fca1181e 100644 --- a/be/test/util/byte_buffer2_test.cpp +++ b/be/test/util/byte_buffer2_test.cpp @@ -30,28 +30,23 @@ public: TEST_F(ByteBufferTest, normal) { auto buf = ByteBuffer::allocate(4); - ASSERT_EQ(0, buf->pos); - ASSERT_EQ(4, buf->limit); - ASSERT_EQ(4, buf->capacity); + EXPECT_EQ(0, buf->pos); + EXPECT_EQ(4, buf->limit); + EXPECT_EQ(4, buf->capacity); char test[] = {1, 2, 3}; buf->put_bytes(test, 3); - ASSERT_EQ(3, buf->pos); - ASSERT_EQ(4, buf->limit); - ASSERT_EQ(4, buf->capacity); + EXPECT_EQ(3, buf->pos); + EXPECT_EQ(4, buf->limit); + EXPECT_EQ(4, buf->capacity); - ASSERT_EQ(1, buf->remaining()); + EXPECT_EQ(1, buf->remaining()); buf->flip(); - ASSERT_EQ(0, buf->pos); - ASSERT_EQ(3, buf->limit); - ASSERT_EQ(4, buf->capacity); - ASSERT_EQ(3, buf->remaining()); + EXPECT_EQ(0, buf->pos); + EXPECT_EQ(3, buf->limit); + EXPECT_EQ(4, buf->capacity); + EXPECT_EQ(3, buf->remaining()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/cgroup_util_test.cpp b/be/test/util/cgroup_util_test.cpp index e10b62e96b..884e670291 100644 --- a/be/test/util/cgroup_util_test.cpp +++ b/be/test/util/cgroup_util_test.cpp @@ -38,21 +38,16 @@ TEST_F(CGroupUtilTest, memlimit) { if (cgroup_util.enable()) { std::ifstream file("/proc/self/cgroup"); if (file.peek() == std::ifstream::traits_type::eof()) { - ASSERT_FALSE(status1.ok()); - ASSERT_FALSE(status2.ok()); + EXPECT_FALSE(status1.ok()); + EXPECT_FALSE(status2.ok()); } else { - ASSERT_TRUE(status1.ok()); - ASSERT_TRUE(status2.ok()); + EXPECT_TRUE(status1.ok()); + EXPECT_TRUE(status2.ok()); } } else { - ASSERT_FALSE(status1.ok()); - ASSERT_FALSE(status2.ok()); + EXPECT_FALSE(status1.ok()); + EXPECT_FALSE(status2.ok()); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/cidr_test.cpp b/be/test/util/cidr_test.cpp index 15b5826058..33e4dd88f0 100644 --- a/be/test/util/cidr_test.cpp +++ b/be/test/util/cidr_test.cpp @@ -56,9 +56,3 @@ TEST(CIDR, contains) { } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/coding_test.cpp b/be/test/util/coding_test.cpp index d32adb094b..dd0117c7d3 100644 --- a/be/test/util/coding_test.cpp +++ b/be/test/util/coding_test.cpp @@ -34,31 +34,31 @@ TEST_F(CodingTest, fixed_le) { encode_fixed8(buf, 124); uint8_t val8 = decode_fixed8(buf); - ASSERT_EQ(124, val8); + EXPECT_EQ(124, val8); encode_fixed16_le(buf, 12345); uint16_t val16 = decode_fixed16_le(buf); - ASSERT_EQ(12345, val16); + EXPECT_EQ(12345, val16); encode_fixed32_le(buf, 1234554321); uint32_t val32 = decode_fixed32_le(buf); - ASSERT_EQ(1234554321, val32); + EXPECT_EQ(1234554321, val32); encode_fixed64_le(buf, 12345543211234554321UL); uint64_t val64 = decode_fixed64_le(buf); - ASSERT_EQ(12345543211234554321UL, val64); + EXPECT_EQ(12345543211234554321UL, val64); std::string str; put_fixed32_le(&str, val32); put_fixed64_le(&str, val64); - ASSERT_EQ(4 + 8, str.size()); + EXPECT_EQ(4 + 8, str.size()); val32 = decode_fixed32_le((const uint8_t*)str.data()); - ASSERT_EQ(1234554321, val32); + EXPECT_EQ(1234554321, val32); encode_fixed64_le(buf, 12345543211234554321UL); val64 = decode_fixed64_le((const uint8_t*)str.data() + 4); - ASSERT_EQ(12345543211234554321UL, val64); + EXPECT_EQ(12345543211234554321UL, val64); } TEST_F(CodingTest, variant) { @@ -68,19 +68,19 @@ TEST_F(CodingTest, variant) { uint8_t* ptr = buf; ptr = encode_varint32(ptr, 1); ptr = encode_varint64(ptr, 2); - ASSERT_EQ(2, ptr - buf); + EXPECT_EQ(2, ptr - buf); } const uint8_t* ptr = buf; const uint8_t* limit = ptr + 64; uint32_t val32; ptr = decode_varint32_ptr(ptr, limit, &val32); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(1, val32); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(1, val32); uint64_t val64; ptr = decode_varint64_ptr(ptr, limit, &val64); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(2, val64); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(2, val64); } TEST_F(CodingTest, variant_bigvalue) { @@ -89,21 +89,21 @@ TEST_F(CodingTest, variant_bigvalue) { { uint8_t* ptr = buf; ptr = encode_varint32(ptr, 1234554321UL); - ASSERT_EQ(5, ptr - buf); + EXPECT_EQ(5, ptr - buf); ptr = encode_varint64(ptr, 12345543211234554321UL); - ASSERT_EQ(5 + 10, ptr - buf); + EXPECT_EQ(5 + 10, ptr - buf); } const uint8_t* ptr = buf; const uint8_t* limit = ptr + 64; uint32_t val32; ptr = decode_varint32_ptr(ptr, limit, &val32); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(1234554321UL, val32); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(1234554321UL, val32); uint64_t val64; ptr = decode_varint64_ptr(ptr, limit, &val64); - ASSERT_NE(nullptr, ptr); - ASSERT_EQ(12345543211234554321UL, val64); + EXPECT_NE(nullptr, ptr); + EXPECT_EQ(12345543211234554321UL, val64); } TEST_F(CodingTest, variant_fail) { @@ -118,7 +118,7 @@ TEST_F(CodingTest, variant_fail) { const uint8_t* limit = ptr + 4; uint32_t val32; ptr = decode_varint32_ptr(ptr, limit, &val32); - ASSERT_EQ(nullptr, ptr); + EXPECT_EQ(nullptr, ptr); } { @@ -130,7 +130,7 @@ TEST_F(CodingTest, variant_fail) { const uint8_t* limit = ptr + 4; uint64_t val64; ptr = decode_varint64_ptr(ptr, limit, &val64); - ASSERT_EQ(nullptr, ptr); + EXPECT_EQ(nullptr, ptr); } } @@ -141,24 +141,19 @@ TEST_F(CodingTest, put_varint) { put_varint64(&val, 2); put_varint64_varint32(&val, 3, 4); - ASSERT_EQ(4, val.size()); + EXPECT_EQ(4, val.size()); const uint8_t* ptr = (const uint8_t*)val.data(); const uint8_t* limit = ptr + 4; uint32_t val32; uint64_t val64; ptr = decode_varint32_ptr(ptr, limit, &val32); - ASSERT_EQ(1, val32); + EXPECT_EQ(1, val32); ptr = decode_varint64_ptr(ptr, limit, &val64); - ASSERT_EQ(2, val64); + EXPECT_EQ(2, val64); ptr = decode_varint64_ptr(ptr, limit, &val64); - ASSERT_EQ(3, val64); + EXPECT_EQ(3, val64); ptr = decode_varint32_ptr(ptr, limit, &val32); - ASSERT_EQ(4, val32); + EXPECT_EQ(4, val32); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/core_local_test.cpp b/be/test/util/core_local_test.cpp index 4268fc0da0..9ffc72e1e4 100644 --- a/be/test/util/core_local_test.cpp +++ b/be/test/util/core_local_test.cpp @@ -23,9 +23,9 @@ #include #include "common/logging.h" +#include "testutil/test_util.h" #include "time.h" #include "util/stopwatch.hpp" -#include "test_util/test_util.h" namespace doris { @@ -64,7 +64,7 @@ TEST_F(CoreLocalTest, CoreLocalValue) { for (int i = 0; i < value.size(); ++i) { sum += __sync_fetch_and_add(value.access_at_core(i), 0); } - ASSERT_EQ(8 * loop, sum); + EXPECT_EQ(8 * loop, sum); LOG(INFO) << "time:" << sum_ns / sum << "ns/op"; } @@ -72,40 +72,40 @@ TEST_F(CoreLocalTest, CoreDataAllocator) { CoreDataAllocatorFactory factory; auto allocator1 = factory.get_allocator(1, 8); auto ptr = allocator1->get_or_create(0); - ASSERT_TRUE(ptr != nullptr); + EXPECT_TRUE(ptr != nullptr); { auto ptr2 = allocator1->get_or_create(0); - ASSERT_TRUE(ptr == ptr2); + EXPECT_TRUE(ptr == ptr2); } { auto ptr2 = allocator1->get_or_create(4096); - ASSERT_TRUE(ptr2 != nullptr); + EXPECT_TRUE(ptr2 != nullptr); } { auto allocator2 = factory.get_allocator(2, 8); - ASSERT_TRUE(allocator2 != allocator1); + EXPECT_TRUE(allocator2 != allocator1); } } TEST_F(CoreLocalTest, CoreLocalValueController) { CoreLocalValueController controller; auto id = controller.get_id(); - ASSERT_EQ(0, id); + EXPECT_EQ(0, id); controller.reclaim_id(id); id = controller.get_id(); - ASSERT_EQ(0, id); + EXPECT_EQ(0, id); id = controller.get_id(); - ASSERT_EQ(1, id); + EXPECT_EQ(1, id); } TEST_F(CoreLocalTest, CoreLocalValueNormal) { CoreLocalValue value; for (int i = 0; i < value.size(); ++i) { - ASSERT_EQ(0, *value.access_at_core(i)); + EXPECT_EQ(0, *value.access_at_core(i)); *value.access_at_core(i) += 1; } for (int i = 0; i < value.size(); ++i) { - ASSERT_EQ(1, *value.access_at_core(i)); + EXPECT_EQ(1, *value.access_at_core(i)); } for (int i = 0; i < 10000; ++i) { *value.access() += 1; @@ -114,11 +114,6 @@ TEST_F(CoreLocalTest, CoreLocalValueNormal) { for (int i = 0; i < value.size(); ++i) { sum += *value.access_at_core(i); } - ASSERT_EQ(10000 + value.size(), sum); + EXPECT_EQ(10000 + value.size(), sum); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/countdown_latch_test.cpp b/be/test/util/countdown_latch_test.cpp index 5edce70c8d..e4835bf7e3 100644 --- a/be/test/util/countdown_latch_test.cpp +++ b/be/test/util/countdown_latch_test.cpp @@ -40,21 +40,21 @@ static void decrement_latch(CountDownLatch* latch, int amount) { // as 1 by one. TEST(TestCountDownLatch, TestLatch) { std::unique_ptr pool; - ASSERT_TRUE(ThreadPoolBuilder("cdl-test").set_max_threads(1).build(&pool).ok()); + EXPECT_TRUE(ThreadPoolBuilder("cdl-test").set_max_threads(1).build(&pool).ok()); CountDownLatch latch(1000); // Decrement the count by 1 in another thread, this should not fire the // latch. - ASSERT_TRUE(pool->submit_func(std::bind(decrement_latch, &latch, 1)).ok()); - ASSERT_FALSE(latch.wait_for(MonoDelta::FromMilliseconds(200))); - ASSERT_EQ(999, latch.count()); + EXPECT_TRUE(pool->submit_func(std::bind(decrement_latch, &latch, 1)).ok()); + EXPECT_FALSE(latch.wait_for(MonoDelta::FromMilliseconds(200))); + EXPECT_EQ(999, latch.count()); // Now decrement by 1000 this should decrement to 0 and fire the latch // (even though 1000 is one more than the current count). - ASSERT_TRUE(pool->submit_func(std::bind(decrement_latch, &latch, 1000)).ok()); + EXPECT_TRUE(pool->submit_func(std::bind(decrement_latch, &latch, 1000)).ok()); latch.wait(); - ASSERT_EQ(0, latch.count()); + EXPECT_EQ(0, latch.count()); } // Test that resetting to zero while there are waiters lets the waiters @@ -62,7 +62,7 @@ TEST(TestCountDownLatch, TestLatch) { TEST(TestCountDownLatch, TestResetToZero) { CountDownLatch cdl(100); scoped_refptr t; - ASSERT_TRUE(Thread::create("test", "cdl-test", &CountDownLatch::wait, &cdl, &t).ok()); + EXPECT_TRUE(Thread::create("test", "cdl-test", &CountDownLatch::wait, &cdl, &t).ok()); // Sleep for a bit until it's likely the other thread is waiting on the latch. SleepFor(MonoDelta::FromMilliseconds(10)); @@ -71,8 +71,3 @@ TEST(TestCountDownLatch, TestResetToZero) { } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/counter_cond_variable_test.cpp b/be/test/util/counter_cond_variable_test.cpp index c988402348..a7947bd6f2 100644 --- a/be/test/util/counter_cond_variable_test.cpp +++ b/be/test/util/counter_cond_variable_test.cpp @@ -44,7 +44,7 @@ void worker() { for (int i = 0; i < 10; ++i) { { std::unique_lock lock(g_io_mu); - std::cout << "worker " << i << std::endl; + LOG(INFO) << "worker " << i; } usleep(100); g_cond.dec(); @@ -53,7 +53,7 @@ void worker() { void waiter() { g_cond.block_wait(); - std::cout << "wait finished" << std::endl; + LOG(INFO) << "wait finished"; } TEST_F(CounterCondVariableTest, test) { @@ -76,8 +76,3 @@ TEST_F(CounterCondVariableTest, test) { } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/counts_test.cpp b/be/test/util/counts_test.cpp index db020a6b0d..4f9d8d8235 100644 --- a/be/test/util/counts_test.cpp +++ b/be/test/util/counts_test.cpp @@ -18,7 +18,8 @@ #include "util/counts.h" #include -#include "test_util/test_util.h" + +#include "testutil/test_util.h" namespace doris { @@ -59,12 +60,7 @@ TEST_F(TCountsTest, TotalTest) { counts.merge(&other1); // 1 1 1 1 2 5 7 7 9 9 10 19 50 50 50 99 99 100 100 100 EXPECT_EQ(counts.terminate(0.3).val, 6.4); - delete [] writer; + delete[] writer; } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/crc32c_test.cpp b/be/test/util/crc32c_test.cpp index 6e95873ad0..a95b98412c 100644 --- a/be/test/util/crc32c_test.cpp +++ b/be/test/util/crc32c_test.cpp @@ -37,20 +37,20 @@ TEST(CRC, StandardResults) { char buf[32]; memset(buf, 0, sizeof(buf)); - ASSERT_EQ(0x8a9136aaU, Value(buf, sizeof(buf))); + EXPECT_EQ(0x8a9136aaU, Value(buf, sizeof(buf))); memset(buf, 0xff, sizeof(buf)); - ASSERT_EQ(0x62a8ab43U, Value(buf, sizeof(buf))); + EXPECT_EQ(0x62a8ab43U, Value(buf, sizeof(buf))); for (int i = 0; i < 32; i++) { buf[i] = static_cast(i); } - ASSERT_EQ(0x46dd794eU, Value(buf, sizeof(buf))); + EXPECT_EQ(0x46dd794eU, Value(buf, sizeof(buf))); for (int i = 0; i < 32; i++) { buf[i] = static_cast(31 - i); } - ASSERT_EQ(0x113fdb5cU, Value(buf, sizeof(buf))); + EXPECT_EQ(0x113fdb5cU, Value(buf, sizeof(buf))); unsigned char data[48] = { 0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -58,24 +58,19 @@ TEST(CRC, StandardResults) { 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; - ASSERT_EQ(0xd9963a56, Value(reinterpret_cast(data), sizeof(data))); + EXPECT_EQ(0xd9963a56, Value(reinterpret_cast(data), sizeof(data))); } TEST(CRC, Values) { - ASSERT_NE(Value("a", 1), Value("foo", 3)); + EXPECT_NE(Value("a", 1), Value("foo", 3)); } TEST(CRC, Extend) { - ASSERT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5)); + EXPECT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5)); std::vector slices = {Slice("hello "), Slice("world")}; - ASSERT_EQ(Value("hello world", 11), Value(slices)); + EXPECT_EQ(Value("hello world", 11), Value(slices)); } } // namespace crc32c } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/date_func_test.cpp b/be/test/util/date_func_test.cpp index 90b6aac470..bfbe6b6c53 100644 --- a/be/test/util/date_func_test.cpp +++ b/be/test/util/date_func_test.cpp @@ -16,7 +16,9 @@ // under the License. #include "util/date_func.h" + #include + #include namespace doris { @@ -29,56 +31,49 @@ public: TEST_F(DateFuncTest, convert_string_to_int) { uint64_t result1 = timestamp_from_datetime(std::string("2021-06-08 15:21:18")); - ASSERT_EQ(20210608152118, result1); + EXPECT_EQ(20210608152118, result1); uint64_t abnormal_result1 = timestamp_from_datetime(std::string("2021-22-08 15:21:18")); - ASSERT_EQ(14000101000000, abnormal_result1); + EXPECT_EQ(14000101000000, abnormal_result1); uint24_t result2 = timestamp_from_date(std::string("2021-09-08")); - ASSERT_EQ(std::string("2021-09-08"), result2.to_string()); + EXPECT_EQ(std::string("2021-09-08"), result2.to_string()); uint24_t abnormal_result2 = timestamp_from_date(std::string("2021-25-08")); - ASSERT_EQ(std::string("1400-01-01"), abnormal_result2.to_string()); + EXPECT_EQ(std::string("1400-01-01"), abnormal_result2.to_string()); } TEST_F(DateFuncTest, convert_double_to_string) { char buffer[100]; int len = time_to_buffer_from_double(211331.21212, buffer); - ASSERT_EQ(std::string("58:42:11"), std::string(buffer, len)); + EXPECT_EQ(std::string("58:42:11"), std::string(buffer, len)); len = time_to_buffer_from_double(-331.21212, buffer); - ASSERT_EQ(std::string("-00:05:31"), std::string(buffer, len)); + EXPECT_EQ(std::string("-00:05:31"), std::string(buffer, len)); len = time_to_buffer_from_double(-331, buffer); - ASSERT_EQ(std::string("-00:05:31"), std::string(buffer, len)); + EXPECT_EQ(std::string("-00:05:31"), std::string(buffer, len)); len = time_to_buffer_from_double(331, buffer); - ASSERT_EQ(std::string("00:05:31"), std::string(buffer, len)); + EXPECT_EQ(std::string("00:05:31"), std::string(buffer, len)); len = time_to_buffer_from_double(0, buffer); - ASSERT_EQ(std::string("00:00:00"), std::string(buffer, len)); + EXPECT_EQ(std::string("00:00:00"), std::string(buffer, len)); len = time_to_buffer_from_double(0.3131, buffer); - ASSERT_EQ(std::string("00:00:00"), std::string(buffer, len)); + EXPECT_EQ(std::string("00:00:00"), std::string(buffer, len)); len = time_to_buffer_from_double(13020399, buffer); - ASSERT_EQ(std::string("838:59:59"), std::string(buffer, len)); + EXPECT_EQ(std::string("838:59:59"), std::string(buffer, len)); len = time_to_buffer_from_double(-3020399, buffer); - ASSERT_EQ(std::string("-838:59:59"), std::string(buffer, len)); + EXPECT_EQ(std::string("-838:59:59"), std::string(buffer, len)); len = time_to_buffer_from_double(13020399, buffer); - ASSERT_EQ(std::string("838:59:59"), std::string(buffer, len)); + EXPECT_EQ(std::string("838:59:59"), std::string(buffer, len)); len = time_to_buffer_from_double(-13020399, buffer); - ASSERT_EQ(std::string("-838:59:59"), std::string(buffer, len)); - + EXPECT_EQ(std::string("-838:59:59"), std::string(buffer, len)); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} - diff --git a/be/test/util/decompress_test.cpp b/be/test/util/decompress_test.cpp index a9612e94a8..0e06a76ad8 100644 --- a/be/test/util/decompress_test.cpp +++ b/be/test/util/decompress_test.cpp @@ -105,14 +105,3 @@ TEST_F(DecompressorTest, SnappyBlocked) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/doris_metrics_test.cpp b/be/test/util/doris_metrics_test.cpp index 43058775ee..91df81602e 100644 --- a/be/test/util/doris_metrics_test.cpp +++ b/be/test/util/doris_metrics_test.cpp @@ -34,183 +34,176 @@ TEST_F(DorisMetricsTest, Normal) { auto server_entity = DorisMetrics::instance()->server_entity(); // check metric { + DorisMetrics::instance()->fragment_requests_total->reset(); DorisMetrics::instance()->fragment_requests_total->increment(12); auto metric = server_entity->get_metric("fragment_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("12", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("12", metric->to_string().c_str()); } { + DorisMetrics::instance()->fragment_request_duration_us->reset(); DorisMetrics::instance()->fragment_request_duration_us->increment(101); auto metric = server_entity->get_metric("fragment_request_duration_us"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("101", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("101", metric->to_string().c_str()); } { DorisMetrics::instance()->http_requests_total->increment(102); auto metric = server_entity->get_metric("http_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("102", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("102", metric->to_string().c_str()); } { DorisMetrics::instance()->http_request_send_bytes->increment(104); auto metric = server_entity->get_metric("http_request_send_bytes"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("104", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("104", metric->to_string().c_str()); } { DorisMetrics::instance()->query_scan_bytes->increment(104); auto metric = server_entity->get_metric("query_scan_bytes"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("104", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("104", metric->to_string().c_str()); } { DorisMetrics::instance()->query_scan_rows->increment(105); auto metric = server_entity->get_metric("query_scan_rows"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("105", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("105", metric->to_string().c_str()); } { DorisMetrics::instance()->push_requests_success_total->increment(106); auto metric = server_entity->get_metric("push_requests_success_total", "push_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("106", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("106", metric->to_string().c_str()); } { DorisMetrics::instance()->push_requests_fail_total->increment(107); auto metric = server_entity->get_metric("push_requests_fail_total", "push_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("107", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("107", metric->to_string().c_str()); } { DorisMetrics::instance()->push_request_duration_us->increment(108); auto metric = server_entity->get_metric("push_request_duration_us"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("108", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("108", metric->to_string().c_str()); } { DorisMetrics::instance()->push_request_write_bytes->increment(109); auto metric = server_entity->get_metric("push_request_write_bytes"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("109", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("109", metric->to_string().c_str()); } { DorisMetrics::instance()->push_request_write_rows->increment(110); auto metric = server_entity->get_metric("push_request_write_rows"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("110", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("110", metric->to_string().c_str()); } // engine request { + DorisMetrics::instance()->create_tablet_requests_total->reset(); DorisMetrics::instance()->create_tablet_requests_total->increment(15); auto metric = server_entity->get_metric("create_tablet_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("15", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("15", metric->to_string().c_str()); } { + DorisMetrics::instance()->drop_tablet_requests_total->reset(); DorisMetrics::instance()->drop_tablet_requests_total->increment(16); auto metric = server_entity->get_metric("drop_tablet_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("16", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("16", metric->to_string().c_str()); } { DorisMetrics::instance()->report_all_tablets_requests_total->increment(17); auto metric = server_entity->get_metric("report_all_tablets_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("17", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("17", metric->to_string().c_str()); } { DorisMetrics::instance()->report_all_tablets_requests_skip->increment(1); - auto metric = server_entity->get_metric("report_all_tablets_requests_skip", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("1", metric->to_string().c_str()); + auto metric = server_entity->get_metric("report_all_tablets_requests_skip", + "engine_requests_total"); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("1", metric->to_string().c_str()); } { DorisMetrics::instance()->report_tablet_requests_total->increment(18); auto metric = server_entity->get_metric("report_tablet_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("18", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("18", metric->to_string().c_str()); } { DorisMetrics::instance()->schema_change_requests_total->increment(19); auto metric = server_entity->get_metric("schema_change_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("19", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("19", metric->to_string().c_str()); } { DorisMetrics::instance()->create_rollup_requests_total->increment(20); auto metric = server_entity->get_metric("create_rollup_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("20", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("20", metric->to_string().c_str()); } { + DorisMetrics::instance()->storage_migrate_requests_total->reset(); DorisMetrics::instance()->storage_migrate_requests_total->increment(21); auto metric = server_entity->get_metric("storage_migrate_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("21", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("21", metric->to_string().c_str()); } { DorisMetrics::instance()->delete_requests_total->increment(22); auto metric = server_entity->get_metric("delete_requests_total", "engine_requests_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("22", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("22", metric->to_string().c_str()); } // compaction { DorisMetrics::instance()->base_compaction_deltas_total->increment(30); auto metric = server_entity->get_metric("base_compaction_deltas_total", "compaction_deltas_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("30", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("30", metric->to_string().c_str()); } { DorisMetrics::instance()->cumulative_compaction_deltas_total->increment(31); auto metric = server_entity->get_metric("cumulative_compaction_deltas_total", "compaction_deltas_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("31", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("31", metric->to_string().c_str()); } { DorisMetrics::instance()->base_compaction_bytes_total->increment(32); auto metric = server_entity->get_metric("base_compaction_bytes_total", "compaction_bytes_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("32", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("32", metric->to_string().c_str()); } { DorisMetrics::instance()->cumulative_compaction_bytes_total->increment(33); auto metric = server_entity->get_metric("cumulative_compaction_bytes_total", "compaction_bytes_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("33", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("33", metric->to_string().c_str()); } // Gauge { DorisMetrics::instance()->memory_pool_bytes_total->increment(40); auto metric = server_entity->get_metric("memory_pool_bytes_total"); - ASSERT_TRUE(metric != nullptr); - ASSERT_STREQ("40", metric->to_string().c_str()); + EXPECT_TRUE(metric != nullptr); + EXPECT_STREQ("40", metric->to_string().c_str()); } } } // namespace doris - -int main(int argc, char** argv) { -#if 0 - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); -#endif - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/easy_json-test.cpp b/be/test/util/easy_json-test.cpp index 9112d33bdd..60786757f0 100644 --- a/be/test/util/easy_json-test.cpp +++ b/be/test/util/easy_json-test.cpp @@ -35,7 +35,7 @@ class EasyJsonTest : public ::testing::Test {}; TEST_F(EasyJsonTest, TestNull) { EasyJson ej; - ASSERT_TRUE(ej.value().IsNull()); + EXPECT_TRUE(ej.value().IsNull()); } TEST_F(EasyJsonTest, TestBasic) { @@ -49,11 +49,11 @@ TEST_F(EasyJsonTest, TestBasic) { Value& v = ej.value(); - ASSERT_EQ(v["1"].GetBool(), true); - ASSERT_EQ(v["2"].GetInt(), kint32min); - ASSERT_EQ(v["4"].GetInt64(), kint64min); - ASSERT_EQ(v["6"].GetDouble(), 1.0); - ASSERT_EQ(string(v["7"].GetString()), "string"); + EXPECT_EQ(v["1"].GetBool(), true); + EXPECT_EQ(v["2"].GetInt(), kint32min); + EXPECT_EQ(v["4"].GetInt64(), kint64min); + EXPECT_EQ(v["6"].GetDouble(), 1.0); + EXPECT_EQ(string(v["7"].GetString()), "string"); } TEST_F(EasyJsonTest, TestNested) { @@ -61,37 +61,37 @@ TEST_F(EasyJsonTest, TestNested) { ej.SetObject(); ej.Get("nested").SetObject(); ej.Get("nested").Set("nested_attr", true); - ASSERT_EQ(ej.value()["nested"]["nested_attr"].GetBool(), true); + EXPECT_EQ(ej.value()["nested"]["nested_attr"].GetBool(), true); ej.Get("nested_array").SetArray(); ej.Get("nested_array").PushBack(1); ej.Get("nested_array").PushBack(2); - ASSERT_EQ(ej.value()["nested_array"][SizeType(0)].GetInt(), 1); - ASSERT_EQ(ej.value()["nested_array"][SizeType(1)].GetInt(), 2); + EXPECT_EQ(ej.value()["nested_array"][SizeType(0)].GetInt(), 1); + EXPECT_EQ(ej.value()["nested_array"][SizeType(1)].GetInt(), 2); } TEST_F(EasyJsonTest, TestCompactSyntax) { EasyJson ej; ej["nested"]["nested_attr"] = true; - ASSERT_EQ(ej.value()["nested"]["nested_attr"].GetBool(), true); + EXPECT_EQ(ej.value()["nested"]["nested_attr"].GetBool(), true); for (int i = 0; i < 2; i++) { ej["nested_array"][i] = i + 1; } - ASSERT_EQ(ej.value()["nested_array"][SizeType(0)].GetInt(), 1); - ASSERT_EQ(ej.value()["nested_array"][SizeType(1)].GetInt(), 2); + EXPECT_EQ(ej.value()["nested_array"][SizeType(0)].GetInt(), 1); + EXPECT_EQ(ej.value()["nested_array"][SizeType(1)].GetInt(), 2); } TEST_F(EasyJsonTest, TestComplexInitializer) { EasyJson ej; ej = EasyJson::kObject; - ASSERT_TRUE(ej.value().IsObject()); + EXPECT_TRUE(ej.value().IsObject()); EasyJson nested_arr = ej.Set("nested_arr", EasyJson::kArray); - ASSERT_TRUE(nested_arr.value().IsArray()); + EXPECT_TRUE(nested_arr.value().IsArray()); EasyJson nested_obj = nested_arr.PushBack(EasyJson::kObject); - ASSERT_TRUE(ej["nested_arr"][0].value().IsObject()); + EXPECT_TRUE(ej["nested_arr"][0].value().IsObject()); } TEST_F(EasyJsonTest, TestAllocatorLifetime) { @@ -100,11 +100,6 @@ TEST_F(EasyJsonTest, TestAllocatorLifetime) { delete root; child["child_attr"] = 1; - ASSERT_EQ(child.value()["child_attr"].GetInt(), 1); + EXPECT_EQ(child.value()["child_attr"].GetInt(), 1); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/encryption_util_test.cpp b/be/test/util/encryption_util_test.cpp index 2f30adee31..089bad2185 100644 --- a/be/test/util/encryption_util_test.cpp +++ b/be/test/util/encryption_util_test.cpp @@ -40,15 +40,15 @@ void do_aes_test(const std::string& source, const std::string& key) { int ret_code = EncryptionUtil::encrypt(AES_128_ECB, (unsigned char*)source.c_str(), source.length(), (unsigned char*)key.c_str(), key.length(), nullptr, true, dest.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); int encrypted_length = ret_code; std::unique_ptr decrypted(new char[cipher_len]); ret_code = EncryptionUtil::decrypt(AES_128_ECB, dest.get(), encrypted_length, (unsigned char*)key.c_str(), key.length(), nullptr, true, (unsigned char*)decrypted.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content(decrypted.get(), ret_code); - ASSERT_EQ(source, decrypted_content); + EXPECT_EQ(source, decrypted_content); } void do_sm4_test(const std::string& source, const std::string& key) { @@ -57,15 +57,15 @@ void do_sm4_test(const std::string& source, const std::string& key) { int ret_code = EncryptionUtil::encrypt(SM4_128_ECB, (unsigned char*)source.c_str(), source.length(), (unsigned char*)key.c_str(), key.length(), nullptr, true, dest.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); int encrypted_length = ret_code; std::unique_ptr decrypted(new char[cipher_len]); ret_code = EncryptionUtil::decrypt(SM4_128_ECB, dest.get(), encrypted_length, (unsigned char*)key.c_str(), key.length(), nullptr, true, (unsigned char*)decrypted.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content(decrypted.get(), ret_code); - ASSERT_EQ(source, decrypted_content); + EXPECT_EQ(source, decrypted_content); } TEST_F(EncryptionUtilTest, aes_test_basic) { @@ -94,9 +94,9 @@ TEST_F(EncryptionUtilTest, aes_test_by_case) { int ret_code = EncryptionUtil::decrypt(AES_128_ECB, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), nullptr, true, (unsigned char*)decrypted_1.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_1(decrypted_1.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_1); + EXPECT_EQ(source_1, decrypted_content_1); std::unique_ptr encrypt_2(new char[case_2.length()]); int length_2 = base64_decode(case_2.c_str(), case_2.length(), encrypt_2.get()); @@ -104,9 +104,9 @@ TEST_F(EncryptionUtilTest, aes_test_by_case) { ret_code = EncryptionUtil::decrypt(AES_128_ECB, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), nullptr, true, (unsigned char*)decrypted_2.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_2(decrypted_2.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_2); + EXPECT_EQ(source_2, decrypted_content_2); } TEST_F(EncryptionUtilTest, sm4_test_by_case) { @@ -121,9 +121,9 @@ TEST_F(EncryptionUtilTest, sm4_test_by_case) { int ret_code = EncryptionUtil::decrypt(SM4_128_ECB, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), nullptr, true, (unsigned char*)decrypted_1.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_1(decrypted_1.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_1); + EXPECT_EQ(source_1, decrypted_content_1); std::unique_ptr encrypt_2(new char[case_2.length()]); int length_2 = base64_decode(case_2.c_str(), case_2.length(), encrypt_2.get()); @@ -131,9 +131,9 @@ TEST_F(EncryptionUtilTest, sm4_test_by_case) { ret_code = EncryptionUtil::decrypt(SM4_128_ECB, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), nullptr, true, (unsigned char*)decrypted_2.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_2(decrypted_2.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_2); + EXPECT_EQ(source_2, decrypted_content_2); } TEST_F(EncryptionUtilTest, aes_with_iv_test_by_case) { @@ -149,17 +149,17 @@ TEST_F(EncryptionUtilTest, aes_with_iv_test_by_case) { int ret_code = EncryptionUtil::decrypt(AES_128_CBC, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_1.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_1(decrypted_1.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_1); + EXPECT_EQ(source_1, decrypted_content_1); std::unique_ptr decrypted_11(new char[case_1.length()]); ret_code = EncryptionUtil::decrypt(AES_128_CBC, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_11.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_11(decrypted_11.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_11); + EXPECT_EQ(source_1, decrypted_content_11); std::unique_ptr encrypt_2(new char[case_2.length()]); int length_2 = base64_decode(case_2.c_str(), case_2.length(), encrypt_2.get()); @@ -167,17 +167,17 @@ TEST_F(EncryptionUtilTest, aes_with_iv_test_by_case) { ret_code = EncryptionUtil::decrypt(AES_128_CBC, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_2.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_2(decrypted_2.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_2); + EXPECT_EQ(source_2, decrypted_content_2); std::unique_ptr decrypted_21(new char[case_2.length()]); ret_code = EncryptionUtil::decrypt(AES_128_CBC, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_21.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_21(decrypted_21.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_21); + EXPECT_EQ(source_2, decrypted_content_21); } TEST_F(EncryptionUtilTest, sm4_with_iv_test_by_case) { @@ -195,9 +195,9 @@ TEST_F(EncryptionUtilTest, sm4_with_iv_test_by_case) { int ret_code = EncryptionUtil::decrypt(SM4_128_CBC, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_1.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_1(decrypted_1.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_1); + EXPECT_EQ(source_1, decrypted_content_1); std::unique_ptr encrypt_2(new char[case_2.length()]); int length_2 = base64_decode(case_2.c_str(), case_2.length(), encrypt_2.get()); @@ -207,28 +207,23 @@ TEST_F(EncryptionUtilTest, sm4_with_iv_test_by_case) { ret_code = EncryptionUtil::decrypt(SM4_128_CBC, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_2.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_2(decrypted_2.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_2); + EXPECT_EQ(source_2, decrypted_content_2); ret_code = EncryptionUtil::decrypt(SM4_128_CBC, (unsigned char*)encrypt_1.get(), length_1, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_11.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_11(decrypted_11.get(), ret_code); - ASSERT_EQ(source_1, decrypted_content_11); + EXPECT_EQ(source_1, decrypted_content_11); ret_code = EncryptionUtil::decrypt(SM4_128_CBC, (unsigned char*)encrypt_2.get(), length_2, (unsigned char*)_aes_key.c_str(), _aes_key.length(), iv.c_str(), true, (unsigned char*)decrypted_21.get()); - ASSERT_TRUE(ret_code > 0); + EXPECT_TRUE(ret_code > 0); std::string decrypted_content_21(decrypted_21.get(), ret_code); - ASSERT_EQ(source_2, decrypted_content_21); + EXPECT_EQ(source_2, decrypted_content_21); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/faststring_test.cpp b/be/test/util/faststring_test.cpp index c51d8995dd..6aa4bc9343 100644 --- a/be/test/util/faststring_test.cpp +++ b/be/test/util/faststring_test.cpp @@ -46,7 +46,7 @@ void RandomString(void* dest, size_t n, doris::Random* rng) { TEST_F(FaststringTest, TestShrinkToFit_Empty) { faststring s; s.shrink_to_fit(); - ASSERT_EQ(faststring::kInitialCapacity, s.capacity()); + EXPECT_EQ(faststring::kInitialCapacity, s.capacity()); } // Test that, if the string contents is shorter than the initial capacity @@ -56,7 +56,7 @@ TEST_F(FaststringTest, TestShrinkToFit_SmallerThanInitialCapacity) { faststring s; s.append("hello"); s.shrink_to_fit(); - ASSERT_EQ(faststring::kInitialCapacity, s.capacity()); + EXPECT_EQ(faststring::kInitialCapacity, s.capacity()); } TEST_F(FaststringTest, TestShrinkToFit_Random) { @@ -71,8 +71,8 @@ TEST_F(FaststringTest, TestShrinkToFit_Random) { s.resize(new_size); memcpy(s.data(), random_bytes.get(), new_size); s.shrink_to_fit(); - ASSERT_EQ(0, memcmp(s.data(), random_bytes.get(), new_size)); - ASSERT_EQ(std::max(faststring::kInitialCapacity, new_size), s.capacity()); + EXPECT_EQ(0, memcmp(s.data(), random_bytes.get(), new_size)); + EXPECT_EQ(std::max(faststring::kInitialCapacity, new_size), s.capacity()); } } @@ -80,34 +80,34 @@ TEST_F(FaststringTest, TestPushBack) { faststring s; for (int i = 0; i < faststring::kInitialCapacity * 2; ++i) { s.push_back('a'); - ASSERT_LE(s.size(), s.capacity()); - ASSERT_EQ(i + 1, s.size()); + EXPECT_LE(s.size(), s.capacity()); + EXPECT_EQ(i + 1, s.size()); if (i + 1 <= faststring::kInitialCapacity) { - ASSERT_EQ(s.capacity(), faststring::kInitialCapacity); + EXPECT_EQ(s.capacity(), faststring::kInitialCapacity); } } } TEST_F(FaststringTest, TestAppend_Simple) { faststring s; - ASSERT_EQ(s.capacity(), faststring::kInitialCapacity); - ASSERT_EQ(s.size(), 0); + EXPECT_EQ(s.capacity(), faststring::kInitialCapacity); + EXPECT_EQ(s.size(), 0); // append empty string s.append(""); - ASSERT_EQ(s.capacity(), faststring::kInitialCapacity); - ASSERT_EQ(s.size(), 0); + EXPECT_EQ(s.capacity(), faststring::kInitialCapacity); + EXPECT_EQ(s.size(), 0); // len_ < kInitialCapacity s.append("hello"); - ASSERT_EQ(s.capacity(), faststring::kInitialCapacity); - ASSERT_EQ(s.size(), 5); + EXPECT_EQ(s.capacity(), faststring::kInitialCapacity); + EXPECT_EQ(s.size(), 5); // len_ > kInitialCapacity std::string tmp(faststring::kInitialCapacity, 'a'); s.append(tmp); - ASSERT_GT(s.capacity(), faststring::kInitialCapacity); - ASSERT_EQ(s.size(), 5 + faststring::kInitialCapacity); + EXPECT_GT(s.capacity(), faststring::kInitialCapacity); + EXPECT_EQ(s.size(), 5 + faststring::kInitialCapacity); } TEST_F(FaststringTest, TestAppend_ExponentiallyExpand) { @@ -120,7 +120,7 @@ TEST_F(FaststringTest, TestAppend_ExponentiallyExpand) { std::string tmp2(faststring::kInitialCapacity - 1, 'a'); s.append(tmp1); s.append(tmp2); - ASSERT_EQ(s.capacity(), faststring::kInitialCapacity * 3 / 2); + EXPECT_EQ(s.capacity(), faststring::kInitialCapacity * 3 / 2); } { @@ -129,13 +129,8 @@ TEST_F(FaststringTest, TestAppend_ExponentiallyExpand) { std::string tmp2(faststring::kInitialCapacity + 1, 'a'); s.append(tmp1); s.append(tmp2); - ASSERT_GT(s.capacity(), faststring::kInitialCapacity * 3 / 2); + EXPECT_GT(s.capacity(), faststring::kInitialCapacity * 3 / 2); } } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/file_cache_test.cpp b/be/test/util/file_cache_test.cpp index 2d81cd6005..4b97015dae 100644 --- a/be/test/util/file_cache_test.cpp +++ b/be/test/util/file_cache_test.cpp @@ -32,15 +32,15 @@ public: _file_exist = "file_exist"; std::unique_ptr file; auto st = Env::Default()->new_writable_file(_file_exist, &file); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); st = file->close(); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } void TearDown() override { _file_cache.reset(nullptr); auto st = Env::Default()->delete_file(_file_exist); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); } private: @@ -51,21 +51,16 @@ private: TEST_F(FileCacheTest, normal) { OpenedFileHandle file_handle; auto found = _file_cache->lookup(_file_exist, &file_handle); - ASSERT_FALSE(found); + EXPECT_FALSE(found); std::unique_ptr file; auto st = Env::Default()->new_random_access_file(_file_exist, &file); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); RandomAccessFile* tmp_file = file.release(); _file_cache->insert(_file_exist, tmp_file, &file_handle); - ASSERT_EQ(tmp_file, file_handle.file()); + EXPECT_EQ(tmp_file, file_handle.file()); OpenedFileHandle file_handle2; found = _file_cache->lookup(_file_exist, &file_handle2); - ASSERT_EQ(file_handle.file(), file_handle2.file()); + EXPECT_EQ(file_handle.file(), file_handle2.file()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/filesystem_util_test.cpp b/be/test/util/filesystem_util_test.cpp index acafebc9a1..e69163ab56 100644 --- a/be/test/util/filesystem_util_test.cpp +++ b/be/test/util/filesystem_util_test.cpp @@ -31,14 +31,14 @@ namespace filesystem = std::filesystem; using filesystem::path; TEST(FileSystemUtil, rlimit) { - ASSERT_LT(0ul, FileSystemUtil::max_num_file_handles()); + EXPECT_LT(0ul, FileSystemUtil::max_num_file_handles()); } TEST(FileSystemUtil, CreateDirectory) { char filename[] = "temp-XXXXXX"; // Setup a temporary directory with one subdir std::string dir_name = mkdtemp(filename); - path dir{dir_name}; + path dir {dir_name}; path subdir1 = dir / "path1"; path subdir2 = dir / "path2"; path subdir3 = dir / "a" / "longer" / "path"; @@ -129,8 +129,3 @@ TEST(FilesystemUtil, contain_path) { } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/frame_of_reference_coding_test.cpp b/be/test/util/frame_of_reference_coding_test.cpp index e8aa3f4427..6aaee9c191 100644 --- a/be/test/util/frame_of_reference_coding_test.cpp +++ b/be/test/util/frame_of_reference_coding_test.cpp @@ -38,7 +38,7 @@ public: std::vector actual_result(element_size); decoder.get_batch(actual_result.data(), element_size); - ASSERT_EQ(data, actual_result); + EXPECT_EQ(data, actual_result); } static void test_skip(int32_t skip_num) { @@ -63,7 +63,7 @@ public: std::vector actual_result(256 - skip_num); decoder.get_batch(actual_result.data(), 256 - skip_num); - ASSERT_EQ(expect_result, actual_result); + EXPECT_EQ(expect_result, actual_result); } }; @@ -111,7 +111,7 @@ TEST_F(TestForCoding, TestInt64) { std::vector actual_result(320); decoder.get_batch(actual_result.data(), 320); - ASSERT_EQ(data, actual_result); + EXPECT_EQ(data, actual_result); } TEST_F(TestForCoding, TestOneMinValue) { @@ -124,7 +124,7 @@ TEST_F(TestForCoding, TestOneMinValue) { decoder.init(); int32_t actual_value; decoder.get(&actual_value); - ASSERT_EQ(2019, actual_value); + EXPECT_EQ(2019, actual_value); } TEST_F(TestForCoding, TestZeroValue) { @@ -132,13 +132,13 @@ TEST_F(TestForCoding, TestZeroValue) { ForEncoder encoder(&buffer); encoder.flush(); - ASSERT_EQ(buffer.length(), 4 + 1); + EXPECT_EQ(buffer.length(), 4 + 1); ForDecoder decoder(buffer.data(), buffer.length()); decoder.init(); int32_t actual_value; bool result = decoder.get(&actual_value); - ASSERT_EQ(result, false); + EXPECT_EQ(result, false); } TEST_F(TestForCoding, TestBytesAlign) { @@ -153,9 +153,9 @@ TEST_F(TestForCoding, TestBytesAlign) { int32_t actual_value; decoder.get(&actual_value); - ASSERT_EQ(2019, actual_value); + EXPECT_EQ(2019, actual_value); decoder.get(&actual_value); - ASSERT_EQ(2020, actual_value); + EXPECT_EQ(2020, actual_value); } TEST_F(TestForCoding, TestValueSeekSpecialCase) { @@ -180,12 +180,12 @@ TEST_F(TestForCoding, TestValueSeekSpecialCase) { int64_t target = 160; bool exact_match; bool has_value = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(has_value, true); - ASSERT_EQ(exact_match, false); + EXPECT_EQ(has_value, true); + EXPECT_EQ(exact_match, false); int64_t next_value; decoder.get(&next_value); - ASSERT_EQ(300, next_value); + EXPECT_EQ(300, next_value); } TEST_F(TestForCoding, TestValueSeek) { @@ -206,46 +206,41 @@ TEST_F(TestForCoding, TestValueSeek) { int64_t target = 160; bool exact_match; bool found = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(found, true); - ASSERT_EQ(exact_match, true); + EXPECT_EQ(found, true); + EXPECT_EQ(exact_match, true); int64_t actual_value; decoder.get(&actual_value); - ASSERT_EQ(target, actual_value); + EXPECT_EQ(target, actual_value); target = -1; found = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(found, true); - ASSERT_EQ(exact_match, false); + EXPECT_EQ(found, true); + EXPECT_EQ(exact_match, false); std::vector actual_result(SIZE); decoder.get_batch(actual_result.data(), SIZE); - ASSERT_EQ(data, actual_result); + EXPECT_EQ(data, actual_result); target = 0; found = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(found, true); - ASSERT_EQ(exact_match, true); + EXPECT_EQ(found, true); + EXPECT_EQ(exact_match, true); decoder.get_batch(actual_result.data(), SIZE); - ASSERT_EQ(data, actual_result); + EXPECT_EQ(data, actual_result); target = 319; found = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(found, true); - ASSERT_EQ(exact_match, true); + EXPECT_EQ(found, true); + EXPECT_EQ(exact_match, true); decoder.get(&actual_value); - ASSERT_EQ(target, actual_value); + EXPECT_EQ(target, actual_value); target = 320; found = decoder.seek_at_or_after_value(&target, &exact_match); - ASSERT_EQ(found, false); + EXPECT_EQ(found, false); } } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/util/histogram_test.cpp b/be/test/util/histogram_test.cpp index b883ca7a92..1ff77204b7 100644 --- a/be/test/util/histogram_test.cpp +++ b/be/test/util/histogram_test.cpp @@ -17,9 +17,10 @@ #include "util/histogram.h" -#include #include +#include + namespace doris { class HistogramTest : public testing::Test { @@ -29,12 +30,11 @@ public: }; namespace { - const HistogramBucketMapper bucket_mapper; - const double delta = 0.1; -} +const HistogramBucketMapper bucket_mapper; +const double delta = 0.1; +} // namespace -void populate_histogram(HistogramStat& hist, uint64_t low, - uint64_t high, uint64_t loop = 1) { +void populate_histogram(HistogramStat& hist, uint64_t low, uint64_t high, uint64_t loop = 1) { for (; loop > 0; loop--) { for (uint64_t i = low; i <= high; i++) { hist.add(i); @@ -44,15 +44,15 @@ void populate_histogram(HistogramStat& hist, uint64_t low, TEST_F(HistogramTest, Normal) { HistogramStat hist; - ASSERT_TRUE(hist.is_empty()); + EXPECT_TRUE(hist.is_empty()); populate_histogram(hist, 1, 110, 10); - ASSERT_EQ(hist.num(), 1100); + EXPECT_EQ(hist.num(), 1100); - ASSERT_LE(fabs(hist.percentile(100.0) - 110.0), delta); - ASSERT_LE(fabs(hist.percentile(99.0) - 108.9), delta); - ASSERT_LE(fabs(hist.percentile(95.0) - 104.5), delta); - ASSERT_LE(fabs(hist.median() - 55.0), delta); - ASSERT_EQ(hist.average(), 55.5); + EXPECT_LE(fabs(hist.percentile(100.0) - 110.0), delta); + EXPECT_LE(fabs(hist.percentile(99.0) - 108.9), delta); + EXPECT_LE(fabs(hist.percentile(95.0) - 104.5), delta); + EXPECT_LE(fabs(hist.median() - 55.0), delta); + EXPECT_EQ(hist.average(), 55.5); } TEST_F(HistogramTest, Merge) { @@ -63,22 +63,22 @@ TEST_F(HistogramTest, Merge) { populate_histogram(other, 101, 250); hist.merge(other); - ASSERT_LE(fabs(hist.percentile(100.0) - 250.0), delta); - ASSERT_LE(fabs(hist.percentile(99.0) - 247.5), delta); - ASSERT_LE(fabs(hist.percentile(95.0) - 237.5), delta); - ASSERT_LE(fabs(hist.median() - 125.0), delta); - ASSERT_EQ(hist.average(), 125.5); + EXPECT_LE(fabs(hist.percentile(100.0) - 250.0), delta); + EXPECT_LE(fabs(hist.percentile(99.0) - 247.5), delta); + EXPECT_LE(fabs(hist.percentile(95.0) - 237.5), delta); + EXPECT_LE(fabs(hist.median() - 125.0), delta); + EXPECT_EQ(hist.average(), 125.5); } TEST_F(HistogramTest, Empty) { HistogramStat hist; - ASSERT_EQ(hist.min(), bucket_mapper.last_value()); - ASSERT_EQ(hist.max(), 0); - ASSERT_EQ(hist.num(), 0); - ASSERT_EQ(hist.median(), 0.0); - ASSERT_EQ(hist.percentile(85.0), 0.0); - ASSERT_EQ(hist.average(), 0.0); - ASSERT_EQ(hist.standard_deviation(), 0.0); + EXPECT_EQ(hist.min(), bucket_mapper.last_value()); + EXPECT_EQ(hist.max(), 0); + EXPECT_EQ(hist.num(), 0); + EXPECT_EQ(hist.median(), 0.0); + EXPECT_EQ(hist.percentile(85.0), 0.0); + EXPECT_EQ(hist.average(), 0.0); + EXPECT_EQ(hist.standard_deviation(), 0.0); } TEST_F(HistogramTest, Clear) { @@ -86,15 +86,10 @@ TEST_F(HistogramTest, Clear) { populate_histogram(hist, 1, 100); hist.clear(); - ASSERT_TRUE(hist.is_empty()); - ASSERT_EQ(hist.median(), 0); - ASSERT_EQ(hist.percentile(85.0), 0.0); - ASSERT_EQ(hist.average(), 0.0); + EXPECT_TRUE(hist.is_empty()); + EXPECT_EQ(hist.median(), 0); + EXPECT_EQ(hist.percentile(85.0), 0.0); + EXPECT_EQ(hist.average(), 0.0); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/http_channel_test.cpp b/be/test/util/http_channel_test.cpp index f18e4b24e0..3c3ae12edd 100644 --- a/be/test/util/http_channel_test.cpp +++ b/be/test/util/http_channel_test.cpp @@ -28,30 +28,24 @@ class HttpChannelTest : public testing::Test { public: void check_data_eq(const std::string& output, const std::string& expected) { std::ostringstream oss; - ASSERT_TRUE(zlib::Uncompress(Slice(output), &oss).ok()); - ASSERT_EQ(expected, oss.str()); + EXPECT_TRUE(zlib::Uncompress(Slice(output), &oss).ok()); + EXPECT_EQ(expected, oss.str()); } }; TEST_F(HttpChannelTest, CompressContent) { - ASSERT_FALSE(HttpChannel::compress_content("gzip", "", nullptr)); - ASSERT_FALSE(HttpChannel::compress_content("", "test", nullptr)); - ASSERT_FALSE(HttpChannel::compress_content("Gzip", "", nullptr)); + EXPECT_FALSE(HttpChannel::compress_content("gzip", "", nullptr)); + EXPECT_FALSE(HttpChannel::compress_content("", "test", nullptr)); + EXPECT_FALSE(HttpChannel::compress_content("Gzip", "", nullptr)); const std::string& intput("test_data_0123456789abcdefg"); std::string output; - ASSERT_TRUE(HttpChannel::compress_content("gzip", intput, &output)); - ASSERT_NO_FATAL_FAILURE(check_data_eq(output, intput)); + EXPECT_TRUE(HttpChannel::compress_content("gzip", intput, &output)); + EXPECT_NO_FATAL_FAILURE(check_data_eq(output, intput)); - ASSERT_TRUE(HttpChannel::compress_content("123,gzip,321", intput, &output)); - ASSERT_NO_FATAL_FAILURE(check_data_eq(output, intput)); + EXPECT_TRUE(HttpChannel::compress_content("123,gzip,321", intput, &output)); + EXPECT_NO_FATAL_FAILURE(check_data_eq(output, intput)); } } // namespace doris - -int main(int argc, char** argv) { - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/internal_queue_test.cpp b/be/test/util/internal_queue_test.cpp index e5ca36e782..5949560ac9 100644 --- a/be/test/util/internal_queue_test.cpp +++ b/be/test/util/internal_queue_test.cpp @@ -24,7 +24,7 @@ #include #include "common/configbase.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/logging.h" #include "util/thread_group.h" @@ -309,14 +309,3 @@ TEST(InternalQueue, TestMultiProducerMultiConsumer) { } } // end namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/json_util_test.cpp b/be/test/util/json_util_test.cpp index 90206f2852..94b370377d 100644 --- a/be/test/util/json_util_test.cpp +++ b/be/test/util/json_util_test.cpp @@ -38,7 +38,7 @@ TEST_F(JsonUtilTest, success) { "{\n" " \"status\": \"Success\",\n" " \"msg\": \"OK\"\n}"; - ASSERT_STREQ(result, str.c_str()); + EXPECT_STREQ(result, str.c_str()); } TEST_F(JsonUtilTest, normal_fail) { @@ -50,7 +50,7 @@ TEST_F(JsonUtilTest, normal_fail) { "{\n" " \"status\": \"Fail\",\n" " \"msg\": \"so bad\"\n}"; - ASSERT_STREQ(result, str.c_str()); + EXPECT_STREQ(result, str.c_str()); } TEST_F(JsonUtilTest, normal_fail_str) { @@ -64,12 +64,7 @@ TEST_F(JsonUtilTest, normal_fail_str) { " \"status\": \"Fail\",\n" " \"msg\": \"\\\"so bad\\\"\"\n}"; LOG(INFO) << "str: " << str; - ASSERT_STREQ(result, str.c_str()); + EXPECT_STREQ(result, str.c_str()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/lru_cache_util_test.cpp b/be/test/util/lru_cache_util_test.cpp index 8c2d214641..98d7246b33 100644 --- a/be/test/util/lru_cache_util_test.cpp +++ b/be/test/util/lru_cache_util_test.cpp @@ -38,12 +38,12 @@ TEST_F(LruCacheTest, NormalTest) { for (int i = 0; i < 10; ++i) { cache.put(i, std::shared_ptr(new Foo(i * 10))); } - ASSERT_EQ(10, cache.size()); + EXPECT_EQ(10, cache.size()); std::shared_ptr ptr; for (int i = 0; i < 10; ++i) { - ASSERT_TRUE(cache.get(i, &ptr)); - ASSERT_EQ(i * 10, ptr->num); + EXPECT_TRUE(cache.get(i, &ptr)); + EXPECT_EQ(i * 10, ptr->num); } } @@ -57,7 +57,7 @@ TEST_F(LruCacheTest, IteratorTest) { values += i * 10; cache.put(i, std::shared_ptr(new Foo(i * 10))); } - ASSERT_EQ(10, cache.size()); + EXPECT_EQ(10, cache.size()); int key_sum = 0; int value_sum = 0; @@ -65,13 +65,13 @@ TEST_F(LruCacheTest, IteratorTest) { key_sum += it.first; value_sum += it.second->num; } - ASSERT_EQ(keys, key_sum); - ASSERT_EQ(values, value_sum); + EXPECT_EQ(keys, key_sum); + EXPECT_EQ(values, value_sum); std::shared_ptr ptr; for (int i = 0; i < 10; ++i) { - ASSERT_TRUE(cache.get(i, &ptr)); - ASSERT_EQ(i * 10, ptr->num); + EXPECT_TRUE(cache.get(i, &ptr)); + EXPECT_EQ(i * 10, ptr->num); } } @@ -81,24 +81,13 @@ TEST_F(LruCacheTest, OverSize) { for (int i = 0; i < 110; ++i) { cache.put(i, std::shared_ptr(new Foo(i * 10))); } - ASSERT_EQ(10, cache.size()); + EXPECT_EQ(10, cache.size()); std::shared_ptr ptr; for (int i = 100; i < 110; ++i) { - ASSERT_TRUE(cache.get(i, &ptr)); - ASSERT_EQ(i * 10, ptr->num); + EXPECT_TRUE(cache.get(i, &ptr)); + EXPECT_EQ(i * 10, ptr->num); } } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/md5_test.cpp b/be/test/util/md5_test.cpp index aa2cd89e7b..03bcfd5f74 100644 --- a/be/test/util/md5_test.cpp +++ b/be/test/util/md5_test.cpp @@ -30,19 +30,14 @@ public: TEST_F(Md5Test, empty) { Md5Digest digest; digest.digest(); - ASSERT_STREQ("d41d8cd98f00b204e9800998ecf8427e", digest.hex().c_str()); + EXPECT_STREQ("d41d8cd98f00b204e9800998ecf8427e", digest.hex().c_str()); } TEST_F(Md5Test, normal) { Md5Digest digest; digest.update("abcdefg", 7); digest.digest(); - ASSERT_STREQ("7ac66c0f148de9519b8bd264312c4d64", digest.hex().c_str()); + EXPECT_STREQ("7ac66c0f148de9519b8bd264312c4d64", digest.hex().c_str()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/new_metrics_test.cpp b/be/test/util/metrics_test.cpp similarity index 80% rename from be/test/util/new_metrics_test.cpp rename to be/test/util/metrics_test.cpp index d30c803f09..68470c84fb 100644 --- a/be/test/util/new_metrics_test.cpp +++ b/be/test/util/metrics_test.cpp @@ -15,15 +15,16 @@ // specific language governing permissions and limitations // under the License. +#include "util/metrics.h" + #include #include #include #include "common/config.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/logging.h" -#include "util/metrics.h" #include "util/stopwatch.hpp" namespace doris { @@ -37,35 +38,35 @@ public: TEST_F(MetricsTest, Counter) { { IntCounter counter; - ASSERT_EQ(0, counter.value()); + EXPECT_EQ(0, counter.value()); counter.increment(100); - ASSERT_EQ(100, counter.value()); + EXPECT_EQ(100, counter.value()); - ASSERT_STREQ("100", counter.to_string().c_str()); + EXPECT_STREQ("100", counter.to_string().c_str()); } { IntAtomicCounter counter; - ASSERT_EQ(0, counter.value()); + EXPECT_EQ(0, counter.value()); counter.increment(100); - ASSERT_EQ(100, counter.value()); + EXPECT_EQ(100, counter.value()); - ASSERT_STREQ("100", counter.to_string().c_str()); + EXPECT_STREQ("100", counter.to_string().c_str()); } { UIntCounter counter; - ASSERT_EQ(0, counter.value()); + EXPECT_EQ(0, counter.value()); counter.increment(100); - ASSERT_EQ(100, counter.value()); + EXPECT_EQ(100, counter.value()); - ASSERT_STREQ("100", counter.to_string().c_str()); + EXPECT_STREQ("100", counter.to_string().c_str()); } { DoubleCounter counter; - ASSERT_EQ(0, counter.value()); + EXPECT_EQ(0, counter.value()); counter.increment(1.23); - ASSERT_EQ(1.23, counter.value()); + EXPECT_EQ(1.23, counter.value()); - ASSERT_STREQ("1.230000", counter.to_string().c_str()); + EXPECT_STREQ("1.230000", counter.to_string().c_str()); } } @@ -93,7 +94,7 @@ TEST_F(MetricsTest, CounterPerf) { sum += 1; } uint64_t elapsed = watch.elapsed_time(); - ASSERT_EQ(kLoopCount, sum); + EXPECT_EQ(kLoopCount, sum); LOG(INFO) << "int64_t: elapsed: " << elapsed << "ns, ns/iter:" << elapsed / kLoopCount; } // IntAtomicCounter @@ -105,7 +106,7 @@ TEST_F(MetricsTest, CounterPerf) { counter.increment(1); } uint64_t elapsed = watch.elapsed_time(); - ASSERT_EQ(kLoopCount, counter.value()); + EXPECT_EQ(kLoopCount, counter.value()); LOG(INFO) << "IntAtomicCounter: elapsed: " << elapsed << "ns, ns/iter:" << elapsed / kLoopCount; } @@ -118,7 +119,7 @@ TEST_F(MetricsTest, CounterPerf) { counter.increment(1); } uint64_t elapsed = watch.elapsed_time(); - ASSERT_EQ(kLoopCount, counter.value()); + EXPECT_EQ(kLoopCount, counter.value()); LOG(INFO) << "IntCounter: elapsed: " << elapsed << "ns, ns/iter:" << elapsed / kLoopCount; } @@ -136,7 +137,7 @@ TEST_F(MetricsTest, CounterPerf) { } LOG(INFO) << "IntCounter multi-thread elapsed: " << used_time.load() << "ns, ns/iter:" << used_time.load() / (8 * kThreadLoopCount); - ASSERT_EQ(8 * kThreadLoopCount, mt_counter.value()); + EXPECT_EQ(8 * kThreadLoopCount, mt_counter.value()); } // multi-thread for IntAtomicCounter { @@ -152,7 +153,7 @@ TEST_F(MetricsTest, CounterPerf) { } LOG(INFO) << "IntAtomicCounter multi-thread elapsed: " << used_time.load() << "ns, ns/iter:" << used_time.load() / (8 * kThreadLoopCount); - ASSERT_EQ(8 * kThreadLoopCount, mt_counter.value()); + EXPECT_EQ(8 * kThreadLoopCount, mt_counter.value()); } } @@ -160,29 +161,29 @@ TEST_F(MetricsTest, Gauge) { // IntGauge { IntGauge gauge; - ASSERT_EQ(0, gauge.value()); + EXPECT_EQ(0, gauge.value()); gauge.set_value(100); - ASSERT_EQ(100, gauge.value()); + EXPECT_EQ(100, gauge.value()); - ASSERT_STREQ("100", gauge.to_string().c_str()); + EXPECT_STREQ("100", gauge.to_string().c_str()); } // UIntGauge { UIntGauge gauge; - ASSERT_EQ(0, gauge.value()); + EXPECT_EQ(0, gauge.value()); gauge.set_value(100); - ASSERT_EQ(100, gauge.value()); + EXPECT_EQ(100, gauge.value()); - ASSERT_STREQ("100", gauge.to_string().c_str()); + EXPECT_STREQ("100", gauge.to_string().c_str()); } // DoubleGauge { DoubleGauge gauge; - ASSERT_EQ(0.0, gauge.value()); + EXPECT_EQ(0.0, gauge.value()); gauge.set_value(1.23); - ASSERT_EQ(1.23, gauge.value()); + EXPECT_EQ(1.23, gauge.value()); - ASSERT_STREQ("1.230000", gauge.to_string().c_str()); + EXPECT_STREQ("1.230000", gauge.to_string().c_str()); } } @@ -192,17 +193,17 @@ TEST_F(MetricsTest, MetricPrototype) { "fragment_requests_total", "Total fragment requests received."); - ASSERT_EQ("fragment_requests_total", cpu_idle_type.simple_name()); - ASSERT_EQ("fragment_requests_total", cpu_idle_type.combine_name("")); - ASSERT_EQ("doris_be_fragment_requests_total", cpu_idle_type.combine_name("doris_be")); + EXPECT_EQ("fragment_requests_total", cpu_idle_type.simple_name()); + EXPECT_EQ("fragment_requests_total", cpu_idle_type.combine_name("")); + EXPECT_EQ("doris_be_fragment_requests_total", cpu_idle_type.combine_name("doris_be")); } { MetricPrototype cpu_idle_type(MetricType::COUNTER, MetricUnit::PERCENT, "cpu_idle", "CPU's idle time percent", "cpu"); - ASSERT_EQ("cpu", cpu_idle_type.simple_name()); - ASSERT_EQ("cpu", cpu_idle_type.combine_name("")); - ASSERT_EQ("doris_be_cpu", cpu_idle_type.combine_name("doris_be")); + EXPECT_EQ("cpu", cpu_idle_type.simple_name()); + EXPECT_EQ("cpu", cpu_idle_type.combine_name("")); + EXPECT_EQ("doris_be_cpu", cpu_idle_type.combine_name("doris_be")); } } @@ -213,25 +214,25 @@ TEST_F(MetricsTest, MetricEntityWithMetric) { // Before register Metric* metric = entity.get_metric("cpu_idle"); - ASSERT_EQ(nullptr, metric); + EXPECT_EQ(nullptr, metric); // Register IntCounter* cpu_idle = (IntCounter*)entity.register_metric(&cpu_idle_type); cpu_idle->increment(12); metric = entity.get_metric("cpu_idle"); - ASSERT_NE(nullptr, metric); - ASSERT_EQ("12", metric->to_string()); + EXPECT_NE(nullptr, metric); + EXPECT_EQ("12", metric->to_string()); cpu_idle->increment(8); - ASSERT_EQ("20", metric->to_string()); + EXPECT_EQ("20", metric->to_string()); // Deregister entity.deregister_metric(&cpu_idle_type); // After deregister metric = entity.get_metric("cpu_idle"); - ASSERT_EQ(nullptr, metric); + EXPECT_EQ(nullptr, metric); } TEST_F(MetricsTest, MetricEntityWithHook) { @@ -245,55 +246,55 @@ TEST_F(MetricsTest, MetricEntityWithHook) { // Before hook Metric* metric = entity.get_metric("cpu_idle"); - ASSERT_NE(nullptr, metric); - ASSERT_EQ("0", metric->to_string()); + EXPECT_NE(nullptr, metric); + EXPECT_EQ("0", metric->to_string()); // Hook entity.trigger_hook_unlocked(true); - ASSERT_EQ("6", metric->to_string()); + EXPECT_EQ("6", metric->to_string()); entity.trigger_hook_unlocked(true); - ASSERT_EQ("12", metric->to_string()); + EXPECT_EQ("12", metric->to_string()); // Deregister hook entity.deregister_hook("test_hook"); // Hook but no effect entity.trigger_hook_unlocked(true); - ASSERT_EQ("12", metric->to_string()); + EXPECT_EQ("12", metric->to_string()); } TEST_F(MetricsTest, MetricRegistryRegister) { MetricRegistry registry("test_registry"); // No entity - ASSERT_EQ("", registry.to_prometheus()); - ASSERT_EQ("[]", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_prometheus()); + EXPECT_EQ("[]", registry.to_json()); + EXPECT_EQ("", registry.to_core_string()); // Register auto entity1 = registry.register_entity("test_entity"); - ASSERT_NE(nullptr, entity1); + EXPECT_NE(nullptr, entity1); // Register again auto entity2 = registry.register_entity("test_entity"); - ASSERT_NE(nullptr, entity2); - ASSERT_EQ(entity1.get(), entity2.get()); + EXPECT_NE(nullptr, entity2); + EXPECT_EQ(entity1.get(), entity2.get()); // Deregister entity once registry.deregister_entity(entity1); // Still exist and equal to entity1 entity2 = registry.get_entity("test_entity"); - ASSERT_NE(nullptr, entity2); - ASSERT_EQ(entity1.get(), entity2.get()); + EXPECT_NE(nullptr, entity2); + EXPECT_EQ(entity1.get(), entity2.get()); // Deregister entity twice registry.deregister_entity(entity2); // Not exist and registry is empty entity2 = registry.get_entity("test_entity"); - ASSERT_EQ(nullptr, entity2); - ASSERT_EQ("", registry.to_prometheus()); + EXPECT_EQ(nullptr, entity2); + EXPECT_EQ("", registry.to_prometheus()); } TEST_F(MetricsTest, MetricRegistryOutput) { @@ -301,9 +302,9 @@ TEST_F(MetricsTest, MetricRegistryOutput) { { // No entity - ASSERT_EQ("", registry.to_prometheus()); - ASSERT_EQ("[]", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_prometheus()); + EXPECT_EQ("[]", registry.to_json()); + EXPECT_EQ("", registry.to_core_string()); } { @@ -315,13 +316,13 @@ TEST_F(MetricsTest, MetricRegistryOutput) { IntCounter* cpu_idle = (IntCounter*)entity->register_metric(&cpu_idle_type); cpu_idle->increment(8); - ASSERT_EQ(R"(# TYPE test_registry_cpu_idle gauge + EXPECT_EQ(R"(# TYPE test_registry_cpu_idle gauge test_registry_cpu_idle 8 )", registry.to_prometheus()); - ASSERT_EQ(R"([{"tags":{"metric":"cpu_idle"},"unit":"percent","value":8}])", + EXPECT_EQ(R"([{"tags":{"metric":"cpu_idle"},"unit":"percent","value":8}])", registry.to_json()); - ASSERT_EQ("test_registry_cpu_idle LONG 8\n", registry.to_core_string()); + EXPECT_EQ("test_registry_cpu_idle LONG 8\n", registry.to_core_string()); registry.deregister_entity(entity); } @@ -334,13 +335,13 @@ test_registry_cpu_idle 8 IntCounter* cpu_idle = (IntCounter*)entity->register_metric(&cpu_idle_type); cpu_idle->increment(18); - ASSERT_EQ(R"(# TYPE test_registry_cpu gauge + EXPECT_EQ(R"(# TYPE test_registry_cpu gauge test_registry_cpu{mode="idle"} 18 )", registry.to_prometheus()); - ASSERT_EQ(R"([{"tags":{"metric":"cpu","mode":"idle"},"unit":"percent","value":18}])", + EXPECT_EQ(R"([{"tags":{"metric":"cpu","mode":"idle"},"unit":"percent","value":18}])", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_core_string()); registry.deregister_entity(entity); } @@ -352,14 +353,14 @@ test_registry_cpu{mode="idle"} 18 IntCounter* cpu_idle = (IntCounter*)entity->register_metric(&cpu_idle_type); cpu_idle->increment(28); - ASSERT_EQ(R"(# TYPE test_registry_cpu_idle gauge + EXPECT_EQ(R"(# TYPE test_registry_cpu_idle gauge test_registry_cpu_idle{name="label_test"} 28 )", registry.to_prometheus()); - ASSERT_EQ( + EXPECT_EQ( R"([{"tags":{"metric":"cpu_idle","name":"label_test"},"unit":"percent","value":28}])", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_core_string()); registry.deregister_entity(entity); } @@ -372,14 +373,14 @@ test_registry_cpu_idle{name="label_test"} 28 IntCounter* cpu_idle = (IntCounter*)entity->register_metric(&cpu_idle_type); cpu_idle->increment(38); - ASSERT_EQ(R"(# TYPE test_registry_cpu gauge + EXPECT_EQ(R"(# TYPE test_registry_cpu gauge test_registry_cpu{name="label_test",mode="idle"} 38 )", registry.to_prometheus()); - ASSERT_EQ( + EXPECT_EQ( R"([{"tags":{"metric":"cpu","mode":"idle","name":"label_test"},"unit":"percent","value":38}])", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_core_string()); registry.deregister_entity(entity); } @@ -397,15 +398,15 @@ test_registry_cpu{name="label_test",mode="idle"} 38 IntGauge* cpu_guest = (IntGauge*)entity->register_metric(&cpu_guest_type); cpu_guest->increment(58); - ASSERT_EQ(R"(# TYPE test_registry_cpu gauge + EXPECT_EQ(R"(# TYPE test_registry_cpu gauge test_registry_cpu{mode="idle"} 48 test_registry_cpu{mode="guest"} 58 )", registry.to_prometheus()); - ASSERT_EQ( + EXPECT_EQ( R"([{"tags":{"metric":"cpu","mode":"guest"},"unit":"percent","value":58},{"tags":{"metric":"cpu","mode":"idle"},"unit":"percent","value":48}])", registry.to_json()); - ASSERT_EQ("", registry.to_core_string()); + EXPECT_EQ("", registry.to_core_string()); registry.deregister_entity(entity); } } @@ -424,7 +425,7 @@ TEST_F(MetricsTest, HistogramRegistryOutput) { for (int j = 1; j <= 100; j++) { task_duration->add(j); } - ASSERT_EQ(R"(# TYPE test_registry_task_duration histogram + EXPECT_EQ(R"(# TYPE test_registry_task_duration histogram test_registry_task_duration{quantile="0.50"} 50 test_registry_task_duration{quantile="0.75"} 75 test_registry_task_duration{quantile="0.90"} 95.8333 @@ -439,7 +440,7 @@ test_registry_task_duration_median 50 test_registry_task_duration_standard_deviation 28.8661 )", registry.to_prometheus()); - ASSERT_EQ( + EXPECT_EQ( R"*([{"tags":{"metric":"task_duration"},"unit":"milliseconds",)*" R"*("value":{"total_count":100,"min":1,"average":50.5,"median":50.0,)*" R"*("percentile_50":50.0,"percentile_75":75.0,"percentile_90":95.83333333333334,"percentile_95":100.0,"percentile_99":100.0,)*" @@ -460,7 +461,7 @@ test_registry_task_duration_standard_deviation 28.8661 task_duration->add(j); } - ASSERT_EQ(R"(# TYPE test_registry_task_duration histogram + EXPECT_EQ(R"(# TYPE test_registry_task_duration histogram test_registry_task_duration{instance="test",type="create_tablet",quantile="0.50"} 50 test_registry_task_duration{instance="test",type="create_tablet",quantile="0.75"} 75 test_registry_task_duration{instance="test",type="create_tablet",quantile="0.90"} 95.8333 @@ -475,7 +476,7 @@ test_registry_task_duration_median{instance="test",type="create_tablet"} 50 test_registry_task_duration_standard_deviation{instance="test",type="create_tablet"} 28.8661 )", registry.to_prometheus()); - ASSERT_EQ( + EXPECT_EQ( R"*([{"tags":{"metric":"task_duration","type":"create_tablet","instance":"test"},"unit":"milliseconds",)*" R"*("value":{"total_count":100,"min":1,"average":50.5,"median":50.0,)*" R"*("percentile_50":50.0,"percentile_75":75.0,"percentile_90":95.83333333333334,"percentile_95":100.0,"percentile_99":100.0,)*" @@ -485,8 +486,3 @@ test_registry_task_duration_standard_deviation{instance="test",type="create_tabl } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/monotime_test.cpp b/be/test/util/monotime_test.cpp index 125adfa5fd..8f66e3bbe0 100644 --- a/be/test/util/monotime_test.cpp +++ b/be/test/util/monotime_test.cpp @@ -39,7 +39,7 @@ TEST(TestMonoTime, TestMonotonicity) { next = MonoTime::Now(); //LOG(INFO) << " next = " << next.ToString(); } while (!prev.ComesBefore(next)); - ASSERT_FALSE(next.ComesBefore(prev)); + EXPECT_FALSE(next.ComesBefore(prev)); alarm(0); } @@ -48,18 +48,18 @@ TEST(TestMonoTime, TestComparison) { MonoTime future(now); future.AddDelta(MonoDelta::FromNanoseconds(1L)); - ASSERT_GT((future - now).ToNanoseconds(), 0); - ASSERT_LT((now - future).ToNanoseconds(), 0); - ASSERT_EQ((now - now).ToNanoseconds(), 0); + EXPECT_GT((future - now).ToNanoseconds(), 0); + EXPECT_LT((now - future).ToNanoseconds(), 0); + EXPECT_EQ((now - now).ToNanoseconds(), 0); MonoDelta nano(MonoDelta::FromNanoseconds(1L)); MonoDelta mil(MonoDelta::FromMilliseconds(1L)); MonoDelta sec(MonoDelta::FromSeconds(1.0)); - ASSERT_TRUE(nano.LessThan(mil)); - ASSERT_TRUE(mil.LessThan(sec)); - ASSERT_TRUE(mil.MoreThan(nano)); - ASSERT_TRUE(sec.MoreThan(mil)); + EXPECT_TRUE(nano.LessThan(mil)); + EXPECT_TRUE(mil.LessThan(sec)); + EXPECT_TRUE(mil.MoreThan(nano)); + EXPECT_TRUE(sec.MoreThan(mil)); } TEST(TestMonoTime, TestTimeVal) { @@ -70,32 +70,32 @@ TEST(TestMonoTime, TestTimeVal) { // Normal conversion case. MonoDelta one_sec_one_micro(MonoDelta::FromNanoseconds(1000001000L)); one_sec_one_micro.ToTimeVal(&tv); - ASSERT_EQ(1, tv.tv_sec); - ASSERT_EQ(1, tv.tv_usec); + EXPECT_EQ(1, tv.tv_sec); + EXPECT_EQ(1, tv.tv_usec); // Case where we are still positive but sub-micro. // Round up to nearest microsecond. This is to avoid infinite timeouts // in APIs that take a struct timeval. MonoDelta zero_sec_one_nano(MonoDelta::FromNanoseconds(1L)); zero_sec_one_nano.ToTimeVal(&tv); - ASSERT_EQ(0, tv.tv_sec); - ASSERT_EQ(1, tv.tv_usec); // Special case: 1ns rounds up to + EXPECT_EQ(0, tv.tv_sec); + EXPECT_EQ(1, tv.tv_usec); // Special case: 1ns rounds up to // Negative conversion case. Ensure the timeval is normalized. // That means sec is negative and usec is positive. MonoDelta neg_micro(MonoDelta::FromMicroseconds(-1L)); - ASSERT_EQ(-1000, neg_micro.ToNanoseconds()); + EXPECT_EQ(-1000, neg_micro.ToNanoseconds()); neg_micro.ToTimeVal(&tv); - ASSERT_EQ(-1, tv.tv_sec); - ASSERT_EQ(999999, tv.tv_usec); + EXPECT_EQ(-1, tv.tv_sec); + EXPECT_EQ(999999, tv.tv_usec); // Case where we are still negative but sub-micro. // Round up to nearest microsecond. This is to avoid infinite timeouts // in APIs that take a struct timeval and for consistency. MonoDelta zero_sec_neg_one_nano(MonoDelta::FromNanoseconds(-1L)); zero_sec_neg_one_nano.ToTimeVal(&tv); - ASSERT_EQ(-1, tv.tv_sec); - ASSERT_EQ(999999, tv.tv_usec); + EXPECT_EQ(-1, tv.tv_sec); + EXPECT_EQ(999999, tv.tv_usec); } TEST(TestMonoTime, TestTimeSpec) { @@ -104,20 +104,20 @@ TEST(TestMonoTime, TestTimeSpec) { ts.tv_sec = 1; ts.tv_nsec = 1; MonoTime one_sec_one_nano_actual(ts); - ASSERT_EQ(0, one_sec_one_nano_expected.GetDeltaSince(one_sec_one_nano_actual).ToNanoseconds()); + EXPECT_EQ(0, one_sec_one_nano_expected.GetDeltaSince(one_sec_one_nano_actual).ToNanoseconds()); MonoDelta zero_sec_two_nanos(MonoDelta::FromNanoseconds(2L)); zero_sec_two_nanos.ToTimeSpec(&ts); - ASSERT_EQ(0, ts.tv_sec); - ASSERT_EQ(2, ts.tv_nsec); + EXPECT_EQ(0, ts.tv_sec); + EXPECT_EQ(2, ts.tv_nsec); // Negative conversion case. Ensure the timespec is normalized. // That means sec is negative and nsec is positive. MonoDelta neg_nano(MonoDelta::FromNanoseconds(-1L)); - ASSERT_EQ(-1, neg_nano.ToNanoseconds()); + EXPECT_EQ(-1, neg_nano.ToNanoseconds()); neg_nano.ToTimeSpec(&ts); - ASSERT_EQ(-1, ts.tv_sec); - ASSERT_EQ(999999999, ts.tv_nsec); + EXPECT_EQ(-1, ts.tv_sec); + EXPECT_EQ(999999999, ts.tv_nsec); } TEST(TestMonoTime, TestDeltas) { @@ -137,13 +137,13 @@ TEST(TestMonoTime, TestDeltaConversions) { // TODO: Reliably test MonoDelta::FromSeconds() considering floating-point rounding errors MonoDelta mil(MonoDelta::FromMilliseconds(500)); - ASSERT_EQ(500 * MonoTime::kNanosecondsPerMillisecond, mil.nano_delta_); + EXPECT_EQ(500 * MonoTime::kNanosecondsPerMillisecond, mil.nano_delta_); MonoDelta micro(MonoDelta::FromMicroseconds(500)); - ASSERT_EQ(500 * MonoTime::kNanosecondsPerMicrosecond, micro.nano_delta_); + EXPECT_EQ(500 * MonoTime::kNanosecondsPerMicrosecond, micro.nano_delta_); MonoDelta nano(MonoDelta::FromNanoseconds(500)); - ASSERT_EQ(500, nano.nano_delta_); + EXPECT_EQ(500, nano.nano_delta_); } static void DoTestMonoTimePerf() { @@ -167,7 +167,7 @@ TEST(TestMonoTime, TestSleepFor) { SleepFor(sleep); MonoTime end = MonoTime::Now(); MonoDelta actualSleep = end.GetDeltaSince(start); - ASSERT_GE(actualSleep.ToNanoseconds(), sleep.ToNanoseconds()); + EXPECT_GE(actualSleep.ToNanoseconds(), sleep.ToNanoseconds()); } // Test functionality of the handy operators for MonoTime/MonoDelta objects. @@ -204,7 +204,7 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta dn = MonoDelta::FromNanoseconds(0); MonoDelta dm = MonoDelta::FromMicroseconds(0); - ASSERT_TRUE(dn.Equals(dm)); + EXPECT_TRUE(dn.Equals(dm)); EXPECT_TRUE(dn == dm); EXPECT_TRUE(dm == dn); } @@ -213,7 +213,7 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta dn = MonoDelta::FromNanoseconds(1); MonoDelta dm = MonoDelta::FromMicroseconds(1); - ASSERT_FALSE(dn.Equals(dm)); + EXPECT_FALSE(dn.Equals(dm)); EXPECT_TRUE(dn != dm); EXPECT_TRUE(dm != dn); } @@ -222,7 +222,7 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta d0 = MonoDelta::FromNanoseconds(0); MonoDelta d1 = MonoDelta::FromNanoseconds(1); - ASSERT_TRUE(d0.LessThan(d1)); + EXPECT_TRUE(d0.LessThan(d1)); EXPECT_TRUE(d0 < d1); } @@ -230,12 +230,12 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta d0 = MonoDelta::FromNanoseconds(0); MonoDelta d1 = MonoDelta::FromNanoseconds(1); - ASSERT_TRUE(d0.LessThan(d1)); + EXPECT_TRUE(d0.LessThan(d1)); EXPECT_TRUE(d0 <= d1); MonoDelta d20 = MonoDelta::FromNanoseconds(2); MonoDelta d21 = MonoDelta::FromNanoseconds(2); - ASSERT_TRUE(d20.Equals(d21)); + EXPECT_TRUE(d20.Equals(d21)); EXPECT_TRUE(d20 <= d21); } @@ -243,7 +243,7 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta d0 = MonoDelta::FromNanoseconds(0); MonoDelta d1 = MonoDelta::FromNanoseconds(1); - ASSERT_TRUE(d1.MoreThan(d0)); + EXPECT_TRUE(d1.MoreThan(d0)); EXPECT_TRUE(d1 > d0); } @@ -251,12 +251,12 @@ TEST(TestMonoTime, TestOperators) { { MonoDelta d0 = MonoDelta::FromNanoseconds(0); MonoDelta d1 = MonoDelta::FromNanoseconds(1); - ASSERT_TRUE(d1.MoreThan(d0)); + EXPECT_TRUE(d1.MoreThan(d0)); EXPECT_TRUE(d1 >= d1); MonoDelta d20 = MonoDelta::FromNanoseconds(2); MonoDelta d21 = MonoDelta::FromNanoseconds(2); - ASSERT_TRUE(d20.Equals(d21)); + EXPECT_TRUE(d20.Equals(d21)); EXPECT_TRUE(d21 >= d20); } @@ -264,8 +264,8 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t0 = MonoTime::Now(); MonoTime t1(t0); - ASSERT_TRUE(t0.Equals(t1)); - ASSERT_TRUE(t1.Equals(t0)); + EXPECT_TRUE(t0.Equals(t1)); + EXPECT_TRUE(t1.Equals(t0)); EXPECT_TRUE(t0 == t1); EXPECT_TRUE(t1 == t0); } @@ -274,8 +274,8 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t0 = MonoTime::Now(); MonoTime t1(t0 + MonoDelta::FromMilliseconds(100)); - ASSERT_TRUE(!t0.Equals(t1)); - ASSERT_TRUE(!t1.Equals(t0)); + EXPECT_TRUE(!t0.Equals(t1)); + EXPECT_TRUE(!t1.Equals(t0)); EXPECT_TRUE(t0 != t1); EXPECT_TRUE(t1 != t0); } @@ -284,8 +284,8 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t0 = MonoTime::Now(); MonoTime t1(t0 + MonoDelta::FromMilliseconds(100)); - ASSERT_TRUE(t0.ComesBefore(t1)); - ASSERT_FALSE(t1.ComesBefore(t0)); + EXPECT_TRUE(t0.ComesBefore(t1)); + EXPECT_FALSE(t1.ComesBefore(t0)); EXPECT_TRUE(t0 < t1); EXPECT_FALSE(t1 < t0); } @@ -294,20 +294,20 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t00 = MonoTime::Now(); MonoTime t01(t00); - ASSERT_TRUE(t00.Equals(t00)); - ASSERT_TRUE(t00.Equals(t01)); - ASSERT_TRUE(t01.Equals(t00)); - ASSERT_TRUE(t01.Equals(t01)); + EXPECT_TRUE(t00.Equals(t00)); + EXPECT_TRUE(t00.Equals(t01)); + EXPECT_TRUE(t01.Equals(t00)); + EXPECT_TRUE(t01.Equals(t01)); EXPECT_TRUE(t00 <= t00); EXPECT_TRUE(t00 <= t01); EXPECT_TRUE(t01 <= t00); EXPECT_TRUE(t01 <= t01); MonoTime t1(t00 + MonoDelta::FromMilliseconds(100)); - ASSERT_TRUE(t00.ComesBefore(t1)); - ASSERT_TRUE(t01.ComesBefore(t1)); - ASSERT_FALSE(t1.ComesBefore(t00)); - ASSERT_FALSE(t1.ComesBefore(t01)); + EXPECT_TRUE(t00.ComesBefore(t1)); + EXPECT_TRUE(t01.ComesBefore(t1)); + EXPECT_FALSE(t1.ComesBefore(t00)); + EXPECT_FALSE(t1.ComesBefore(t01)); EXPECT_TRUE(t00 <= t1); EXPECT_TRUE(t01 <= t1); EXPECT_FALSE(t1 <= t00); @@ -318,8 +318,8 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t0 = MonoTime::Now(); MonoTime t1(t0 + MonoDelta::FromMilliseconds(100)); - ASSERT_TRUE(t0.ComesBefore(t1)); - ASSERT_FALSE(t1.ComesBefore(t0)); + EXPECT_TRUE(t0.ComesBefore(t1)); + EXPECT_FALSE(t1.ComesBefore(t0)); EXPECT_TRUE(t0 < t1); EXPECT_FALSE(t1 < t0); } @@ -328,20 +328,20 @@ TEST(TestMonoTime, TestOperators) { { MonoTime t00 = MonoTime::Now(); MonoTime t01(t00); - ASSERT_TRUE(t00.Equals(t00)); - ASSERT_TRUE(t00.Equals(t01)); - ASSERT_TRUE(t01.Equals(t00)); - ASSERT_TRUE(t01.Equals(t01)); + EXPECT_TRUE(t00.Equals(t00)); + EXPECT_TRUE(t00.Equals(t01)); + EXPECT_TRUE(t01.Equals(t00)); + EXPECT_TRUE(t01.Equals(t01)); EXPECT_TRUE(t00 >= t00); EXPECT_TRUE(t00 >= t01); EXPECT_TRUE(t01 >= t00); EXPECT_TRUE(t01 >= t01); MonoTime t1(t00 + MonoDelta::FromMilliseconds(100)); - ASSERT_TRUE(t00.ComesBefore(t1)); - ASSERT_TRUE(t01.ComesBefore(t1)); - ASSERT_FALSE(t1.ComesBefore(t00)); - ASSERT_FALSE(t1.ComesBefore(t01)); + EXPECT_TRUE(t00.ComesBefore(t1)); + EXPECT_TRUE(t01.ComesBefore(t1)); + EXPECT_FALSE(t1.ComesBefore(t00)); + EXPECT_FALSE(t1.ComesBefore(t01)); EXPECT_FALSE(t00 >= t1); EXPECT_FALSE(t01 >= t1); EXPECT_TRUE(t1 >= t00); @@ -402,8 +402,3 @@ TEST(TestMonoTimePerf, TestMonoTimePerf) { } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/mysql_row_buffer_test.cpp b/be/test/util/mysql_row_buffer_test.cpp index 43c9355355..a575e7653a 100644 --- a/be/test/util/mysql_row_buffer_test.cpp +++ b/be/test/util/mysql_row_buffer_test.cpp @@ -120,8 +120,3 @@ TEST(MysqlRowBufferTest, dynamic_mode) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/util/parse_util_test.cpp b/be/test/util/parse_util_test.cpp index 511c675914..151b3f349e 100644 --- a/be/test/util/parse_util_test.cpp +++ b/be/test/util/parse_util_test.cpp @@ -30,8 +30,8 @@ static void test_parse_mem_spec(const std::string& mem_spec_str, int64_t result) bool is_percent = true; int64_t bytes = ParseUtil::parse_mem_spec(mem_spec_str, -1, MemInfo::_s_physical_mem, &is_percent); - ASSERT_EQ(result, bytes); - ASSERT_FALSE(is_percent); + EXPECT_EQ(result, bytes); + EXPECT_FALSE(is_percent); } TEST(TestParseMemSpec, Normal) { @@ -54,25 +54,25 @@ TEST(TestParseMemSpec, Normal) { bool is_percent = false; int64_t bytes = ParseUtil::parse_mem_spec("20%", -1, MemInfo::_s_physical_mem, &is_percent); - ASSERT_GT(bytes, 0); - ASSERT_TRUE(is_percent); + EXPECT_GT(bytes, 0); + EXPECT_TRUE(is_percent); MemInfo::_s_physical_mem = 1000; is_percent = true; bytes = ParseUtil::parse_mem_spec("0.1%", -1, MemInfo::_s_physical_mem, &is_percent); - ASSERT_EQ(bytes, 1); - ASSERT_TRUE(is_percent); + EXPECT_EQ(bytes, 1); + EXPECT_TRUE(is_percent); // test with parent limit is_percent = false; bytes = ParseUtil::parse_mem_spec("1%", 1000, MemInfo::_s_physical_mem, &is_percent); - ASSERT_TRUE(is_percent); - ASSERT_EQ(10, bytes); + EXPECT_TRUE(is_percent); + EXPECT_EQ(10, bytes); is_percent = true; bytes = ParseUtil::parse_mem_spec("1001", 1000, MemInfo::_s_physical_mem, &is_percent); - ASSERT_FALSE(is_percent); - ASSERT_EQ(1001, bytes); + EXPECT_FALSE(is_percent); + EXPECT_EQ(1001, bytes); } TEST(TestParseMemSpec, Bad) { @@ -93,14 +93,8 @@ TEST(TestParseMemSpec, Bad) { for (const auto& value : bad_values) { bool is_percent = false; int64_t bytes = ParseUtil::parse_mem_spec(value, -1, MemInfo::_s_physical_mem, &is_percent); - ASSERT_EQ(-1, bytes); + EXPECT_EQ(-1, bytes); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - doris::MemInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/path_trie_test.cpp b/be/test/util/path_trie_test.cpp index bbf433f22e..bd599e1bab 100644 --- a/be/test/util/path_trie_test.cpp +++ b/be/test/util/path_trie_test.cpp @@ -32,150 +32,139 @@ TEST_F(PathTrieTest, SplitTest) { array.clear(); root.split("", &array); - ASSERT_EQ(0, array.size()); + EXPECT_EQ(0, array.size()); array.clear(); root.split("///", &array); - ASSERT_EQ(0, array.size()); + EXPECT_EQ(0, array.size()); array.clear(); root.split("/a/b/c", &array); - ASSERT_EQ(3, array.size()); - ASSERT_STREQ("a", array[0].c_str()); - ASSERT_STREQ("b", array[1].c_str()); - ASSERT_STREQ("c", array[2].c_str()); + EXPECT_EQ(3, array.size()); + EXPECT_STREQ("a", array[0].c_str()); + EXPECT_STREQ("b", array[1].c_str()); + EXPECT_STREQ("c", array[2].c_str()); array.clear(); root.split("/{db}/{table}/{rollup}", &array); - ASSERT_EQ(3, array.size()); - ASSERT_STREQ("{db}", array[0].c_str()); - ASSERT_STREQ("{table}", array[1].c_str()); - ASSERT_STREQ("{rollup}", array[2].c_str()); + EXPECT_EQ(3, array.size()); + EXPECT_STREQ("{db}", array[0].c_str()); + EXPECT_STREQ("{table}", array[1].c_str()); + EXPECT_STREQ("{rollup}", array[2].c_str()); } TEST_F(PathTrieTest, TemplateTest) { PathTrie root; std::string path = "/{db}/{table}/{rollup}"; - ASSERT_TRUE(root.insert(path, 1)); + EXPECT_TRUE(root.insert(path, 1)); std::map params; int value; - ASSERT_TRUE(root.retrieve("/1/2/3", &value)); - ASSERT_EQ(1, value); + EXPECT_TRUE(root.retrieve("/1/2/3", &value)); + EXPECT_EQ(1, value); - ASSERT_TRUE(root.retrieve("/a/b/c", &value, ¶ms)); - ASSERT_EQ(1, value); - ASSERT_STREQ("a", params["db"].c_str()); - ASSERT_STREQ("b", params["table"].c_str()); - ASSERT_STREQ("c", params["rollup"].c_str()); + EXPECT_TRUE(root.retrieve("/a/b/c", &value, ¶ms)); + EXPECT_EQ(1, value); + EXPECT_STREQ("a", params["db"].c_str()); + EXPECT_STREQ("b", params["table"].c_str()); + EXPECT_STREQ("c", params["rollup"].c_str()); } TEST_F(PathTrieTest, ExactTest) { PathTrie root; std::string path = "/db/table/rollup"; - ASSERT_TRUE(root.insert(path, 100)); + EXPECT_TRUE(root.insert(path, 100)); std::map params; int value; - ASSERT_TRUE(root.retrieve("/db/table/rollup", &value, ¶ms)); - ASSERT_EQ(100, value); - ASSERT_EQ(0, params.size()); + EXPECT_TRUE(root.retrieve("/db/table/rollup", &value, ¶ms)); + EXPECT_EQ(100, value); + EXPECT_EQ(0, params.size()); // No path assert - ASSERT_FALSE(root.retrieve("/db/table/c", &value, ¶ms)); - ASSERT_FALSE(root.retrieve("/a/b/c", &value, ¶ms)); + EXPECT_FALSE(root.retrieve("/db/table/c", &value, ¶ms)); + EXPECT_FALSE(root.retrieve("/a/b/c", &value, ¶ms)); } TEST_F(PathTrieTest, MultiInsertTest) { PathTrie root; std::string path = "/db/table/rollup"; - ASSERT_TRUE(root.insert(path, 100)); - ASSERT_FALSE(root.insert(path, 100)); + EXPECT_TRUE(root.insert(path, 100)); + EXPECT_FALSE(root.insert(path, 100)); path = "/db/table/rollup2"; - ASSERT_TRUE(root.insert(path, 110)); + EXPECT_TRUE(root.insert(path, 110)); int value; - ASSERT_TRUE(root.retrieve("/db/table/rollup", &value)); - ASSERT_EQ(100, value); - ASSERT_TRUE(root.retrieve("/db/table/rollup2", &value)); - ASSERT_EQ(110, value); + EXPECT_TRUE(root.retrieve("/db/table/rollup", &value)); + EXPECT_EQ(100, value); + EXPECT_TRUE(root.retrieve("/db/table/rollup2", &value)); + EXPECT_EQ(110, value); // Other path = "/db/rollup"; - ASSERT_TRUE(root.insert(path, 120)); - ASSERT_TRUE(root.retrieve("/db/rollup", &value)); - ASSERT_EQ(120, value); + EXPECT_TRUE(root.insert(path, 120)); + EXPECT_TRUE(root.retrieve("/db/rollup", &value)); + EXPECT_EQ(120, value); } TEST_F(PathTrieTest, MultiTemplateTest) { PathTrie root; std::string path = "/db/{table}"; - ASSERT_TRUE(root.insert(path, 100)); + EXPECT_TRUE(root.insert(path, 100)); // Duplicate template path = "/db/{rollup}/abc"; - ASSERT_FALSE(root.insert(path, 110)); + EXPECT_FALSE(root.insert(path, 110)); path = "/db/{table}/abc"; - ASSERT_TRUE(root.insert(path, 110)); + EXPECT_TRUE(root.insert(path, 110)); int value; std::map params; - ASSERT_TRUE(root.retrieve("/db/12345", &value, ¶ms)); - ASSERT_EQ(100, value); - ASSERT_EQ(1, params.size()); - ASSERT_STREQ("12345", params["table"].c_str()); + EXPECT_TRUE(root.retrieve("/db/12345", &value, ¶ms)); + EXPECT_EQ(100, value); + EXPECT_EQ(1, params.size()); + EXPECT_STREQ("12345", params["table"].c_str()); } TEST_F(PathTrieTest, MultiPlayTest) { PathTrie root; std::string path = "/db/abc"; - ASSERT_TRUE(root.insert(path, 100)); + EXPECT_TRUE(root.insert(path, 100)); // Duplicate template path = "/db"; - ASSERT_TRUE(root.insert(path, 110)); + EXPECT_TRUE(root.insert(path, 110)); path = "/db/abc/bcd"; - ASSERT_TRUE(root.insert(path, 120)); + EXPECT_TRUE(root.insert(path, 120)); int value; - ASSERT_TRUE(root.retrieve("/db/abc", &value)); - ASSERT_EQ(100, value); - ASSERT_TRUE(root.retrieve("/db", &value)); - ASSERT_EQ(110, value); - ASSERT_TRUE(root.retrieve("/db/abc/bcd", &value)); - ASSERT_EQ(120, value); + EXPECT_TRUE(root.retrieve("/db/abc", &value)); + EXPECT_EQ(100, value); + EXPECT_TRUE(root.retrieve("/db", &value)); + EXPECT_EQ(110, value); + EXPECT_TRUE(root.retrieve("/db/abc/bcd", &value)); + EXPECT_EQ(120, value); } TEST_F(PathTrieTest, EmptyTest) { PathTrie root; std::string path = "/"; - ASSERT_TRUE(root.insert(path, 100)); + EXPECT_TRUE(root.insert(path, 100)); // Duplicate template path = "/"; - ASSERT_FALSE(root.insert(path, 110)); + EXPECT_FALSE(root.insert(path, 110)); int value; - ASSERT_TRUE(root.retrieve("/", &value)); - ASSERT_EQ(100, value); + EXPECT_TRUE(root.retrieve("/", &value)); + EXPECT_EQ(100, value); value = 150; - ASSERT_TRUE(root.retrieve("", &value)); - ASSERT_EQ(100, value); + EXPECT_TRUE(root.retrieve("", &value)); + EXPECT_EQ(100, value); } } // namespace doris - -int main(int argc, char* argv[]) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/path_util_test.cpp b/be/test/util/path_util_test.cpp index dabb4a7b60..a6c5ba54b3 100644 --- a/be/test/util/path_util_test.cpp +++ b/be/test/util/path_util_test.cpp @@ -31,84 +31,79 @@ using std::vector; namespace doris { TEST(TestPathUtil, JoinPathSegments) { - ASSERT_EQ("a", path_util::join_path_segments("a", "")); - ASSERT_EQ("b", path_util::join_path_segments("", "b")); - ASSERT_EQ("a/b", path_util::join_path_segments("a", "b")); - ASSERT_EQ("a/b", path_util::join_path_segments("a/", "b")); - ASSERT_EQ("a/b", path_util::join_path_segments("a", "/b")); - ASSERT_EQ("a/b", path_util::join_path_segments("a/", "/b")); + EXPECT_EQ("a", path_util::join_path_segments("a", "")); + EXPECT_EQ("b", path_util::join_path_segments("", "b")); + EXPECT_EQ("a/b", path_util::join_path_segments("a", "b")); + EXPECT_EQ("a/b", path_util::join_path_segments("a/", "b")); + EXPECT_EQ("a/b", path_util::join_path_segments("a", "/b")); + EXPECT_EQ("a/b", path_util::join_path_segments("a/", "/b")); } TEST(TestPathUtil, BaseNameTest) { - ASSERT_EQ(".", path_util::base_name("")); - ASSERT_EQ(".", path_util::base_name(".")); - ASSERT_EQ("..", path_util::base_name("..")); - ASSERT_EQ("/", path_util::base_name("/")); - ASSERT_EQ("/", path_util::base_name("//")); - ASSERT_EQ("a", path_util::base_name("a")); - ASSERT_EQ("ab", path_util::base_name("ab")); - ASSERT_EQ("ab", path_util::base_name("ab/")); - ASSERT_EQ("cd", path_util::base_name("ab/cd")); - ASSERT_EQ("ab", path_util::base_name("/ab")); - ASSERT_EQ("ab", path_util::base_name("/ab///")); - ASSERT_EQ("cd", path_util::base_name("/ab/cd")); + EXPECT_EQ(".", path_util::base_name("")); + EXPECT_EQ(".", path_util::base_name(".")); + EXPECT_EQ("..", path_util::base_name("..")); + EXPECT_EQ("/", path_util::base_name("/")); + EXPECT_EQ("/", path_util::base_name("//")); + EXPECT_EQ("a", path_util::base_name("a")); + EXPECT_EQ("ab", path_util::base_name("ab")); + EXPECT_EQ("ab", path_util::base_name("ab/")); + EXPECT_EQ("cd", path_util::base_name("ab/cd")); + EXPECT_EQ("ab", path_util::base_name("/ab")); + EXPECT_EQ("ab", path_util::base_name("/ab///")); + EXPECT_EQ("cd", path_util::base_name("/ab/cd")); } TEST(TestPathUtil, DirNameTest) { - ASSERT_EQ(".", path_util::dir_name("")); - ASSERT_EQ(".", path_util::dir_name(".")); - ASSERT_EQ(".", path_util::dir_name("..")); - ASSERT_EQ("/", path_util::dir_name("/")); - ASSERT_EQ("//", path_util::dir_name("//")); - ASSERT_EQ(".", path_util::dir_name("a")); - ASSERT_EQ(".", path_util::dir_name("ab")); - ASSERT_EQ(".", path_util::dir_name("ab/")); - ASSERT_EQ("ab", path_util::dir_name("ab/cd")); - ASSERT_EQ("/", path_util::dir_name("/ab")); - ASSERT_EQ("/", path_util::dir_name("/ab///")); - ASSERT_EQ("/ab", path_util::dir_name("/ab/cd")); + EXPECT_EQ(".", path_util::dir_name("")); + EXPECT_EQ(".", path_util::dir_name(".")); + EXPECT_EQ(".", path_util::dir_name("..")); + EXPECT_EQ("/", path_util::dir_name("/")); + EXPECT_EQ("//", path_util::dir_name("//")); + EXPECT_EQ(".", path_util::dir_name("a")); + EXPECT_EQ(".", path_util::dir_name("ab")); + EXPECT_EQ(".", path_util::dir_name("ab/")); + EXPECT_EQ("ab", path_util::dir_name("ab/cd")); + EXPECT_EQ("/", path_util::dir_name("/ab")); + EXPECT_EQ("/", path_util::dir_name("/ab///")); + EXPECT_EQ("/ab", path_util::dir_name("/ab/cd")); } TEST(TestPathUtil, SplitPathTest) { using Vec = std::vector; - ASSERT_EQ(Vec({"/"}), path_util::split_path("/")); - ASSERT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b")); - ASSERT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b/")); - ASSERT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a//b/")); - ASSERT_EQ(Vec({"a", "b"}), path_util::split_path("a/b")); - ASSERT_EQ(Vec({"."}), path_util::split_path(".")); - ASSERT_EQ(Vec(), path_util::split_path("")); + EXPECT_EQ(Vec({"/"}), path_util::split_path("/")); + EXPECT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b")); + EXPECT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a/b/")); + EXPECT_EQ(Vec({"/", "a", "b"}), path_util::split_path("/a//b/")); + EXPECT_EQ(Vec({"a", "b"}), path_util::split_path("a/b")); + EXPECT_EQ(Vec({"."}), path_util::split_path(".")); + EXPECT_EQ(Vec(), path_util::split_path("")); } TEST(TestPathUtil, file_extension_test) { - ASSERT_EQ("", path_util::file_extension("")); - ASSERT_EQ("", path_util::file_extension(".")); - ASSERT_EQ("", path_util::file_extension("..")); - ASSERT_EQ("", path_util::file_extension("/")); - ASSERT_EQ("", path_util::file_extension("//")); - ASSERT_EQ("", path_util::file_extension("///")); - ASSERT_EQ("", path_util::file_extension("a")); - ASSERT_EQ("", path_util::file_extension("ab")); - ASSERT_EQ("", path_util::file_extension("ab/")); - ASSERT_EQ("", path_util::file_extension("ab/cd")); - ASSERT_EQ("", path_util::file_extension("/ab")); - ASSERT_EQ("", path_util::file_extension("/ab/")); - ASSERT_EQ("", path_util::file_extension("///ab///")); - ASSERT_EQ("", path_util::file_extension("/ab/cd")); - ASSERT_EQ("", path_util::file_extension("../ab/cd")); + EXPECT_EQ("", path_util::file_extension("")); + EXPECT_EQ("", path_util::file_extension(".")); + EXPECT_EQ("", path_util::file_extension("..")); + EXPECT_EQ("", path_util::file_extension("/")); + EXPECT_EQ("", path_util::file_extension("//")); + EXPECT_EQ("", path_util::file_extension("///")); + EXPECT_EQ("", path_util::file_extension("a")); + EXPECT_EQ("", path_util::file_extension("ab")); + EXPECT_EQ("", path_util::file_extension("ab/")); + EXPECT_EQ("", path_util::file_extension("ab/cd")); + EXPECT_EQ("", path_util::file_extension("/ab")); + EXPECT_EQ("", path_util::file_extension("/ab/")); + EXPECT_EQ("", path_util::file_extension("///ab///")); + EXPECT_EQ("", path_util::file_extension("/ab/cd")); + EXPECT_EQ("", path_util::file_extension("../ab/cd")); - ASSERT_EQ(".a", path_util::file_extension(".a")); - ASSERT_EQ("", path_util::file_extension("a.b/c")); - ASSERT_EQ(".d", path_util::file_extension("a.b/c.d")); - ASSERT_EQ(".c", path_util::file_extension("a/b.c")); - ASSERT_EQ(".", path_util::file_extension("a/b.")); - ASSERT_EQ(".c", path_util::file_extension("a.b.c")); - ASSERT_EQ(".", path_util::file_extension("a.b.c.")); + EXPECT_EQ(".a", path_util::file_extension(".a")); + EXPECT_EQ("", path_util::file_extension("a.b/c")); + EXPECT_EQ(".d", path_util::file_extension("a.b/c.d")); + EXPECT_EQ(".c", path_util::file_extension("a/b.c")); + EXPECT_EQ(".", path_util::file_extension("a/b.")); + EXPECT_EQ(".c", path_util::file_extension("a.b.c")); + EXPECT_EQ(".", path_util::file_extension("a.b.c.")); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/perf_counters_test.cpp b/be/test/util/perf_counters_test.cpp deleted file mode 100644 index 1364022072..0000000000 --- a/be/test/util/perf_counters_test.cpp +++ /dev/null @@ -1,86 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "util/perf_counters.h" - -#include -#include -#include - -#include - -#include "util/cpu_info.h" -#include "util/disk_info.h" -#include "util/mem_info.h" - -using namespace std; - -namespace impala { - -TEST(PerfCounterTest, Basic) { - PerfCounters counters; - EXPECT_TRUE(counters.AddDefaultCounters()); - - counters.Snapshot("Before"); - - double result = 0; - - for (int i = 0; i < 1000000; i++) { - double d1 = rand() / (double)RAND_MAX; - double d2 = rand() / (double)RAND_MAX; - result = d1 * d1 + d2 * d2; - } - - counters.Snapshot("After"); - - for (int i = 0; i < 1000000; i++) { - double d1 = rand() / (double)RAND_MAX; - double d2 = rand() / (double)RAND_MAX; - result = d1 * d1 + d2 * d2; - } - - counters.Snapshot("After2"); - counters.PrettyPrint(&cout); -} - -TEST(CpuInfoTest, Basic) { - cout << CpuInfo::DebugString(); -} - -TEST(DiskInfoTest, Basic) { - cout << DiskInfo::DebugString(); - cout << "Device name for disk 0: " << DiskInfo::device_name(0) << std::endl; - - int disk_id_home_dir = DiskInfo::disk_id("/home"); - cout << "Device name for '/home': " << DiskInfo::device_name(disk_id_home_dir) << std::endl; -} - -} // namespace impala - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - impala::CpuInfo::Init(); - impala::DiskInfo::Init(); - impala::MemInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/quantile_state_test.cpp b/be/test/util/quantile_state_test.cpp index c61f555ab0..a09bccf0dc 100644 --- a/be/test/util/quantile_state_test.cpp +++ b/be/test/util/quantile_state_test.cpp @@ -24,16 +24,16 @@ using DoubleQuantileState = QuantileState; TEST(QuantileStateTest, merge) { DoubleQuantileState empty; - ASSERT_EQ(EMPTY, empty._type); + EXPECT_EQ(EMPTY, empty._type); empty.add_value(1); - ASSERT_EQ(SINGLE, empty._type); + EXPECT_EQ(SINGLE, empty._type); empty.add_value(2); empty.add_value(3); empty.add_value(4); empty.add_value(5); - ASSERT_EQ(1, empty.get_value_by_percentile(0)); - ASSERT_EQ(3, empty.get_value_by_percentile(0.5)); - ASSERT_EQ(5, empty.get_value_by_percentile(1)); + EXPECT_EQ(1, empty.get_value_by_percentile(0)); + EXPECT_EQ(3, empty.get_value_by_percentile(0.5)); + EXPECT_EQ(5, empty.get_value_by_percentile(1)); DoubleQuantileState another; another.add_value(6); @@ -41,19 +41,14 @@ TEST(QuantileStateTest, merge) { another.add_value(8); another.add_value(9); another.add_value(10); - ASSERT_EQ(6, another.get_value_by_percentile(0)); - ASSERT_EQ(8, another.get_value_by_percentile(0.5)); - ASSERT_EQ(10, another.get_value_by_percentile(1)); + EXPECT_EQ(6, another.get_value_by_percentile(0)); + EXPECT_EQ(8, another.get_value_by_percentile(0.5)); + EXPECT_EQ(10, another.get_value_by_percentile(1)); another.merge(empty); - ASSERT_EQ(1, another.get_value_by_percentile(0)); - ASSERT_EQ(5.5, another.get_value_by_percentile(0.5)); - ASSERT_EQ(10, another.get_value_by_percentile(1)); + EXPECT_EQ(1, another.get_value_by_percentile(0)); + EXPECT_EQ(5.5, another.get_value_by_percentile(0.5)); + EXPECT_EQ(10, another.get_value_by_percentile(1)); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/radix_sort_test.cpp b/be/test/util/radix_sort_test.cpp index 3408d69a5a..d5fbda13b4 100644 --- a/be/test/util/radix_sort_test.cpp +++ b/be/test/util/radix_sort_test.cpp @@ -53,18 +53,6 @@ protected: // Code here will be called immediately after each test (right // before the destructor). } - - static void SetUpTestCase() { - static bool initialized = false; - if (!initialized) { - FLAGS_logtostderr = true; - google::InstallFailureSignalHandler(); - google::InitGoogleLogging("testing::RadixSortTest"); - initialized = true; - } - } - - // Objects declared here can be used by all tests in the test case for Foo. }; TEST_F(RadixSortTest, TestUint32Sort) { @@ -124,15 +112,15 @@ TEST_F(RadixSortTest, TestFloatSort) { radixSortLSD(data.data(), data.size()); for (size_t i = 0; i < num_values + 4; ++i) { if (i == 0) { - ASSERT_TRUE(compare_float_with_epsilon(data[i], min, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i], min, 0.0000001)); } else if (i == num_values + 1) { - ASSERT_TRUE(compare_float_with_epsilon(data[i], max, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i], max, 0.0000001)); } else if (i == num_values + 2) { - ASSERT_TRUE(std::isinf(data[i])); + EXPECT_TRUE(std::isinf(data[i])); } else if (i == num_values + 3) { - ASSERT_TRUE(std::isnan(data[i])); + EXPECT_TRUE(std::isnan(data[i])); } else { - ASSERT_TRUE(compare_float_with_epsilon(data[i], 1.0 * i - 5000 + 0.1, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i], 1.0 * i - 5000 + 0.1, 0.0000001)); } } } @@ -162,16 +150,16 @@ TEST_F(RadixSortTest, TestDoubleSort) { radixSortLSD(data.data(), data.size()); for (size_t i = 0; i < num_values + 4; ++i) { if (i == 0) { - ASSERT_TRUE(compare_double_with_epsilon(data[i], min, 0.0000001)); + EXPECT_TRUE(compare_double_with_epsilon(data[i], min, 0.0000001)); } else if (i == num_values + 1) { - ASSERT_TRUE(compare_double_with_epsilon(data[i], max, 0.0000001)); + EXPECT_TRUE(compare_double_with_epsilon(data[i], max, 0.0000001)); } else if (i == num_values + 2) { - ASSERT_TRUE(std::isinf(data[i])); + EXPECT_TRUE(std::isinf(data[i])); } else if (i == num_values + 3) { - ASSERT_TRUE(std::isnan(data[i])); + EXPECT_TRUE(std::isnan(data[i])); } else { double tmp = 1.0 * i - 5000 + 0.1; - ASSERT_TRUE(compare_double_with_epsilon(data[i], tmp, 0.0000001)); + EXPECT_TRUE(compare_double_with_epsilon(data[i], tmp, 0.0000001)); } } } @@ -217,23 +205,18 @@ TEST_F(RadixSortTest, TestObjectSort) { RadixSort::executeLSD(data.data(), data.size()); for (size_t i = 0; i < num_values + 4; ++i) { if (i == 0) { - ASSERT_TRUE(compare_float_with_epsilon(data[i].d1, min, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i].d1, min, 0.0000001)); } else if (i == num_values + 1) { - ASSERT_TRUE(compare_float_with_epsilon(data[i].d1, max, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i].d1, max, 0.0000001)); } else if (i == num_values + 2) { - ASSERT_TRUE(std::isinf(data[i].d1)); + EXPECT_TRUE(std::isinf(data[i].d1)); } else if (i == num_values + 3) { - ASSERT_TRUE(std::isnan(data[i].d1)); + EXPECT_TRUE(std::isnan(data[i].d1)); } else { float tmp = 1.0 * i - 5000 + 0.1; - ASSERT_TRUE(compare_float_with_epsilon(data[i].d1, tmp, 0.0000001)); + EXPECT_TRUE(compare_float_with_epsilon(data[i].d1, tmp, 0.0000001)); } } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/rle_encoding_test.cpp b/be/test/util/rle_encoding_test.cpp index 9534ea371d..b9c59653f5 100644 --- a/be/test/util/rle_encoding_test.cpp +++ b/be/test/util/rle_encoding_test.cpp @@ -30,7 +30,7 @@ #include -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/bit_stream_utils.h" #include "util/bit_stream_utils.inline.h" #include "util/bit_util.h" @@ -269,18 +269,18 @@ TEST_F(TestRle, TestBulkPut) { RleDecoder decoder(buffer.data(), encoder.len(), 1); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_TRUE(val); - ASSERT_EQ(10, run_length); + EXPECT_TRUE(val); + EXPECT_EQ(10, run_length); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_FALSE(val); - ASSERT_EQ(7, run_length); + EXPECT_FALSE(val); + EXPECT_EQ(7, run_length); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_TRUE(val); - ASSERT_EQ(20, run_length); + EXPECT_TRUE(val); + EXPECT_EQ(20, run_length); - ASSERT_EQ(0, decoder.GetNextRun(&val, std::numeric_limits::max())); + EXPECT_EQ(0, decoder.GetNextRun(&val, std::numeric_limits::max())); } TEST_F(TestRle, TestGetNextRun) { @@ -308,8 +308,8 @@ TEST_F(TestRle, TestGetNextRun) { run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); run_length = std::min(run_length, count); - ASSERT_EQ(!!(j & 1), val); - ASSERT_EQ(block, run_length); + EXPECT_EQ(!!(j & 1), val); + EXPECT_EQ(block, run_length); count -= run_length; } DCHECK_EQ(count, 0); @@ -353,12 +353,12 @@ TEST_F(TestRle, TestRoundTripRandomSequencesWithRuns) { bool val; while (rem_to_read > 0 && (run_len = decoder.GetNextRun(&val, std::min(kMaxToReadAtOnce, rem_to_read))) != 0) { - ASSERT_LE(run_len, kMaxToReadAtOnce); + EXPECT_LE(run_len, kMaxToReadAtOnce); roundtrip_str.append(run_len, val ? '1' : '0'); rem_to_read -= run_len; } - ASSERT_EQ(string_rep, roundtrip_str); + EXPECT_EQ(string_rep, roundtrip_str); } } TEST_F(TestRle, TestSkip) { @@ -392,35 +392,30 @@ TEST_F(TestRle, TestSkip) { RleDecoder decoder(buffer.data(), encoder.len(), 1); // position before "A" - ASSERT_EQ(3, decoder.Skip(7)); + EXPECT_EQ(3, decoder.Skip(7)); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_TRUE(val); - ASSERT_EQ(1, run_length); + EXPECT_TRUE(val); + EXPECT_EQ(1, run_length); // position before "B" - ASSERT_EQ(7, decoder.Skip(14)); + EXPECT_EQ(7, decoder.Skip(14)); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_FALSE(val); - ASSERT_EQ(2, run_length); + EXPECT_FALSE(val); + EXPECT_EQ(2, run_length); // position before "C" - ASSERT_EQ(18, decoder.Skip(46)); + EXPECT_EQ(18, decoder.Skip(46)); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_TRUE(val); - ASSERT_EQ(10, run_length); + EXPECT_TRUE(val); + EXPECT_EQ(10, run_length); // position before "D" - ASSERT_EQ(24, decoder.Skip(49)); + EXPECT_EQ(24, decoder.Skip(49)); run_length = decoder.GetNextRun(&val, std::numeric_limits::max()); - ASSERT_FALSE(val); - ASSERT_EQ(11, run_length); + EXPECT_FALSE(val); + EXPECT_EQ(11, run_length); encoder.Flush(); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/runtime_profile_test.cpp b/be/test/util/runtime_profile_test.cpp index 76c7f28474..a918420a62 100644 --- a/be/test/util/runtime_profile_test.cpp +++ b/be/test/util/runtime_profile_test.cpp @@ -347,15 +347,3 @@ TEST(CountersTest, BucketCounters) { EXPECT_EQ(val1, buckets[1]->double_value()); } } // namespace impala - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - impala::CpuInfo::Init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/s3_storage_backend_test.cpp b/be/test/util/s3_storage_backend_test.cpp index ab5dd81d5d..b86d00e479 100644 --- a/be/test/util/s3_storage_backend_test.cpp +++ b/be/test/util/s3_storage_backend_test.cpp @@ -17,10 +17,9 @@ #include "util/s3_storage_backend.h" +#include #include - -#include #include #include #include @@ -39,6 +38,9 @@ static const std::string ENDPOINT = "http://s3.bj.bcebos.com"; static const std::string USE_PATH_STYLE = "false"; static const std::string REGION = "bj"; static const std::string BUCKET = "s3://cmy-repo/"; + +#define S3StorageBackendTest DISABLED_S3StorageBackendTest + class S3StorageBackendTest : public testing::Test { public: S3StorageBackendTest() @@ -90,106 +92,98 @@ protected: TEST_F(S3StorageBackendTest, s3_upload) { Status status = _s3->upload(_test_file, _s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _s3->download(_s3_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); status = _s3->upload(_test_file + "_not_found", _s3_base_path + "/Ode_to_the_West_Wind1.txt"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind1.txt"); - ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); } TEST_F(S3StorageBackendTest, s3_direct_upload) { Status status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _s3->download(_s3_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); } TEST_F(S3StorageBackendTest, s3_download) { Status status = _s3->upload(_test_file, _s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string orig_md5sum; FileUtils::md5sum(_test_file, &orig_md5sum); status = _s3->download(_s3_base_path + "/Ode_to_the_West_Wind.txt", _test_file + ".download"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::string download_md5sum; FileUtils::md5sum(_test_file + ".download", &download_md5sum); - ASSERT_EQ(orig_md5sum, download_md5sum); + EXPECT_EQ(orig_md5sum, download_md5sum); status = _s3->download(_s3_base_path + "/Ode_to_the_West_Wind.txt.not_found", _test_file + ".download"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); status = _s3->download(_s3_base_path + "/Ode_to_the_West_Wind.txt.not_found", "/not_permitted.download"); - ASSERT_FALSE(status.ok()); + EXPECT_FALSE(status.ok()); } TEST_F(S3StorageBackendTest, s3_rename) { Status status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->rename(_s3_base_path + "/Ode_to_the_West_Wind.txt", _s3_base_path + "/Ode_to_the_West_Wind.txt.new"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt.new"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(S3StorageBackendTest, s3_list) { Status status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind1.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind2.md5", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); std::map files; status = _s3->list(_s3_base_path, true, false, &files); - ASSERT_TRUE(status.ok()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind") != files.end()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind1") != files.end()); - ASSERT_TRUE(files.find("Ode_to_the_West_Wind2") != files.end()); - ASSERT_EQ(3, files.size()); + EXPECT_TRUE(status.ok()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind") != files.end()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind1") != files.end()); + EXPECT_TRUE(files.find("Ode_to_the_West_Wind2") != files.end()); + EXPECT_EQ(3, files.size()); } TEST_F(S3StorageBackendTest, s3_rm) { Status status = _s3->direct_upload(_s3_base_path + "/Ode_to_the_West_Wind.txt", _content); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->rm(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/Ode_to_the_West_Wind.txt"); - ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); } TEST_F(S3StorageBackendTest, s3_mkdir) { Status status = _s3->mkdir(_s3_base_path + "/dir"); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = _s3->exist(_s3_base_path + "/dir"); - ASSERT_TRUE(status.code() == TStatusCode::NOT_FOUND); + EXPECT_TRUE(status.code() == TStatusCode::NOT_FOUND); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - int ret = 0; - // set ak sk before running it. - // ret = RUN_ALL_TESTS(); - return ret; -} diff --git a/be/test/util/s3_uri_test.cpp b/be/test/util/s3_uri_test.cpp index 1f62102891..3263521e52 100644 --- a/be/test/util/s3_uri_test.cpp +++ b/be/test/util/s3_uri_test.cpp @@ -34,59 +34,54 @@ public: TEST_F(S3URITest, LocationParsing) { std::string p1 = "s3://bucket/path/to/file"; S3URI uri1(p1); - ASSERT_TRUE(uri1.parse()); - ASSERT_EQ("bucket", uri1.get_bucket()); - ASSERT_EQ("path/to/file", uri1.get_key()); + EXPECT_TRUE(uri1.parse()); + EXPECT_EQ("bucket", uri1.get_bucket()); + EXPECT_EQ("path/to/file", uri1.get_key()); } TEST_F(S3URITest, PathLocationParsing) { std::string p1 = "s3://bucket/path/"; S3URI uri1(p1); - ASSERT_TRUE(uri1.parse()); - ASSERT_EQ("bucket", uri1.get_bucket()); - ASSERT_EQ("path/", uri1.get_key()); + EXPECT_TRUE(uri1.parse()); + EXPECT_EQ("bucket", uri1.get_bucket()); + EXPECT_EQ("path/", uri1.get_key()); } TEST_F(S3URITest, EncodedString) { std::string p1 = "s3://bucket/path%20to%20file"; S3URI uri1(p1); - ASSERT_TRUE(uri1.parse()); - ASSERT_EQ("bucket", uri1.get_bucket()); - ASSERT_EQ("path%20to%20file", uri1.get_key()); + EXPECT_TRUE(uri1.parse()); + EXPECT_EQ("bucket", uri1.get_bucket()); + EXPECT_EQ("path%20to%20file", uri1.get_key()); } TEST_F(S3URITest, MissingKey) { std::string p1 = "https://bucket/"; S3URI uri1(p1); - ASSERT_FALSE(uri1.parse()); + EXPECT_FALSE(uri1.parse()); std::string p2 = "s3://bucket/"; S3URI uri2(p2); - ASSERT_FALSE(uri2.parse()); + EXPECT_FALSE(uri2.parse()); } TEST_F(S3URITest, RelativePathing) { std::string p1 = "/path/to/file"; S3URI uri1(p1); - ASSERT_FALSE(uri1.parse()); + EXPECT_FALSE(uri1.parse()); } TEST_F(S3URITest, InvalidScheme) { std::string p1 = "ftp://bucket/"; S3URI uri1(p1); - ASSERT_FALSE(uri1.parse()); + EXPECT_FALSE(uri1.parse()); } TEST_F(S3URITest, QueryAndFragment) { std::string p1 = "s3://bucket/path/to/file?query=foo#bar"; S3URI uri1(p1); - ASSERT_TRUE(uri1.parse()); - ASSERT_EQ("bucket", uri1.get_bucket()); - ASSERT_EQ("path/to/file", uri1.get_key()); + EXPECT_TRUE(uri1.parse()); + EXPECT_EQ("bucket", uri1.get_bucket()); + EXPECT_EQ("path/to/file", uri1.get_key()); } } // end namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/scoped_cleanup_test.cpp b/be/test/util/scoped_cleanup_test.cpp index ade82357a0..b25e5a7b51 100644 --- a/be/test/util/scoped_cleanup_test.cpp +++ b/be/test/util/scoped_cleanup_test.cpp @@ -28,7 +28,7 @@ TEST(ScopedCleanup, TestCleanup) { auto cleanup = MakeScopedCleanup([&]() { var = saved; }); var = 42; } - ASSERT_EQ(0, var); + EXPECT_EQ(0, var); } TEST(ScopedCleanup, TestCleanupMacro) { @@ -38,7 +38,7 @@ TEST(ScopedCleanup, TestCleanupMacro) { SCOPED_CLEANUP({ var = saved; }); var = 42; } - ASSERT_EQ(0, var); + EXPECT_EQ(0, var); } TEST(ScopedCleanup, TestCancelCleanup) { @@ -49,12 +49,7 @@ TEST(ScopedCleanup, TestCancelCleanup) { var = 42; cleanup.cancel(); } - ASSERT_EQ(42, var); + EXPECT_EQ(42, var); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/sm3_test.cpp b/be/test/util/sm3_test.cpp index ff039ff196..9065f54f89 100644 --- a/be/test/util/sm3_test.cpp +++ b/be/test/util/sm3_test.cpp @@ -30,7 +30,7 @@ public: TEST_F(SM3Test, empty) { SM3Digest digest; digest.digest(); - ASSERT_STREQ("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b", + EXPECT_STREQ("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b", digest.hex().c_str()); } @@ -39,14 +39,14 @@ TEST_F(SM3Test, normal) { SM3Digest digest; digest.update("abc", 3); digest.digest(); - ASSERT_STREQ("66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0", + EXPECT_STREQ("66c7f0f462eeedd9d1f2d46bdc10e4e24167c4875cf2f7a2297da02b8f4ba8e0", digest.hex().c_str()); } { SM3Digest digest; digest.update("0123456789", 10); digest.digest(); - ASSERT_STREQ("09093b72553f5d9d622d6c62f5ffd916ee959679b1bd4d169c3e12aa8328e743", + EXPECT_STREQ("09093b72553f5d9d622d6c62f5ffd916ee959679b1bd4d169c3e12aa8328e743", digest.hex().c_str()); } @@ -55,14 +55,9 @@ TEST_F(SM3Test, normal) { digest.update("01234", 5); digest.update("56789", 5); digest.digest(); - ASSERT_STREQ("09093b72553f5d9d622d6c62f5ffd916ee959679b1bd4d169c3e12aa8328e743", + EXPECT_STREQ("09093b72553f5d9d622d6c62f5ffd916ee959679b1bd4d169c3e12aa8328e743", digest.hex().c_str()); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/sort_heap_test.cpp b/be/test/util/sort_heap_test.cpp index cafd3dfece..eb2887eba5 100644 --- a/be/test/util/sort_heap_test.cpp +++ b/be/test/util/sort_heap_test.cpp @@ -88,8 +88,3 @@ TEST_F(SortHeapTest, IntReplaceTest) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/string_parser_test.cpp b/be/test/util/string_parser_test.cpp index 4503ecf61c..c3428a8068 100644 --- a/be/test/util/string_parser_test.cpp +++ b/be/test/util/string_parser_test.cpp @@ -535,14 +535,3 @@ TEST(StringToFloat, BruteForce) { } } // end namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - // if (!doris::config::init(conffile.c_str(), false)) { - // fprintf(stderr, "error read config file. \n"); - // return -1; - // } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/string_util_test.cpp b/be/test/util/string_util_test.cpp index 7d26a8e3cd..da3411e7f6 100644 --- a/be/test/util/string_util_test.cpp +++ b/be/test/util/string_util_test.cpp @@ -31,52 +31,52 @@ public: TEST_F(StringUtilTest, normal) { { - ASSERT_EQ("abc", to_lower("ABC")); - ASSERT_EQ("abc", to_lower("abc")); - ASSERT_EQ("123", to_lower("123")); - ASSERT_EQ("abc,", to_lower("Abc,")); + EXPECT_EQ("abc", to_lower("ABC")); + EXPECT_EQ("abc", to_lower("abc")); + EXPECT_EQ("123", to_lower("123")); + EXPECT_EQ("abc,", to_lower("Abc,")); } { - ASSERT_EQ("ABC", to_upper("ABC")); - ASSERT_EQ("ABC", to_upper("abc")); - ASSERT_EQ("123", to_upper("123")); - ASSERT_EQ("ABC,", to_upper("Abc,")); + EXPECT_EQ("ABC", to_upper("ABC")); + EXPECT_EQ("ABC", to_upper("abc")); + EXPECT_EQ("123", to_upper("123")); + EXPECT_EQ("ABC,", to_upper("Abc,")); } { - ASSERT_EQ("ABC", to_upper("ABC")); - ASSERT_EQ("ABC", to_upper("abc")); - ASSERT_EQ("123", to_upper("123")); - ASSERT_EQ("ABC,", to_upper("Abc,")); + EXPECT_EQ("ABC", to_upper("ABC")); + EXPECT_EQ("ABC", to_upper("abc")); + EXPECT_EQ("123", to_upper("123")); + EXPECT_EQ("ABC,", to_upper("Abc,")); } { - ASSERT_TRUE(iequal("ABC", "ABC")); - ASSERT_TRUE(iequal("ABC", "abc")); - ASSERT_TRUE(iequal("ABC", "ABc")); - ASSERT_TRUE(iequal("123", "123")); - ASSERT_TRUE(iequal("123A,", "123a,")); - ASSERT_FALSE(iequal("12A,", "123a,")); - ASSERT_FALSE(iequal("abc", "ABD")); + EXPECT_TRUE(iequal("ABC", "ABC")); + EXPECT_TRUE(iequal("ABC", "abc")); + EXPECT_TRUE(iequal("ABC", "ABc")); + EXPECT_TRUE(iequal("123", "123")); + EXPECT_TRUE(iequal("123A,", "123a,")); + EXPECT_FALSE(iequal("12A,", "123a,")); + EXPECT_FALSE(iequal("abc", "ABD")); } { - ASSERT_TRUE(starts_with("abcd", "ab")); - ASSERT_TRUE(starts_with("abcd", "abc")); - ASSERT_TRUE(starts_with("abcd", "abcd")); - ASSERT_TRUE(starts_with("1234", "123")); - ASSERT_TRUE(starts_with("a", "a")); - ASSERT_TRUE(starts_with("", "")); - ASSERT_TRUE(starts_with("a", "")); - ASSERT_FALSE(starts_with("", " ")); - ASSERT_FALSE(starts_with("1234", "123a")); + EXPECT_TRUE(starts_with("abcd", "ab")); + EXPECT_TRUE(starts_with("abcd", "abc")); + EXPECT_TRUE(starts_with("abcd", "abcd")); + EXPECT_TRUE(starts_with("1234", "123")); + EXPECT_TRUE(starts_with("a", "a")); + EXPECT_TRUE(starts_with("", "")); + EXPECT_TRUE(starts_with("a", "")); + EXPECT_FALSE(starts_with("", " ")); + EXPECT_FALSE(starts_with("1234", "123a")); } { - ASSERT_TRUE(ends_with("abcd", "cd")); - ASSERT_TRUE(ends_with("abcd", "bcd")); - ASSERT_TRUE(ends_with("abcd", "abcd")); - ASSERT_TRUE(ends_with("1234", "234")); - ASSERT_TRUE(ends_with("a", "a")); - ASSERT_TRUE(ends_with("", "")); - ASSERT_TRUE(ends_with("a", "")); - ASSERT_FALSE(ends_with("", " ")); + EXPECT_TRUE(ends_with("abcd", "cd")); + EXPECT_TRUE(ends_with("abcd", "bcd")); + EXPECT_TRUE(ends_with("abcd", "abcd")); + EXPECT_TRUE(ends_with("1234", "234")); + EXPECT_TRUE(ends_with("a", "a")); + EXPECT_TRUE(ends_with("", "")); + EXPECT_TRUE(ends_with("a", "")); + EXPECT_FALSE(ends_with("", " ")); } { std::vector tokens1; @@ -100,9 +100,9 @@ TEST_F(StringUtilTest, normal) { std::vector empty_tokens; - ASSERT_EQ(join(tokens1, "-"), "xx-abc-xx"); - ASSERT_EQ(join(tokens2, "-"), "-xx-abc--abc-xx-"); - ASSERT_EQ(join(empty_tokens, "-"), ""); + EXPECT_EQ(join(tokens1, "-"), "xx-abc-xx"); + EXPECT_EQ(join(tokens2, "-"), "-xx-abc--abc-xx-"); + EXPECT_EQ(join(empty_tokens, "-"), ""); } { std::string str1("xx-abc--xx-abb"); @@ -112,72 +112,72 @@ TEST_F(StringUtilTest, normal) { const char* pch1 = "xx-abc--xx-abb"; std::vector tokens; tokens = split(str2, "Xx"); - ASSERT_EQ(tokens.size(), 2); - ASSERT_EQ(tokens[0], ""); - ASSERT_EQ(tokens[1], "-abc--xX-abb-xx"); + EXPECT_EQ(tokens.size(), 2); + EXPECT_EQ(tokens[0], ""); + EXPECT_EQ(tokens[1], "-abc--xX-abb-xx"); tokens = split(pch1, "x"); - ASSERT_EQ(tokens.size(), 5); - ASSERT_EQ(tokens[0], ""); - ASSERT_EQ(tokens[1], ""); - ASSERT_EQ(tokens[2], "-abc--"); - ASSERT_EQ(tokens[3], ""); - ASSERT_EQ(tokens[4], "-abb"); + EXPECT_EQ(tokens.size(), 5); + EXPECT_EQ(tokens[0], ""); + EXPECT_EQ(tokens[1], ""); + EXPECT_EQ(tokens[2], "-abc--"); + EXPECT_EQ(tokens[3], ""); + EXPECT_EQ(tokens[4], "-abb"); tokens = split(str1, "-"); - ASSERT_EQ(tokens.size(), 5); - ASSERT_EQ(tokens[0], "xx"); - ASSERT_EQ(tokens[1], "abc"); - ASSERT_EQ(tokens[2], ""); - ASSERT_EQ(tokens[3], "xx"); - ASSERT_EQ(tokens[4], "abb"); + EXPECT_EQ(tokens.size(), 5); + EXPECT_EQ(tokens[0], "xx"); + EXPECT_EQ(tokens[1], "abc"); + EXPECT_EQ(tokens[2], ""); + EXPECT_EQ(tokens[3], "xx"); + EXPECT_EQ(tokens[4], "abb"); tokens = split(str3, ","); - ASSERT_EQ(tokens.size(), 1); - ASSERT_EQ(tokens[0], "xx"); + EXPECT_EQ(tokens.size(), 1); + EXPECT_EQ(tokens[0], "xx"); tokens = split(strempty, "-"); - ASSERT_EQ(tokens.size(), 1); - ASSERT_EQ(tokens[0], ""); + EXPECT_EQ(tokens.size(), 1); + EXPECT_EQ(tokens[0], ""); } { StringCaseSet test_set; test_set.emplace("AbC"); test_set.emplace("AbCD"); test_set.emplace("AbCE"); - ASSERT_EQ(1, test_set.count("abc")); - ASSERT_EQ(1, test_set.count("abcd")); - ASSERT_EQ(1, test_set.count("abce")); - ASSERT_EQ(0, test_set.count("ab")); + EXPECT_EQ(1, test_set.count("abc")); + EXPECT_EQ(1, test_set.count("abcd")); + EXPECT_EQ(1, test_set.count("abce")); + EXPECT_EQ(0, test_set.count("ab")); } { StringCaseUnorderedSet test_set; test_set.emplace("AbC"); test_set.emplace("AbCD"); test_set.emplace("AbCE"); - ASSERT_EQ(1, test_set.count("abc")); - ASSERT_EQ(0, test_set.count("ab")); + EXPECT_EQ(1, test_set.count("abc")); + EXPECT_EQ(0, test_set.count("ab")); } { StringCaseMap test_map; test_map.emplace("AbC", 123); test_map.emplace("AbCD", 234); test_map.emplace("AbCE", 345); - ASSERT_EQ(123, test_map["abc"]); - ASSERT_EQ(234, test_map["aBcD"]); - ASSERT_EQ(345, test_map["abcE"]); - ASSERT_EQ(0, test_map.count("ab")); + EXPECT_EQ(123, test_map["abc"]); + EXPECT_EQ(234, test_map["aBcD"]); + EXPECT_EQ(345, test_map["abcE"]); + EXPECT_EQ(0, test_map.count("ab")); } { StringCaseUnorderedMap test_map; test_map.emplace("AbC", 123); test_map.emplace("AbCD", 234); test_map.emplace("AbCE", 345); - ASSERT_EQ(123, test_map["abc"]); - ASSERT_EQ(234, test_map["aBcD"]); - ASSERT_EQ(345, test_map["abcE"]); - ASSERT_EQ(0, test_map.count("ab")); + EXPECT_EQ(123, test_map["abc"]); + EXPECT_EQ(234, test_map["aBcD"]); + EXPECT_EQ(345, test_map["abcE"]); + EXPECT_EQ(0, test_map.count("ab")); } { std::string ip1 = "192.168.1.1"; @@ -185,23 +185,17 @@ TEST_F(StringUtilTest, normal) { int64_t hash1 = hash_of_path(ip1, "/home/disk1/palo2.HDD"); int64_t hash2 = hash_of_path(ip1, "/home/disk1//palo2.HDD/"); int64_t hash3 = hash_of_path(ip1, "home/disk1/palo2.HDD/"); - ASSERT_EQ(hash1, hash2); - ASSERT_EQ(hash3, hash2); + EXPECT_EQ(hash1, hash2); + EXPECT_EQ(hash3, hash2); int64_t hash4 = hash_of_path(ip1, "/home/disk1/palo2.HDD/"); int64_t hash5 = hash_of_path(ip2, "/home/disk1/palo2.HDD/"); - ASSERT_NE(hash4, hash5); + EXPECT_NE(hash4, hash5); int64_t hash6 = hash_of_path(ip1, "/"); int64_t hash7 = hash_of_path(ip1, "//"); - ASSERT_EQ(hash6, hash7); + EXPECT_EQ(hash6, hash7); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/system_metrics_test.cpp b/be/test/util/system_metrics_test.cpp index 1da93d8b6b..755cacb7e4 100644 --- a/be/test/util/system_metrics_test.cpp +++ b/be/test/util/system_metrics_test.cpp @@ -20,7 +20,7 @@ #include #include "common/config.h" -#include "test_util/test_util.h" +#include "testutil/test_util.h" #include "util/logging.h" #include "util/metrics.h" #include "util/stopwatch.hpp" @@ -43,23 +43,23 @@ extern const char* k_ut_load_avg_path; TEST_F(SystemMetricsTest, normal) { std::string dir_path = GetCurrentRunningDir(); std::string stat_path(dir_path); - stat_path += "/test_data/stat_normal"; + stat_path += "/util/test_data/stat_normal"; LOG(INFO) << stat_path; k_ut_stat_path = stat_path.c_str(); std::string diskstats_path(dir_path); - diskstats_path += "/test_data/diskstats_normal"; + diskstats_path += "/util/test_data/diskstats_normal"; k_ut_diskstats_path = diskstats_path.c_str(); std::string net_dev_path(dir_path); - net_dev_path += "/test_data/net_dev_normal"; + net_dev_path += "/util/test_data/net_dev_normal"; k_ut_net_dev_path = net_dev_path.c_str(); std::string fd_path(dir_path); - fd_path += "/test_data/fd_file_nr"; + fd_path += "/util/test_data/fd_file_nr"; k_ut_fd_path = fd_path.c_str(); std::string net_snmp_path(dir_path); - net_snmp_path += "/test_data/net_snmp_normal"; + net_snmp_path += "/util/test_data/net_snmp_normal"; k_ut_net_snmp_path = net_snmp_path.c_str(); std::string load_avg_path(dir_path); - load_avg_path += "/test_data/load_avg_normal"; + load_avg_path += "/util/test_data/load_avg_normal"; k_ut_load_avg_path = load_avg_path.c_str(); MetricRegistry registry("test"); @@ -70,134 +70,134 @@ TEST_F(SystemMetricsTest, normal) { network_interfaces.emplace_back("xgbe0"); SystemMetrics metrics(®istry, disk_devices, network_interfaces); auto entity = registry.get_entity("server"); - ASSERT_TRUE(entity != nullptr); + EXPECT_TRUE(entity != nullptr); metrics.update(); // cpu Metric* cpu_user = entity->get_metric("cpu_user", "cpu"); - ASSERT_TRUE(cpu_user != nullptr); - // ASSERT_STREQ("57199151", cpu_user->to_string().c_str()); + EXPECT_TRUE(cpu_user != nullptr); + // EXPECT_STREQ("57199151", cpu_user->to_string().c_str()); Metric* cpu_nice = entity->get_metric("cpu_nice", "cpu"); - ASSERT_TRUE(cpu_nice != nullptr); - ASSERT_STREQ("2616310", cpu_nice->to_string().c_str()); + EXPECT_TRUE(cpu_nice != nullptr); + EXPECT_STREQ("2616310", cpu_nice->to_string().c_str()); Metric* cpu_system = entity->get_metric("cpu_system", "cpu"); - ASSERT_TRUE(cpu_system != nullptr); - ASSERT_STREQ("10600935", cpu_system->to_string().c_str()); + EXPECT_TRUE(cpu_system != nullptr); + EXPECT_STREQ("10600935", cpu_system->to_string().c_str()); Metric* cpu_idle = entity->get_metric("cpu_idle", "cpu"); - ASSERT_TRUE(cpu_idle != nullptr); - ASSERT_STREQ("1517505423", cpu_idle->to_string().c_str()); + EXPECT_TRUE(cpu_idle != nullptr); + EXPECT_STREQ("1517505423", cpu_idle->to_string().c_str()); Metric* cpu_iowait = entity->get_metric("cpu_iowait", "cpu"); - ASSERT_TRUE(cpu_iowait != nullptr); - ASSERT_STREQ("2137148", cpu_iowait->to_string().c_str()); + EXPECT_TRUE(cpu_iowait != nullptr); + EXPECT_STREQ("2137148", cpu_iowait->to_string().c_str()); Metric* cpu_irq = entity->get_metric("cpu_irq", "cpu"); - ASSERT_TRUE(cpu_irq != nullptr); - ASSERT_STREQ("0", cpu_irq->to_string().c_str()); + EXPECT_TRUE(cpu_irq != nullptr); + EXPECT_STREQ("0", cpu_irq->to_string().c_str()); Metric* cpu_softirq = entity->get_metric("cpu_soft_irq", "cpu"); - ASSERT_TRUE(cpu_softirq != nullptr); - ASSERT_STREQ("108277", cpu_softirq->to_string().c_str()); + EXPECT_TRUE(cpu_softirq != nullptr); + EXPECT_STREQ("108277", cpu_softirq->to_string().c_str()); Metric* cpu_steal = entity->get_metric("cpu_steal", "cpu"); - ASSERT_TRUE(cpu_steal != nullptr); - ASSERT_STREQ("0", cpu_steal->to_string().c_str()); + EXPECT_TRUE(cpu_steal != nullptr); + EXPECT_STREQ("0", cpu_steal->to_string().c_str()); Metric* cpu_guest = entity->get_metric("cpu_guest", "cpu"); - ASSERT_TRUE(cpu_guest != nullptr); - ASSERT_STREQ("0", cpu_guest->to_string().c_str()); + EXPECT_TRUE(cpu_guest != nullptr); + EXPECT_STREQ("0", cpu_guest->to_string().c_str()); Metric* cpu_guest_nice = entity->get_metric("cpu_guest_nice", "cpu"); - ASSERT_TRUE(cpu_guest_nice != nullptr); - ASSERT_STREQ("0", cpu_guest_nice->to_string().c_str()); + EXPECT_TRUE(cpu_guest_nice != nullptr); + EXPECT_STREQ("0", cpu_guest_nice->to_string().c_str()); // memroy Metric* memory_allocated_bytes = entity->get_metric("memory_allocated_bytes"); - ASSERT_TRUE(memory_allocated_bytes != nullptr); + EXPECT_TRUE(memory_allocated_bytes != nullptr); // network auto net_entity = registry.get_entity("network_metrics.xgbe0", {{"device", "xgbe0"}}); - ASSERT_TRUE(net_entity != nullptr); + EXPECT_TRUE(net_entity != nullptr); Metric* receive_bytes = net_entity->get_metric("network_receive_bytes"); - ASSERT_TRUE(receive_bytes != nullptr); - ASSERT_STREQ("52567436039", receive_bytes->to_string().c_str()); + EXPECT_TRUE(receive_bytes != nullptr); + EXPECT_STREQ("52567436039", receive_bytes->to_string().c_str()); Metric* receive_packets = net_entity->get_metric("network_receive_packets"); - ASSERT_TRUE(receive_packets != nullptr); - ASSERT_STREQ("65066152", receive_packets->to_string().c_str()); + EXPECT_TRUE(receive_packets != nullptr); + EXPECT_STREQ("65066152", receive_packets->to_string().c_str()); Metric* send_bytes = net_entity->get_metric("network_send_bytes"); - ASSERT_TRUE(send_bytes != nullptr); - ASSERT_STREQ("45480856156", send_bytes->to_string().c_str()); + EXPECT_TRUE(send_bytes != nullptr); + EXPECT_STREQ("45480856156", send_bytes->to_string().c_str()); Metric* send_packets = net_entity->get_metric("network_send_packets"); - ASSERT_TRUE(send_packets != nullptr); - ASSERT_STREQ("88277614", send_packets->to_string().c_str()); + EXPECT_TRUE(send_packets != nullptr); + EXPECT_STREQ("88277614", send_packets->to_string().c_str()); // disk auto disk_entity = registry.get_entity("disk_metrics.sda", {{"device", "sda"}}); - ASSERT_TRUE(disk_entity != nullptr); + EXPECT_TRUE(disk_entity != nullptr); Metric* bytes_read = disk_entity->get_metric("disk_bytes_read"); - ASSERT_TRUE(bytes_read != nullptr); - ASSERT_STREQ("20142745600", bytes_read->to_string().c_str()); + EXPECT_TRUE(bytes_read != nullptr); + EXPECT_STREQ("20142745600", bytes_read->to_string().c_str()); Metric* reads_completed = disk_entity->get_metric("disk_reads_completed"); - ASSERT_TRUE(reads_completed != nullptr); - ASSERT_STREQ("759548", reads_completed->to_string().c_str()); + EXPECT_TRUE(reads_completed != nullptr); + EXPECT_STREQ("759548", reads_completed->to_string().c_str()); Metric* read_time_ms = disk_entity->get_metric("disk_read_time_ms"); - ASSERT_TRUE(read_time_ms != nullptr); - ASSERT_STREQ("4308146", read_time_ms->to_string().c_str()); + EXPECT_TRUE(read_time_ms != nullptr); + EXPECT_STREQ("4308146", read_time_ms->to_string().c_str()); Metric* bytes_written = disk_entity->get_metric("disk_bytes_written"); - ASSERT_TRUE(bytes_written != nullptr); - ASSERT_STREQ("1624753500160", bytes_written->to_string().c_str()); + EXPECT_TRUE(bytes_written != nullptr); + EXPECT_STREQ("1624753500160", bytes_written->to_string().c_str()); Metric* writes_completed = disk_entity->get_metric("disk_writes_completed"); - ASSERT_TRUE(writes_completed != nullptr); - ASSERT_STREQ("18282936", writes_completed->to_string().c_str()); + EXPECT_TRUE(writes_completed != nullptr); + EXPECT_STREQ("18282936", writes_completed->to_string().c_str()); Metric* write_time_ms = disk_entity->get_metric("disk_write_time_ms"); - ASSERT_TRUE(write_time_ms != nullptr); - ASSERT_STREQ("1907755230", write_time_ms->to_string().c_str()); + EXPECT_TRUE(write_time_ms != nullptr); + EXPECT_STREQ("1907755230", write_time_ms->to_string().c_str()); Metric* io_time_ms = disk_entity->get_metric("disk_io_time_ms"); - ASSERT_TRUE(io_time_ms != nullptr); - ASSERT_STREQ("19003350", io_time_ms->to_string().c_str()); + EXPECT_TRUE(io_time_ms != nullptr); + EXPECT_STREQ("19003350", io_time_ms->to_string().c_str()); Metric* io_time_weigthed = disk_entity->get_metric("disk_io_time_weigthed"); - ASSERT_TRUE(write_time_ms != nullptr); - ASSERT_STREQ("1912122964", io_time_weigthed->to_string().c_str()); + EXPECT_TRUE(write_time_ms != nullptr); + EXPECT_STREQ("1912122964", io_time_weigthed->to_string().c_str()); // fd Metric* fd_metric = entity->get_metric("fd_num_limit"); - ASSERT_TRUE(fd_metric != nullptr); - ASSERT_STREQ("13052138", fd_metric->to_string().c_str()); + EXPECT_TRUE(fd_metric != nullptr); + EXPECT_STREQ("13052138", fd_metric->to_string().c_str()); fd_metric = entity->get_metric("fd_num_used"); - ASSERT_TRUE(fd_metric != nullptr); - ASSERT_STREQ("19520", fd_metric->to_string().c_str()); + EXPECT_TRUE(fd_metric != nullptr); + EXPECT_STREQ("19520", fd_metric->to_string().c_str()); // net snmp Metric* tcp_retrans_segs = entity->get_metric("snmp_tcp_retrans_segs"); - ASSERT_TRUE(tcp_retrans_segs != nullptr); + EXPECT_TRUE(tcp_retrans_segs != nullptr); Metric* tcp_in_errs = entity->get_metric("snmp_tcp_in_errs"); - ASSERT_TRUE(tcp_in_errs != nullptr); - ASSERT_STREQ("826271", tcp_retrans_segs->to_string().c_str()); - ASSERT_STREQ("12712", tcp_in_errs->to_string().c_str()); + EXPECT_TRUE(tcp_in_errs != nullptr); + EXPECT_STREQ("826271", tcp_retrans_segs->to_string().c_str()); + EXPECT_STREQ("12712", tcp_in_errs->to_string().c_str()); // load average Metric* load_average_1_minutes = entity->get_metric("load_average_1_minutes", "load_average"); - ASSERT_TRUE(fd_metric != nullptr); - ASSERT_STREQ("1.090000", load_average_1_minutes->to_string().c_str()); + EXPECT_TRUE(fd_metric != nullptr); + EXPECT_STREQ("1.090000", load_average_1_minutes->to_string().c_str()); Metric* load_average_5_minutes = entity->get_metric("load_average_5_minutes", "load_average"); - ASSERT_TRUE(fd_metric != nullptr); - ASSERT_STREQ("1.400000", load_average_5_minutes->to_string().c_str()); + EXPECT_TRUE(fd_metric != nullptr); + EXPECT_STREQ("1.400000", load_average_5_minutes->to_string().c_str()); Metric* load_average_15_minutes = entity->get_metric("load_average_15_minutes", "load_average"); - ASSERT_TRUE(fd_metric != nullptr); - ASSERT_STREQ("2.020000", load_average_15_minutes->to_string().c_str()); + EXPECT_TRUE(fd_metric != nullptr); + EXPECT_STREQ("2.020000", load_average_15_minutes->to_string().c_str()); } } TEST_F(SystemMetricsTest, no_proc_file) { std::string dir_path = GetCurrentRunningDir(); std::string stat_path(dir_path); - stat_path += "/test_data/no_stat_normal"; + stat_path += "/util/test_data/no_stat_normal"; LOG(INFO) << stat_path; k_ut_stat_path = stat_path.c_str(); std::string diskstats_path(dir_path); - diskstats_path += "/test_data/no_diskstats_normal"; + diskstats_path += "/util/test_data/no_diskstats_normal"; k_ut_diskstats_path = diskstats_path.c_str(); std::string net_dev_path(dir_path); - net_dev_path += "/test_data/no_net_dev_normal"; + net_dev_path += "/util/test_data/no_net_dev_normal"; k_ut_net_dev_path = net_dev_path.c_str(); k_ut_fd_path = ""; k_ut_net_snmp_path = ""; @@ -211,33 +211,28 @@ TEST_F(SystemMetricsTest, no_proc_file) { SystemMetrics metrics(®istry, disk_devices, network_interfaces); auto entity = registry.get_entity("server"); - ASSERT_TRUE(entity != nullptr); + EXPECT_TRUE(entity != nullptr); // cpu Metric* cpu_user = entity->get_metric("cpu_user", "cpu"); - ASSERT_TRUE(cpu_user != nullptr); - ASSERT_STREQ("0", cpu_user->to_string().c_str()); + EXPECT_TRUE(cpu_user != nullptr); + EXPECT_STREQ("0", cpu_user->to_string().c_str()); // memroy Metric* memory_allocated_bytes = entity->get_metric("memory_allocated_bytes"); - ASSERT_TRUE(memory_allocated_bytes != nullptr); + EXPECT_TRUE(memory_allocated_bytes != nullptr); // network auto net_entity = registry.get_entity("network_metrics.xgbe0", {{"device", "xgbe0"}}); - ASSERT_TRUE(net_entity != nullptr); + EXPECT_TRUE(net_entity != nullptr); Metric* receive_bytes = net_entity->get_metric("network_receive_bytes"); - ASSERT_TRUE(receive_bytes != nullptr); - ASSERT_STREQ("0", receive_bytes->to_string().c_str()); + EXPECT_TRUE(receive_bytes != nullptr); + EXPECT_STREQ("0", receive_bytes->to_string().c_str()); // disk auto disk_entity = registry.get_entity("disk_metrics.sda", {{"device", "sda"}}); - ASSERT_TRUE(disk_entity != nullptr); + EXPECT_TRUE(disk_entity != nullptr); Metric* bytes_read = disk_entity->get_metric("disk_bytes_read"); - ASSERT_TRUE(bytes_read != nullptr); - ASSERT_STREQ("0", bytes_read->to_string().c_str()); + EXPECT_TRUE(bytes_read != nullptr); + EXPECT_STREQ("0", bytes_read->to_string().c_str()); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/tdigest_test.cpp b/be/test/util/tdigest_test.cpp index 84bc4e23be..4ba4d8440a 100644 --- a/be/test/util/tdigest_test.cpp +++ b/be/test/util/tdigest_test.cpp @@ -21,7 +21,7 @@ #include -#include "test_util/test_util.h" +#include "testutil/test_util.h" namespace doris { @@ -49,18 +49,6 @@ protected: // Code here will be called immediately after each test (right // before the destructor). } - - static void SetUpTestCase() { - static bool initialized = false; - if (!initialized) { - FLAGS_logtostderr = true; - google::InstallFailureSignalHandler(); - google::InitGoogleLogging("testing::TDigestTest"); - initialized = true; - } - } - - // Objects declared here can be used by all tests in the test case for Foo. }; static double quantile(const double q, const std::vector& values) { @@ -141,7 +129,7 @@ TEST_F(TDigestTest, FewValues) { EXPECT_EQ(digest.processed().size(), values.size()); - std::vector testValues{0.0, 1.0e-10, qvalue(gen), 0.5, 1.0 - 1e-10, 1.0}; + std::vector testValues {0.0, 1.0e-10, qvalue(gen), 0.5, 1.0 - 1e-10, 1.0}; for (auto q : testValues) { double q1 = quantile(q, values); auto q2 = digest.quantile(q); @@ -169,7 +157,7 @@ TEST_F(TDigestTest, MoreThan2BValues) { } EXPECT_EQ(static_cast(1000 + float(10L * (1 << 28))), digest.totalWeight()); EXPECT_GT(digest.totalWeight(), std::numeric_limits::max()); - std::vector quantiles{0, 0.1, 0.5, 0.9, 1, reals(gen)}; + std::vector quantiles {0, 0.1, 0.5, 0.9, 1, reals(gen)}; std::sort(quantiles.begin(), quantiles.end()); auto prev = std::numeric_limits::min(); for (double q : quantiles) { @@ -183,7 +171,7 @@ TEST_F(TDigestTest, MergeTest) { TDigest digest1(1000); TDigest digest2(1000); - digest2.add(std::vector{&digest1}); + digest2.add(std::vector {&digest1}); } TEST_F(TDigestTest, TestSorted) { @@ -218,8 +206,8 @@ TEST_F(TDigestTest, ExtremeQuantiles) { // [ ?, 10, ?, 20, ?, ?, 50, ?, ? ] // and we expect it to compute approximate missing values: // [ 5, 10, 15, 20, 30, 40, 50, 60, 70] - std::vector values{5.0, 10.0, 15.0, 20.0, 30.0, 35.0, 40.0, 45.0, 50.0}; - std::vector quantiles{1.5 / 9.0, 3.5 / 9.0, 6.5 / 9.0}; + std::vector values {5.0, 10.0, 15.0, 20.0, 30.0, 35.0, 40.0, 45.0, 50.0}; + std::vector quantiles {1.5 / 9.0, 3.5 / 9.0, 6.5 / 9.0}; for (auto q : quantiles) { EXPECT_NEAR(quantile(q, values), digest.quantile(q), 0.01) << "q = " << q; } @@ -247,8 +235,3 @@ TEST_F(TDigestTest, Montonicity) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/thread_group_test.cpp b/be/test/util/thread_group_test.cpp deleted file mode 100644 index dbc8902947..0000000000 --- a/be/test/util/thread_group_test.cpp +++ /dev/null @@ -1,81 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "util/thread_group.h" - -#include -#include -#include - -#include -#include -#include - -#include "common/logging.h" -#include "common/status.h" -#include "gutil/basictypes.h" -#include "gutil/ref_counted.h" -#include "util/countdown_latch.h" -#include "util/runtime_profile.h" - -using std::string; - -namespace doris { - -class ThreadGroupTest : public ::testing::Test { -public: - virtual void SetUp() {} - virtual void TearDown() {} - void increment_count() { - std::unique_lock lock(mutex); - ++count; - } - int count = 0; - std::mutex mutex; -}; - -TEST_F(ThreadGroupTest, TestJoinALL) { - ThreadGroup threads; - for (int i = 0; i < 10; ++i) { - threads.create_thread(&increment_count); - } - threads.join_all(); - EXPECT_EQ(10, count); -} - -TEST_F(ThreadGroupTest, TestThreadIn) { - ThreadGroup threads; - std::thread* th = new std::thread(&increment_count); - threads.add_thread(th); - ASSERT_FALSE(threads.is_this_thread_in()); - threads.join_all(); - ThreadGroup threads2; - std::thread* th2 = new std::thread(&increment_count); - threads2.add_thread(th2); - ASSERT_TRUE(threads2.is_thread_in(th2)); - threads2.remove_thread(th2); - ASSERT_FALSE(threads2.is_thread_in(th2)); - th2->join(); - delete th2; -} - -} // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/thread_pool_test.cpp b/be/test/util/thread_pool_test.cpp deleted file mode 100644 index 0ca9348c45..0000000000 --- a/be/test/util/thread_pool_test.cpp +++ /dev/null @@ -1,84 +0,0 @@ -// Licensed to the Apache Software Foundation (ASF) under one -// or more contributor license agreements. See the NOTICE file -// distributed with this work for additional information -// regarding copyright ownership. The ASF licenses this file -// to you under the Apache License, Version 2.0 (the -// "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, -// software distributed under the License is distributed on an -// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -// KIND, either express or implied. See the License for the -// specific language governing permissions and limitations -// under the License. - -#include "util/thread_pool.hpp" - -#include -#include -#include - -#include -#include - -#include "util/logging.h" - -namespace doris { - -const int NUM_THREADS = 5; -int g_thread_counters[NUM_THREADS]; - -// Per-thread mutex to ensure visibility of counters after thread pool terminates -std::mutex g_thread_mutexes[NUM_THREADS]; - -void count(int thread_id, const int& i) { - std::lock_guard l(g_thread_mutexes[thread_id]); - g_thread_counters[thread_id] += i; -} - -TEST(ThreadPoolTest, BasicTest) { - const int OFFERED_RANGE = 10000; - - for (int i = 0; i < NUM_THREADS; ++i) { - g_thread_counters[i] = 0; - } - - ThreadPool thread_pool(5, 250, count); - - for (int i = 0; i <= OFFERED_RANGE; ++i) { - ASSERT_TRUE(thread_pool.offer(i)); - } - - thread_pool.drain_and_shutdown(); - - // Check that Offer() after Shutdown() will return false - ASSERT_FALSE(thread_pool.offer(-1)); - EXPECT_EQ(0, thread_pool.get_queue_size()); - - int expected_count = (OFFERED_RANGE * (OFFERED_RANGE + 1)) / 2; - int count = 0; - - for (int i = 0; i < NUM_THREADS; ++i) { - std::lock_guard l(g_thread_mutexes[i]); - LOG(INFO) << "Counter " << i << ": " << g_thread_counters[i]; - count += g_thread_counters[i]; - } - - EXPECT_EQ(expected_count, count); -} - -} // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/thread_test.cpp b/be/test/util/thread_test.cpp index 7afb07e83a..56f191d3a4 100644 --- a/be/test/util/thread_test.cpp +++ b/be/test/util/thread_test.cpp @@ -48,18 +48,18 @@ TEST_F(ThreadTest, TestJoinAndWarn) { scoped_refptr holder; Status status = Thread::create("test", "sleeper thread", SleepFor, MonoDelta::FromSeconds(1), &holder); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = ThreadJoiner(holder.get()).warn_after_ms(10).warn_every_ms(100).join(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(ThreadTest, TestFailedJoin) { scoped_refptr holder; Status status = Thread::create("test", "sleeper thread", SleepFor, MonoDelta::FromSeconds(1), &holder); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = ThreadJoiner(holder.get()).give_up_after_ms(50).join(); - ASSERT_TRUE(status.is_aborted()); + EXPECT_TRUE(status.is_aborted()); } static void TryJoinOnSelf() { @@ -71,7 +71,7 @@ static void TryJoinOnSelf() { // Try to join on the thread that is currently running. TEST_F(ThreadTest, TestJoinOnSelf) { scoped_refptr holder; - ASSERT_TRUE(Thread::create("test", "test", TryJoinOnSelf, &holder).ok()); + EXPECT_TRUE(Thread::create("test", "test", TryJoinOnSelf, &holder).ok()); holder->join(); // Actual assertion is done by the thread spawned above. } @@ -80,12 +80,12 @@ TEST_F(ThreadTest, TestDoubleJoinIsNoOp) { scoped_refptr holder; Status status = Thread::create("test", "sleeper thread", SleepFor, MonoDelta::FromSeconds(0), &holder); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); ThreadJoiner joiner(holder.get()); status = joiner.join(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); status = joiner.join(); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } TEST_F(ThreadTest, ThreadStartBenchmark) { @@ -96,11 +96,11 @@ TEST_F(ThreadTest, ThreadStartBenchmark) { SCOPED_RAW_TIMER(&thread_creation_ns); for (auto& t : threads) { Status status = Thread::create("test", "TestCallOnExit", SleepFor, - MonoDelta::FromSeconds(0), &t); - ASSERT_TRUE(status.ok()); + MonoDelta::FromSeconds(0), &t); + EXPECT_TRUE(status.ok()); } } - std::cout << "create 1000 threads use:" << thread_creation_ns << "ns" << std::endl; + LOG(INFO) << "create 1000 threads use:" << thread_creation_ns << "ns"; } { int64_t thread_publish_tid_ns = 0; @@ -110,7 +110,7 @@ TEST_F(ThreadTest, ThreadStartBenchmark) { t->tid(); } } - std::cout << "1000 threads publish TIDS use:" << thread_publish_tid_ns << "ns" << std::endl; + LOG(INFO) << "1000 threads publish TIDS use:" << thread_publish_tid_ns << "ns"; } for (auto& t : threads) { @@ -119,8 +119,3 @@ TEST_F(ThreadTest, ThreadStartBenchmark) { } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/threadpool_test.cpp b/be/test/util/threadpool_test.cpp index a87d2b68c4..77f48348ee 100644 --- a/be/test/util/threadpool_test.cpp +++ b/be/test/util/threadpool_test.cpp @@ -68,7 +68,7 @@ static const char* kDefaultPoolName = "test"; class ThreadPoolTest : public ::testing::Test { public: virtual void SetUp() override { - ASSERT_TRUE(ThreadPoolBuilder(kDefaultPoolName).build(&_pool).ok()); + EXPECT_TRUE(ThreadPoolBuilder(kDefaultPoolName).build(&_pool).ok()); } Status rebuild_pool_with_builder(const ThreadPoolBuilder& builder) { @@ -87,7 +87,7 @@ protected: }; TEST_F(ThreadPoolTest, TestNoTaskOpenClose) { - ASSERT_TRUE(rebuild_pool_with_min_max(4, 4).ok()); + EXPECT_TRUE(rebuild_pool_with_min_max(4, 4).ok()); _pool->shutdown(); } @@ -123,17 +123,17 @@ private: }; TEST_F(ThreadPoolTest, TestSimpleTasks) { - ASSERT_TRUE(rebuild_pool_with_min_max(4, 4).ok()); + EXPECT_TRUE(rebuild_pool_with_min_max(4, 4).ok()); std::atomic counter(0); std::shared_ptr task(new SimpleTask(15, &counter)); - ASSERT_TRUE(_pool->submit_func(std::bind(&simple_task_method, 10, &counter)).ok()); - ASSERT_TRUE(_pool->submit(task).ok()); - ASSERT_TRUE(_pool->submit_func(std::bind(&simple_task_method, 20, &counter)).ok()); - ASSERT_TRUE(_pool->submit(task).ok()); + EXPECT_TRUE(_pool->submit_func(std::bind(&simple_task_method, 10, &counter)).ok()); + EXPECT_TRUE(_pool->submit(task).ok()); + EXPECT_TRUE(_pool->submit_func(std::bind(&simple_task_method, 20, &counter)).ok()); + EXPECT_TRUE(_pool->submit(task).ok()); _pool->wait(); - ASSERT_EQ(10 + 15 + 20 + 15, counter.load()); + EXPECT_EQ(10 + 15 + 20 + 15, counter.load()); _pool->shutdown(); } @@ -152,31 +152,31 @@ private: }; TEST_F(ThreadPoolTest, TestThreadPoolWithNoMinimum) { - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(0) .set_max_threads(3) .set_idle_timeout(MonoDelta::FromMilliseconds(1))) .ok()); // There are no threads to start with. - ASSERT_TRUE(_pool->num_threads() == 0); + EXPECT_TRUE(_pool->num_threads() == 0); // We get up to 3 threads when submitting work. CountDownLatch latch(1); SCOPED_CLEANUP({ latch.count_down(); }); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(2, _pool->num_threads()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(3, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(2, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(3, _pool->num_threads()); // The 4th piece of work gets queued. - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(3, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(3, _pool->num_threads()); // Finish all work latch.count_down(); _pool->wait(); - ASSERT_EQ(0, _pool->_active_threads); + EXPECT_EQ(0, _pool->_active_threads); _pool->shutdown(); - ASSERT_EQ(0, _pool->num_threads()); + EXPECT_EQ(0, _pool->num_threads()); } TEST_F(ThreadPoolTest, TestThreadPoolWithNoMaxThreads) { @@ -186,7 +186,7 @@ TEST_F(ThreadPoolTest, TestThreadPoolWithNoMaxThreads) { const int kNumCPUs = base::NumCPUs(); // Build a threadpool with no limit on the maximum number of threads. - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_max_threads(std::numeric_limits::max())) .ok()); CountDownLatch latch(1); @@ -194,24 +194,24 @@ TEST_F(ThreadPoolTest, TestThreadPoolWithNoMaxThreads) { // submit tokenless tasks. Each should create a new thread. for (int i = 0; i < kNumCPUs * 2; i++) { - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); } - ASSERT_EQ((kNumCPUs * 2), _pool->num_threads()); + EXPECT_EQ((kNumCPUs * 2), _pool->num_threads()); // submit tasks on two tokens. Only two threads should be created. std::unique_ptr t1 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL); std::unique_ptr t2 = _pool->new_token(ThreadPool::ExecutionMode::SERIAL); for (int i = 0; i < kNumCPUs * 2; i++) { ThreadPoolToken* t = (i % 2 == 0) ? t1.get() : t2.get(); - ASSERT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); } - ASSERT_EQ((kNumCPUs * 2) + 2, _pool->num_threads()); + EXPECT_EQ((kNumCPUs * 2) + 2, _pool->num_threads()); // submit more tokenless tasks. Each should create a new thread. for (int i = 0; i < kNumCPUs; i++) { - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); } - ASSERT_EQ((kNumCPUs * 3) + 2, _pool->num_threads()); + EXPECT_EQ((kNumCPUs * 3) + 2, _pool->num_threads()); latch.count_down(); _pool->wait(); @@ -225,7 +225,7 @@ TEST_F(ThreadPoolTest, TestRace) { auto cleanup = MakeScopedCleanup([]() { alarm(0); // Disable alarm on test exit. }); - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(0) .set_max_threads(1) .set_idle_timeout(MonoDelta::FromMicroseconds(1))) @@ -235,9 +235,9 @@ TEST_F(ThreadPoolTest, TestRace) { CountDownLatch l(1); // CountDownLatch::count_down has multiple overloaded version, // so an cast is needed to use std::bind - ASSERT_TRUE(_pool + EXPECT_TRUE(_pool ->submit_func(std::bind( - (void (CountDownLatch::*)())(&CountDownLatch::count_down), &l)) + (void(CountDownLatch::*)())(&CountDownLatch::count_down), &l)) .ok()); l.wait(); // Sleeping a different amount in each iteration makes it more likely to hit @@ -247,37 +247,37 @@ TEST_F(ThreadPoolTest, TestRace) { } TEST_F(ThreadPoolTest, TestVariableSizeThreadPool) { - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(1) .set_max_threads(4) .set_idle_timeout(MonoDelta::FromMilliseconds(1))) .ok()); // There is 1 thread to start with. - ASSERT_EQ(1, _pool->num_threads()); + EXPECT_EQ(1, _pool->num_threads()); // We get up to 4 threads when submitting work. CountDownLatch latch(1); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(1, _pool->num_threads()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(2, _pool->num_threads()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(3, _pool->num_threads()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(4, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(1, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(2, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(3, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(4, _pool->num_threads()); // The 5th piece of work gets queued. - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_EQ(4, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_EQ(4, _pool->num_threads()); // Finish all work latch.count_down(); _pool->wait(); - ASSERT_EQ(0, _pool->_active_threads); + EXPECT_EQ(0, _pool->_active_threads); _pool->shutdown(); - ASSERT_EQ(0, _pool->num_threads()); + EXPECT_EQ(0, _pool->num_threads()); } TEST_F(ThreadPoolTest, TestMaxQueueSize) { - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(1) .set_max_threads(1) .set_max_queue_size(1)) @@ -286,8 +286,8 @@ TEST_F(ThreadPoolTest, TestMaxQueueSize) { CountDownLatch latch(1); // We will be able to submit two tasks: one for max_threads == 1 and one for // max_queue_size == 1. - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); Status s = _pool->submit(SlowTask::new_slow_task(&latch)); CHECK(s.is_service_unavailable()) << "Expected failure due to queue blowout:" << s.to_string(); latch.count_down(); @@ -299,17 +299,17 @@ TEST_F(ThreadPoolTest, TestMaxQueueSize) { // running is used for enforcement. TEST_F(ThreadPoolTest, TestZeroQueueSize) { const int kMaxThreads = 4; - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_max_queue_size(0) .set_max_threads(kMaxThreads)) .ok()); CountDownLatch latch(1); for (int i = 0; i < kMaxThreads; i++) { - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch)).ok()); } Status s = _pool->submit(SlowTask::new_slow_task(&latch)); - ASSERT_TRUE(s.is_service_unavailable()) << s.to_string(); + EXPECT_TRUE(s.is_service_unavailable()) << s.to_string(); latch.count_down(); _pool->wait(); _pool->shutdown(); @@ -328,20 +328,22 @@ TEST_F(ThreadPoolTest, TestZeroQueueSize) { #ifndef THREAD_SANITIZER TEST_F(ThreadPoolTest, TestDeadlocks) { ::testing::FLAGS_gtest_death_test_style = "threadsafe"; - const char* death_msg = "called pool function that would result in deadlock"; - ASSERT_DEATH( + const char* death_msg = + "_ZNSt5_BindIFMN5doris10ThreadPoolEFvvEPS1_EE6__callIvJEJLm0EEEET_OSt5tupleIJDpT0_" + "EESt12_Index_tupleIJXspT1_EEE"; + EXPECT_DEATH( { - ASSERT_TRUE(rebuild_pool_with_min_max(1, 1).ok()); - ASSERT_TRUE( + EXPECT_TRUE(rebuild_pool_with_min_max(1, 1).ok()); + EXPECT_TRUE( _pool->submit_func(std::bind((&ThreadPool::shutdown), _pool.get())).ok()); _pool->wait(); }, death_msg); - ASSERT_DEATH( + EXPECT_DEATH( { - ASSERT_TRUE(rebuild_pool_with_min_max(1, 1).ok()); - ASSERT_TRUE(_pool->submit_func(std::bind(&ThreadPool::wait, _pool.get())).ok()); + EXPECT_TRUE(rebuild_pool_with_min_max(1, 1).ok()); + EXPECT_TRUE(_pool->submit_func(std::bind(&ThreadPool::wait, _pool.get())).ok()); _pool->wait(); }, death_msg); @@ -358,14 +360,14 @@ public: // Test that if a tasks's destructor is slow, it doesn't cause serialization of the tasks // in the queue. TEST_F(ThreadPoolTest, TestSlowDestructor) { - ASSERT_TRUE(rebuild_pool_with_min_max(1, 20).ok()); + EXPECT_TRUE(rebuild_pool_with_min_max(1, 20).ok()); MonoTime start = MonoTime::Now(); for (int i = 0; i < 100; i++) { shared_ptr task(new SlowDestructorRunnable()); - ASSERT_TRUE(_pool->submit(std::move(task)).ok()); + EXPECT_TRUE(_pool->submit(std::move(task)).ok()); } _pool->wait(); - ASSERT_LT((MonoTime::Now() - start).ToSeconds(), 5); + EXPECT_LT((MonoTime::Now() - start).ToSeconds(), 5); } // For test cases that should run with both kinds of tokens. @@ -373,8 +375,8 @@ class ThreadPoolTestTokenTypes : public ThreadPoolTest, public testing::WithParamInterface {}; INSTANTIATE_TEST_SUITE_P(Tokens, ThreadPoolTestTokenTypes, - ::testing::Values(ThreadPool::ExecutionMode::SERIAL, - ThreadPool::ExecutionMode::CONCURRENT)); + ::testing::Values(ThreadPool::ExecutionMode::SERIAL, + ThreadPool::ExecutionMode::CONCURRENT)); TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitAndWait) { std::unique_ptr t = _pool->new_token(GetParam()); @@ -383,9 +385,9 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitAndWait) { SleepFor(MonoDelta::FromMilliseconds(1)); i++; }); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); t->wait(); - ASSERT_EQ(1, i); + EXPECT_EQ(1, i); } TEST_F(ThreadPoolTest, TestTokenSubmitsProcessedSerially) { @@ -402,15 +404,15 @@ TEST_F(ThreadPoolTest, TestTokenSubmitsProcessedSerially) { SleepFor(MonoDelta::FromMilliseconds(sleep_ms)); result += c; }); - ASSERT_TRUE(status.ok()); + EXPECT_TRUE(status.ok()); } t->wait(); - ASSERT_EQ("abcde", result); + EXPECT_EQ("abcde", result); } TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitsProcessedConcurrently) { const int kNumTokens = 5; - ASSERT_TRUE(rebuild_pool_with_builder( + EXPECT_TRUE(rebuild_pool_with_builder( ThreadPoolBuilder(kDefaultPoolName).set_max_threads(kNumTokens)) .ok()); std::vector> tokens; @@ -424,7 +426,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitsProcessedConcurrently) { std::shared_ptr b = std::make_shared(kNumTokens + 1); for (int i = 0; i < kNumTokens; i++) { tokens.emplace_back(_pool->new_token(GetParam())); - ASSERT_TRUE(tokens.back()->submit_func([b]() { b->wait(); }).ok()); + EXPECT_TRUE(tokens.back()->submit_func([b]() { b->wait(); }).ok()); } // This will deadlock if the above tasks weren't all running concurrently. @@ -433,7 +435,7 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmitsProcessedConcurrently) { TEST_F(ThreadPoolTest, TestTokenSubmitsNonSequential) { const int kNumSubmissions = 5; - ASSERT_TRUE(rebuild_pool_with_builder( + EXPECT_TRUE(rebuild_pool_with_builder( ThreadPoolBuilder(kDefaultPoolName).set_max_threads(kNumSubmissions)) .ok()); @@ -446,7 +448,7 @@ TEST_F(ThreadPoolTest, TestTokenSubmitsNonSequential) { shared_ptr b = std::make_shared(kNumSubmissions + 1); std::unique_ptr t = _pool->new_token(ThreadPool::ExecutionMode::CONCURRENT); for (int i = 0; i < kNumSubmissions; i++) { - ASSERT_TRUE(t->submit_func([b]() { b->wait(); }).ok()); + EXPECT_TRUE(t->submit_func([b]() { b->wait(); }).ok()); } // This will deadlock if the above tasks weren't all running concurrently. @@ -454,7 +456,7 @@ TEST_F(ThreadPoolTest, TestTokenSubmitsNonSequential) { } TEST_P(ThreadPoolTestTokenTypes, TestTokenShutdown) { - ASSERT_TRUE( + EXPECT_TRUE( rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName).set_max_threads(4)).ok()); std::unique_ptr t1(_pool->new_token(GetParam())); @@ -470,10 +472,10 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenShutdown) { }); for (int i = 0; i < 3; i++) { - ASSERT_TRUE(t1->submit_func([&]() { l1.wait(); }).ok()); + EXPECT_TRUE(t1->submit_func([&]() { l1.wait(); }).ok()); } for (int i = 0; i < 3; i++) { - ASSERT_TRUE(t2->submit_func([&]() { l2.wait(); }).ok()); + EXPECT_TRUE(t2->submit_func([&]() { l2.wait(); }).ok()); } // Unblock all of t1's tasks, but not t2's tasks. @@ -483,8 +485,8 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenShutdown) { t1->shutdown(); // We can no longer submit to t1 but we can still submit to t2. - ASSERT_TRUE(t1->submit_func([]() {}).is_service_unavailable()); - ASSERT_TRUE(t2->submit_func([]() {}).ok()); + EXPECT_TRUE(t1->submit_func([]() {}).is_service_unavailable()); + EXPECT_TRUE(t2->submit_func([]() {}).ok()); // Unblock t2's tasks. l2.count_down(); @@ -515,14 +517,14 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenWaitForAll) { // Half of the submissions will be token-less, and half will use a token. if (i % 2 == 0) { - ASSERT_TRUE(_pool->submit_func(task).ok()); + EXPECT_TRUE(_pool->submit_func(task).ok()); } else { int token_idx = r.Next() % tokens.size(); - ASSERT_TRUE(tokens[token_idx]->submit_func(task).ok()); + EXPECT_TRUE(tokens[token_idx]->submit_func(task).ok()); } } _pool->wait(); - ASSERT_EQ(kNumSubmissions, v); + EXPECT_EQ(kNumSubmissions, v); } TEST_F(ThreadPoolTest, TestFuzz) { @@ -546,7 +548,7 @@ TEST_F(ThreadPoolTest, TestFuzz) { if (op < 40) { // submit without a token. int sleep_ms = r.Next() % 5; - ASSERT_TRUE(_pool->submit_func([sleep_ms]() { + EXPECT_TRUE(_pool->submit_func([sleep_ms]() { // Sleep a little first to increase task overlap. SleepFor(MonoDelta::FromMilliseconds(sleep_ms)); }).ok()); @@ -561,7 +563,7 @@ TEST_F(ThreadPoolTest, TestFuzz) { // Sleep a little first to increase task overlap. SleepFor(MonoDelta::FromMilliseconds(sleep_ms)); }); - ASSERT_TRUE(s.ok() || s.is_service_unavailable()); + EXPECT_TRUE(s.ok() || s.is_service_unavailable()); } else if (op < 85) { // Allocate a token with a randomly selected policy. ThreadPool::ExecutionMode mode = r.Next() % 2 ? ThreadPool::ExecutionMode::SERIAL @@ -592,8 +594,8 @@ TEST_F(ThreadPoolTest, TestFuzz) { tokens.erase(it); } else { // Wait on everything. - ASSERT_LT(op, 100); - ASSERT_GE(op, 98); + EXPECT_LT(op, 100); + EXPECT_GE(op, 98); _pool->wait(); } } @@ -606,7 +608,7 @@ TEST_F(ThreadPoolTest, TestFuzz) { } TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmissionsAdhereToMaxQueueSize) { - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(1) .set_max_threads(1) .set_max_queue_size(1)) @@ -617,10 +619,10 @@ TEST_P(ThreadPoolTestTokenTypes, TestTokenSubmissionsAdhereToMaxQueueSize) { SCOPED_CLEANUP({ latch.count_down(); }); // We will be able to submit two tasks: one for max_threads == 1 and one for // max_queue_size == 1. - ASSERT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); - ASSERT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); + EXPECT_TRUE(t->submit(SlowTask::new_slow_task(&latch)).ok()); Status s = t->submit(SlowTask::new_slow_task(&latch)); - ASSERT_TRUE(s.is_service_unavailable()); + EXPECT_TRUE(s.is_service_unavailable()); } TEST_F(ThreadPoolTest, TestTokenConcurrency) { @@ -753,11 +755,9 @@ TEST_F(ThreadPoolTest, TestTokenConcurrency) { } static void MyFunc(int idx, int n) { - std::cout << idx << ", " << std::this_thread::get_id() << " before sleep " << n << " seconds" - << std::endl; + LOG(INFO) << idx << ", " << std::this_thread::get_id() << " before sleep " << n << " seconds"; sleep(n); - std::cout << idx << ", " << std::this_thread::get_id() << " after sleep " << n << " seconds" - << std::endl; + LOG(INFO) << idx << ", " << std::this_thread::get_id() << " after sleep " << n << " seconds"; } TEST_F(ThreadPoolTest, TestNormal) { @@ -774,70 +774,65 @@ TEST_F(ThreadPoolTest, TestNormal) { for (int i = 0; i < 10; i++) { token1->submit_func(std::bind(&MyFunc, i, 1)); } - std::cout << "after submit 1" << std::endl; token1->wait(); - ASSERT_EQ(0, token1->num_tasks()); + EXPECT_EQ(0, token1->num_tasks()); std::unique_ptr token2 = thread_pool->new_token(ThreadPool::ExecutionMode::CONCURRENT, 20); for (int i = 0; i < 10; i++) { token2->submit_func(std::bind(&MyFunc, i, 1)); } - std::cout << "after submit 2" << std::endl; token2->wait(); - ASSERT_EQ(0, token2->num_tasks()); + EXPECT_EQ(0, token2->num_tasks()); std::unique_ptr token3 = thread_pool->new_token(ThreadPool::ExecutionMode::CONCURRENT, 1); for (int i = 0; i < 10; i++) { token3->submit_func(std::bind(&MyFunc, i, 1)); } - std::cout << "after submit 3" << std::endl; token3->wait(); - ASSERT_EQ(0, token3->num_tasks()); + EXPECT_EQ(0, token3->num_tasks()); std::unique_ptr token4 = thread_pool->new_token(ThreadPool::ExecutionMode::SERIAL); for (int i = 0; i < 10; i++) { token4->submit_func(std::bind(&MyFunc, i, 1)); } - std::cout << "after submit 4" << std::endl; token4->wait(); - ASSERT_EQ(0, token4->num_tasks()); + EXPECT_EQ(0, token4->num_tasks()); std::unique_ptr token5 = thread_pool->new_token(ThreadPool::ExecutionMode::CONCURRENT, 20); for (int i = 0; i < 10; i++) { token5->submit_func(std::bind(&MyFunc, i, 1)); } - std::cout << "after submit 5" << std::endl; token5->shutdown(); - ASSERT_EQ(0, token5->num_tasks()); + EXPECT_EQ(0, token5->num_tasks()); } TEST_F(ThreadPoolTest, TestThreadPoolDynamicAdjustMaximumMinimum) { - ASSERT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) + EXPECT_TRUE(rebuild_pool_with_builder(ThreadPoolBuilder(kDefaultPoolName) .set_min_threads(3) .set_max_threads(3) .set_idle_timeout(MonoDelta::FromMilliseconds(1))) .ok()); - ASSERT_EQ(3, _pool->min_threads()); - ASSERT_EQ(3, _pool->max_threads()); - ASSERT_EQ(3, _pool->num_threads()); + EXPECT_EQ(3, _pool->min_threads()); + EXPECT_EQ(3, _pool->max_threads()); + EXPECT_EQ(3, _pool->num_threads()); - ASSERT_TRUE(!_pool->set_min_threads(4).ok()); - ASSERT_TRUE(!_pool->set_max_threads(2).ok()); + EXPECT_TRUE(!_pool->set_min_threads(4).ok()); + EXPECT_TRUE(!_pool->set_max_threads(2).ok()); - ASSERT_TRUE(_pool->set_min_threads(2).ok()); - ASSERT_EQ(2, _pool->min_threads()); - ASSERT_TRUE(_pool->set_max_threads(4).ok()); - ASSERT_EQ(4, _pool->max_threads()); + EXPECT_TRUE(_pool->set_min_threads(2).ok()); + EXPECT_EQ(2, _pool->min_threads()); + EXPECT_TRUE(_pool->set_max_threads(4).ok()); + EXPECT_EQ(4, _pool->max_threads()); - ASSERT_TRUE(_pool->set_min_threads(3).ok()); - ASSERT_EQ(3, _pool->min_threads()); - ASSERT_TRUE(_pool->set_max_threads(3).ok()); - ASSERT_EQ(3, _pool->max_threads()); + EXPECT_TRUE(_pool->set_min_threads(3).ok()); + EXPECT_EQ(3, _pool->min_threads()); + EXPECT_TRUE(_pool->set_max_threads(3).ok()); + EXPECT_EQ(3, _pool->max_threads()); CountDownLatch latch_1(1); CountDownLatch latch_2(1); @@ -848,37 +843,37 @@ TEST_F(ThreadPoolTest, TestThreadPoolDynamicAdjustMaximumMinimum) { CountDownLatch latch_7(1); CountDownLatch latch_8(1); CountDownLatch latch_9(1); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_1)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_2)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_3)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_4)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_5)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_6)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_7)).ok()); - ASSERT_EQ(3, _pool->num_threads()); - ASSERT_TRUE(_pool->set_max_threads(4).ok()); - ASSERT_EQ(4, _pool->max_threads()); - ASSERT_EQ(4, _pool->num_threads()); - ASSERT_TRUE(_pool->set_max_threads(5).ok()); - ASSERT_EQ(5, _pool->max_threads()); - ASSERT_EQ(5, _pool->num_threads()); - ASSERT_TRUE(_pool->set_max_threads(6).ok()); - ASSERT_EQ(6, _pool->max_threads()); - ASSERT_EQ(6, _pool->num_threads()); - ASSERT_TRUE(_pool->set_max_threads(4).ok()); - ASSERT_EQ(4, _pool->max_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_1)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_2)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_3)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_4)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_5)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_6)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_7)).ok()); + EXPECT_EQ(3, _pool->num_threads()); + EXPECT_TRUE(_pool->set_max_threads(4).ok()); + EXPECT_EQ(4, _pool->max_threads()); + EXPECT_EQ(4, _pool->num_threads()); + EXPECT_TRUE(_pool->set_max_threads(5).ok()); + EXPECT_EQ(5, _pool->max_threads()); + EXPECT_EQ(5, _pool->num_threads()); + EXPECT_TRUE(_pool->set_max_threads(6).ok()); + EXPECT_EQ(6, _pool->max_threads()); + EXPECT_EQ(6, _pool->num_threads()); + EXPECT_TRUE(_pool->set_max_threads(4).ok()); + EXPECT_EQ(4, _pool->max_threads()); latch_1.count_down(); latch_2.count_down(); latch_3.count_down(); SleepFor(MonoDelta::FromMilliseconds(500)); - ASSERT_EQ(4, _pool->num_threads()); + EXPECT_EQ(4, _pool->num_threads()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_8)).ok()); - ASSERT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_9)).ok()); - ASSERT_EQ(4, _pool->num_threads()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_8)).ok()); + EXPECT_TRUE(_pool->submit(SlowTask::new_slow_task(&latch_9)).ok()); + EXPECT_EQ(4, _pool->num_threads()); - ASSERT_TRUE(_pool->set_min_threads(2).ok()); - ASSERT_EQ(2, _pool->min_threads()); + EXPECT_TRUE(_pool->set_min_threads(2).ok()); + EXPECT_EQ(2, _pool->min_threads()); latch_4.count_down(); latch_5.count_down(); @@ -887,16 +882,11 @@ TEST_F(ThreadPoolTest, TestThreadPoolDynamicAdjustMaximumMinimum) { latch_8.count_down(); latch_9.count_down(); SleepFor(MonoDelta::FromMilliseconds(500)); - ASSERT_EQ(2, _pool->num_threads()); + EXPECT_EQ(2, _pool->num_threads()); _pool->wait(); _pool->shutdown(); - ASSERT_EQ(0, _pool->num_threads()); + EXPECT_EQ(0, _pool->num_threads()); } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/trace_test.cpp b/be/test/util/trace_test.cpp index cb10226928..d8f61f49cf 100644 --- a/be/test/util/trace_test.cpp +++ b/be/test/util/trace_test.cpp @@ -73,7 +73,7 @@ TEST_F(TraceTest, TestBasic) { TRACE_TO(t, "goodbye $0, $1", "cruel world", 54321); std::string result = XOutDigits(t->DumpToString(Trace::NO_FLAGS)); - ASSERT_EQ( + EXPECT_EQ( "XXXX XX:XX:XX.XXXXXX trace_test.cpp:XX] hello world, XXXXX\n" "XXXX XX:XX:XX.XXXXXX trace_test.cpp:XX] goodbye cruel world, XXXXX\n", result); @@ -138,8 +138,3 @@ TEST_F(TraceTest, TestTraceMetrics) { } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/tuple_row_zorder_compare_test.cpp b/be/test/util/tuple_row_zorder_compare_test.cpp index 11ece77ac9..4399b505f1 100644 --- a/be/test/util/tuple_row_zorder_compare_test.cpp +++ b/be/test/util/tuple_row_zorder_compare_test.cpp @@ -15,733 +15,780 @@ // specific language governing permissions and limitations // under the License. -#include "util/json_util.h" +#include "util/tuple_row_zorder_compare.h" + #include + #include "common/logging.h" #include "exec/sort_exec_exprs.h" #include "exprs/expr.h" #include "exprs/expr_context.h" +#include "olap/memtable.h" +#include "olap/row.h" +#include "olap/schema.h" #include "runtime/descriptors.h" +#include "runtime/large_int_value.h" #include "runtime/raw_value.h" #include "runtime/tuple.h" #include "runtime/tuple_row.h" -#include "olap/schema.h" -#include "olap/row.h" -#include "util/tuple_row_zorder_compare.h" -#include "runtime/large_int_value.h" -#include "olap/memtable.h" +#include "util/json_util.h" namespace doris { - class TupleRowZOrderCompareTest : public testing::Test { - public: - ObjectPool _agg_buffer_pool; - std::unique_ptr _mem_tracker; - std::unique_ptr _buffer_mem_pool; +class TupleRowZOrderCompareTest : public testing::Test { +public: + ObjectPool _agg_buffer_pool; + std::unique_ptr _mem_tracker; + std::unique_ptr _buffer_mem_pool; - TupleRowZOrderCompareTest() { - _mem_tracker.reset(new MemTracker(-1)); - _buffer_mem_pool.reset(new MemPool(_mem_tracker.get())); - } + TupleRowZOrderCompareTest() { + _mem_tracker.reset(new MemTracker(-1)); + _buffer_mem_pool.reset(new MemPool(_mem_tracker.get())); + } - ~TupleRowZOrderCompareTest() = default; + ~TupleRowZOrderCompareTest() = default; - template - int CompareInt8Test(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::TINYINT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int8_t) + 1*i; - - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int8_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); + template + int CompareInt8Test(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::TINYINT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int8_t) + 1 * i; - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_TINYINT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_TINYINT, true); + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int8_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int8_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_TINYINT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_TINYINT, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int8_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int8_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int8_t), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int8_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareInt16Test(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::SMALLINT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int8_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int16_t) + 1 * i; - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int8_t), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int8_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int16_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + + slot_descs.emplace_back(slot_desc); } - template - int CompareInt16Test(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::SMALLINT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int16_t) + 1 * i; + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true); - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int16_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - - slot_descs.emplace_back(slot_desc); + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int16_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int16_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int16_t), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int16_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareIntTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::INT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int32_t) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int32_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true); - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int16_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int32_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int32_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int32_t), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int32_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareInt64Test(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::BIGINT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int16_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int16_t), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int16_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int64_t) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int64_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); } - template - int CompareIntTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::INT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int32_t) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int32_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BIGINT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BIGINT, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int64_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int64_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int64_t), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int64_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareInt128Test(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::LARGEINT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int128_t) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int128_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_LARGEINT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_LARGEINT, true); - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int32_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int128_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int128_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int128_t), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int128_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareFloatTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::FLOAT); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int32_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int32_t), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int32_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(float) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(float) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); } - template - int CompareInt64Test(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::BIGINT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int64_t) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int64_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_FLOAT, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_FLOAT, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(float), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(float)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(float), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(float)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareDoubleTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::DOUBLE); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(double) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(double) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BIGINT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BIGINT, true); + slot_descs.emplace_back(slot_desc); + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int64_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DOUBLE, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DOUBLE, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(double), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(double)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(double), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(double)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareBoolTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::BOOLEAN); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int64_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int64_t), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int64_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(bool) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(bool) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); } - template - int CompareInt128Test(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::LARGEINT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int128_t) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int128_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BOOL, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BOOL, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(bool), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(bool)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(bool), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(bool)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareCharTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::VARCHAR); + scalar_type.__set_len(65535); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(StringValue) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(StringValue) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_LARGEINT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_LARGEINT, true); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_VARCHAR, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_VARCHAR, true); - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int128_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(StringValue), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(StringValue)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(StringValue), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(StringValue)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareDateTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::DATETIME); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int128_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int128_t), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int128_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(DateTimeValue) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(DateTimeValue) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); } - template - int CompareFloatTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::FLOAT); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(float) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(float) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DATETIME, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DATETIME, true); + + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(DateTimeValue), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); + } + FillMem(lhs_tuple, 1, lval1, lval2); + uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num * sizeof(char) + + col_num * sizeof(DateTimeValue)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(DateTimeValue), + _buffer_mem_pool.get()); + FillMem(rhs_tuple, 1, rval1, rval2); + uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num * sizeof(char) + + col_num * sizeof(DateTimeValue)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } + + template + int CompareDecimalTest(T lval1, T lval2, T rval1, T rval2) { + int col_num = 2; + std::vector slot_descs; + for (int i = 1; i <= col_num; i++) { + TSlotDescriptor slot_desc; + slot_desc.id = i; + slot_desc.parent = 0; + TTypeDesc type; + { + TTypeNode node; + node.__set_type(TTypeNodeType::SCALAR); + TScalarType scalar_type; + scalar_type.__set_type(TPrimitiveType::type::DECIMALV2); + scalar_type.__isset.precision = true; + scalar_type.__isset.scale = true; + scalar_type.__set_precision(-1); + scalar_type.__set_scale(-1); + node.__set_scalar_type(scalar_type); + type.types.push_back(node); } - - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_FLOAT, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_FLOAT, true); - - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(float), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(float)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(float), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(float)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + slot_desc.slotType = type; + slot_desc.columnPos = i; + slot_desc.byteOffset = (i - 1) * sizeof(int128_t) + 1 * i; + slot_desc.nullIndicatorByte = 0 + (i - 1) * sizeof(int128_t) + 1 * (i - 1); + slot_desc.nullIndicatorBit = 1; + std::ostringstream ss; + ss << "col_" << i; + slot_desc.colName = ss.str(); + slot_desc.slotIdx = i; + slot_desc.isMaterialized = true; + slot_descs.emplace_back(slot_desc); } - template - int CompareDoubleTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::DOUBLE); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(double) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(double) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - - slot_descs.emplace_back(slot_desc); - } + std::vector col_schemas; + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DECIMAL, true); + col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DECIMAL, true); - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DOUBLE, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DOUBLE, true); - - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(double), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(double)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(double), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(double)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + Schema schema = Schema(col_schemas, col_num); + TupleRowZOrderComparator comparator(&schema, 2); + Tuple* lhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int128_t), + _buffer_mem_pool.get()); + if (IS_FIRST_SLOT_NULL) { + lhs_tuple->set_null(NullIndicatorOffset(0, 1)); } + FillMem(lhs_tuple, 1, lval1.value(), lval2.value()); + uint8_t* lhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int128_t)); + ContiguousRow lhs_row(&schema, lhs_tuple_buf); + tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - template - int CompareBoolTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::BOOLEAN); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(bool) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(bool) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); - } + Tuple* rhs_tuple = Tuple::create(col_num * sizeof(char) + col_num * sizeof(int128_t), + _buffer_mem_pool.get()); - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BOOL, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_BOOL, true); + FillMem(rhs_tuple, 1, rval1.value(), rval2.value()); + uint8_t* rhs_tuple_buf = + _buffer_mem_pool->allocate(col_num * sizeof(char) + col_num * sizeof(int128_t)); + ContiguousRow rhs_row(&schema, rhs_tuple_buf); + tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); + int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), + reinterpret_cast(rhs_row.row_ptr())); + return result; + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(bool), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(bool)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); - - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(bool), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(bool)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; + void tuple_to_row(const Schema& schema, const vector& slot_descs, + const Tuple* tuple, ContiguousRow* row, MemPool* mem_pool) { + for (size_t i = 0; i < slot_descs.size(); ++i) { + auto cell = row->cell(i); + const SlotDescriptor& slot = slot_descs[i]; + bool is_null = tuple->is_null(slot.null_indicator_offset()); + const void* value = tuple->get_slot(slot.tuple_offset()); + schema.column(i)->consume(&cell, (const char*)value, is_null, mem_pool, + &_agg_buffer_pool); } + } - template - int CompareCharTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::VARCHAR); - scalar_type.__set_len(65535); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(StringValue) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(StringValue) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); - } + template + void FillMem(Tuple* tuple_mem, int idx, T val) { + memcpy(tuple_mem->get_slot(idx), &val, sizeof(T)); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_VARCHAR, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_VARCHAR, true); + template + void FillMem(Tuple* tuple_mem, int idx, T val, Args... args) { + // Use memcpy to avoid gcc generating unaligned instructions like movaps + // for int128_t. They will raise SegmentFault when addresses are not + // aligned to 16 bytes. + memcpy(tuple_mem->get_slot(idx), &val, sizeof(T)); + FillMem(tuple_mem, idx + sizeof(T) + 1, args...); + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(StringValue), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(StringValue)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + template + int Int8Int8Test(int8_t lval1, int8_t lval2, int8_t rval1, int8_t rval2) { + return CompareInt8Test(lval1, lval2, rval1, rval2); + } - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(StringValue), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(StringValue)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; - } + template + int Int16Int16Test(int16_t lval1, int16_t lval2, int16_t rval1, int16_t rval2) { + return CompareInt16Test(lval1, lval2, rval1, rval2); + } - template - int CompareDateTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::DATETIME); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(DateTimeValue) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(DateTimeValue) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); - } + template + int IntIntTest(int32_t lval1, int32_t lval2, int32_t rval1, int32_t rval2) { + return CompareIntTest(lval1, lval2, rval1, rval2); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DATETIME, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DATETIME, true); + template + int Int64Int64Test(int64_t lval1, int64_t lval2, int64_t rval1, int64_t rval2) { + return CompareInt64Test(lval1, lval2, rval1, rval2); + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(DateTimeValue), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1, lval2); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(DateTimeValue)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + template + int Int128Int128Test(int128_t lval1, int128_t lval2, int128_t rval1, int128_t rval2) { + return CompareInt128Test(lval1, lval2, rval1, rval2); + } - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(DateTimeValue), _buffer_mem_pool.get()); - FillMem(rhs_tuple, 1, rval1, rval2); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(DateTimeValue)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; - } + template + int FloatFloatTest(float lval1, float lval2, float rval1, float rval2) { + return CompareFloatTest(lval1, lval2, rval1, rval2); + } - template - int CompareDecimalTest(T lval1, T lval2, T rval1, T rval2) { - int col_num = 2; - std::vector slot_descs; - for (int i = 1; i <= col_num; i++) { - TSlotDescriptor slot_desc; - slot_desc.id = i; - slot_desc.parent = 0; - TTypeDesc type; - { - TTypeNode node; - node.__set_type(TTypeNodeType::SCALAR); - TScalarType scalar_type; - scalar_type.__set_type(TPrimitiveType::type::DECIMALV2); - scalar_type.__isset.precision = true; - scalar_type.__isset.scale = true; - scalar_type.__set_precision(-1); - scalar_type.__set_scale(-1); - node.__set_scalar_type(scalar_type); - type.types.push_back(node); - } - slot_desc.slotType = type; - slot_desc.columnPos = i; - slot_desc.byteOffset = (i-1)*sizeof(int128_t) + 1*i; - slot_desc.nullIndicatorByte = 0+(i-1)*sizeof(int128_t) + 1*(i-1); - slot_desc.nullIndicatorBit = 1; - std::ostringstream ss; - ss << "col_" << i; - slot_desc.colName = ss.str(); - slot_desc.slotIdx = i; - slot_desc.isMaterialized = true; - slot_descs.emplace_back(slot_desc); - } + template + int DoubleDoubleTest(double lval1, double lval2, double rval1, double rval2) { + return CompareDoubleTest(lval1, lval2, rval1, rval2); + } - std::vector col_schemas; - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DECIMAL, true); - col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_DECIMAL, true); + template + int BoolBoolTest(bool lval1, bool lval2, bool rval1, bool rval2) { + return CompareBoolTest(lval1, lval2, rval1, rval2); + } - Schema schema = Schema(col_schemas, col_num); - TupleRowZOrderComparator comparator(&schema, 2); - Tuple* lhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int128_t), _buffer_mem_pool.get()); - if (IS_FIRST_SLOT_NULL) { - lhs_tuple->set_null(NullIndicatorOffset(0, 1)); - } - FillMem(lhs_tuple, 1, lval1.value(), lval2.value()); - uint8_t* lhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int128_t)); - ContiguousRow lhs_row(&schema, lhs_tuple_buf); - tuple_to_row(schema, slot_descs, lhs_tuple, &lhs_row, _buffer_mem_pool.get()); + template + int CharCharTest(StringValue lval1, StringValue lval2, StringValue rval1, StringValue rval2) { + return CompareCharTest(lval1, lval2, rval1, rval2); + } - Tuple* rhs_tuple = Tuple::create(col_num*sizeof(char) + col_num*sizeof(int128_t), _buffer_mem_pool.get()); + template + int DateDateTest(DateTimeValue lval1, DateTimeValue lval2, DateTimeValue rval1, + DateTimeValue rval2) { + return CompareDateTest(lval1, lval2, rval1, rval2); + } - FillMem(rhs_tuple, 1, rval1.value(), rval2.value()); - uint8_t* rhs_tuple_buf = _buffer_mem_pool->allocate(col_num*sizeof(char) + col_num*sizeof(int128_t)); - ContiguousRow rhs_row(&schema, rhs_tuple_buf); - tuple_to_row(schema, slot_descs, rhs_tuple, &rhs_row, _buffer_mem_pool.get()); - int result = comparator.compare(reinterpret_cast(lhs_row.row_ptr()), - reinterpret_cast(rhs_row.row_ptr())); - return result; - } - - void tuple_to_row(const Schema& schema, const vector& slot_descs, const Tuple* tuple, - ContiguousRow* row, MemPool* mem_pool) { - for (size_t i = 0; i < slot_descs.size(); ++i) { - auto cell = row->cell(i); - const SlotDescriptor& slot = slot_descs[i]; - bool is_null = tuple->is_null(slot.null_indicator_offset()); - const void* value = tuple->get_slot(slot.tuple_offset()); - schema.column(i)->consume(&cell, (const char*)value, is_null, mem_pool, - &_agg_buffer_pool); - } - } - - template - void FillMem(Tuple* tuple_mem, int idx, T val) { - memcpy(tuple_mem->get_slot(idx), &val, sizeof(T)); - } - - template - void FillMem(Tuple* tuple_mem, int idx, T val, Args... args) { - // Use memcpy to avoid gcc generating unaligned instructions like movaps - // for int128_t. They will raise SegmentFault when addresses are not - // aligned to 16 bytes. - memcpy(tuple_mem->get_slot(idx), &val, sizeof(T)); - FillMem(tuple_mem, idx + sizeof(T)+1, args...); - } - - template - int Int8Int8Test(int8_t lval1, int8_t lval2, int8_t rval1, int8_t rval2) { - return CompareInt8Test(lval1, lval2, rval1, rval2); - } - - template - int Int16Int16Test(int16_t lval1, int16_t lval2, int16_t rval1, int16_t rval2) { - return CompareInt16Test(lval1, lval2, rval1, rval2); - } - - template - int IntIntTest(int32_t lval1, int32_t lval2, int32_t rval1, int32_t rval2) { - return CompareIntTest(lval1, lval2, rval1, rval2); - } - - template - int Int64Int64Test(int64_t lval1, int64_t lval2, int64_t rval1, int64_t rval2) { - return CompareInt64Test(lval1, lval2, rval1, rval2); - } - - template - int Int128Int128Test(int128_t lval1, int128_t lval2, int128_t rval1, int128_t rval2) { - return CompareInt128Test(lval1, lval2, rval1, rval2); - } - - template - int FloatFloatTest(float lval1, float lval2, float rval1, float rval2) { - return CompareFloatTest(lval1, lval2, rval1, rval2); - } - - template - int DoubleDoubleTest(double lval1, double lval2, double rval1, double rval2) { - return CompareDoubleTest(lval1, lval2, rval1, rval2); - } - - template - int BoolBoolTest(bool lval1, bool lval2, bool rval1, bool rval2) { - return CompareBoolTest(lval1, lval2, rval1, rval2); - } - - template - int CharCharTest(StringValue lval1, StringValue lval2, StringValue rval1, StringValue rval2) { - return CompareCharTest(lval1, lval2, rval1, rval2); - } - - template - int DateDateTest(DateTimeValue lval1, DateTimeValue lval2, DateTimeValue rval1, DateTimeValue rval2) { - return CompareDateTest(lval1, lval2, rval1, rval2); - } - - template - int DecimalDecimalTest(DecimalV2Value lval1, DecimalV2Value lval2, - DecimalV2Value rval1, DecimalV2Value rval2) { - return CompareDecimalTest(lval1, lval2, rval1, rval2); - } - }; + template + int DecimalDecimalTest(DecimalV2Value lval1, DecimalV2Value lval2, DecimalV2Value rval1, + DecimalV2Value rval2) { + return CompareDecimalTest(lval1, lval2, rval1, rval2); + } +}; TEST_F(TupleRowZOrderCompareTest, DecimalTest) { std::string str1 = "1.00"; @@ -906,20 +953,41 @@ TEST_F(TupleRowZOrderCompareTest, DateDateTest) { EXPECT_EQ(DateDateTest(val1, val2, val3, val4), -1); } TEST_F(TupleRowZOrderCompareTest, CharTest) { - EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"), StringValue("a"), StringValue("b")), 0); - EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"), StringValue("a"), StringValue("b")), 0); - EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("0"), StringValue("h"), StringValue("0")), 0); - EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("z"), StringValue("z"), StringValue("h")), -1); - EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("0"), StringValue("h"), StringValue("0")), -1); - EXPECT_EQ(CharCharTest(StringValue("!"), StringValue("{"), StringValue("0"), StringValue("K")), 1); - EXPECT_EQ(CharCharTest(StringValue("A"), StringValue("~"), StringValue("B"), StringValue("Z")), 1); - EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("bbb"), StringValue("aaa"), StringValue("bbb")), 0); - EXPECT_EQ(CharCharTest(StringValue("abc"), StringValue("bbc"), StringValue("abc"), StringValue("bbc")), 0); - EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aa0"), StringValue("aah"), StringValue("aa0")), 0); - EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("aa0"), StringValue("aah"), StringValue("aa0")), -1); - EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aaz"), StringValue("aaz"), StringValue("aah")), -1); - EXPECT_EQ(CharCharTest(StringValue("aa!"), StringValue("aa{"), StringValue("aa0"), StringValue("aaK")), 1); - EXPECT_EQ(CharCharTest(StringValue("aaA"), StringValue("aa~"), StringValue("aaB"), StringValue("aaZ")), 1); + EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"), StringValue("a"), StringValue("b")), + 0); + EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("b"), StringValue("a"), StringValue("b")), + 0); + EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("0"), StringValue("h"), StringValue("0")), + 0); + EXPECT_EQ(CharCharTest(StringValue("h"), StringValue("z"), StringValue("z"), StringValue("h")), + -1); + EXPECT_EQ(CharCharTest(StringValue("a"), StringValue("0"), StringValue("h"), StringValue("0")), + -1); + EXPECT_EQ(CharCharTest(StringValue("!"), StringValue("{"), StringValue("0"), StringValue("K")), + 1); + EXPECT_EQ(CharCharTest(StringValue("A"), StringValue("~"), StringValue("B"), StringValue("Z")), + 1); + EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("bbb"), StringValue("aaa"), + StringValue("bbb")), + 0); + EXPECT_EQ(CharCharTest(StringValue("abc"), StringValue("bbc"), StringValue("abc"), + StringValue("bbc")), + 0); + EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aa0"), StringValue("aah"), + StringValue("aa0")), + 0); + EXPECT_EQ(CharCharTest(StringValue("aaa"), StringValue("aa0"), StringValue("aah"), + StringValue("aa0")), + -1); + EXPECT_EQ(CharCharTest(StringValue("aah"), StringValue("aaz"), StringValue("aaz"), + StringValue("aah")), + -1); + EXPECT_EQ(CharCharTest(StringValue("aa!"), StringValue("aa{"), StringValue("aa0"), + StringValue("aaK")), + 1); + EXPECT_EQ(CharCharTest(StringValue("aaA"), StringValue("aa~"), StringValue("aaB"), + StringValue("aaZ")), + 1); } TEST_F(TupleRowZOrderCompareTest, BoolTest) { EXPECT_EQ(BoolBoolTest(true, false, true, false), 0); @@ -954,7 +1022,7 @@ TEST_F(TupleRowZOrderCompareTest, FloatTest) { EXPECT_EQ(FloatFloatTest(5.0f, 7.0f, 4.0f, 10.0f), -1); EXPECT_EQ(FloatFloatTest(6.0f, 10.0f, 7.0f, 3.0f), 1); EXPECT_EQ(FloatFloatTest(9.0f, 7.0f, 8.0f, 10.0f), -1); - EXPECT_EQ(FloatFloatTest(8.0f , 8.0f, 9.0f, 7.0f), 1); + EXPECT_EQ(FloatFloatTest(8.0f, 8.0f, 9.0f, 7.0f), 1); EXPECT_EQ(FloatFloatTest(9.0f, 4.0f, 6.0f, 10.0f), 1); EXPECT_EQ(FloatFloatTest(-4.0f, -3.0f, -3.0f, -4.0f), -1); EXPECT_EQ(FloatFloatTest(-5.0f, -7.0f, -4.0f, -10.0f), 1); @@ -1046,15 +1114,3 @@ TEST_F(TupleRowZOrderCompareTest, LargeIntTest) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - doris::init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/util/uid_util_test.cpp b/be/test/util/uid_util_test.cpp index 4b4871aa12..ed05c87f2b 100644 --- a/be/test/util/uid_util_test.cpp +++ b/be/test/util/uid_util_test.cpp @@ -32,14 +32,14 @@ TEST_F(UidUtilTest, UniqueId) { { UniqueId id = UniqueId::gen_uid(); std::string hex_str = id.to_string(); - ASSERT_STRNE("0000000000000000-0000000000000000", hex_str.c_str()); + EXPECT_STRNE("0000000000000000-0000000000000000", hex_str.c_str()); } { UniqueId id(123456789, 987654321); std::string hex_str = id.to_string(); - ASSERT_STREQ("00000000075bcd15-000000003ade68b1", hex_str.c_str()); + EXPECT_STREQ("00000000075bcd15-000000003ade68b1", hex_str.c_str()); UniqueId id2("00000000075bcd15", "000000003ade68b1"); - ASSERT_TRUE(id == id2); + EXPECT_TRUE(id == id2); } { PUniqueId puid; @@ -47,9 +47,9 @@ TEST_F(UidUtilTest, UniqueId) { puid.set_lo(98765432123456789); UniqueId id(puid); std::string hex_str = id.to_string(); - ASSERT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", hex_str.c_str()); + EXPECT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", hex_str.c_str()); UniqueId id2("002bdc546291f4b1", "015ee2a321ce7d15"); - ASSERT_TRUE(id == id2); + EXPECT_TRUE(id == id2); } { TUniqueId tuid; @@ -57,9 +57,9 @@ TEST_F(UidUtilTest, UniqueId) { tuid.__set_lo(98765432123456789); UniqueId id(tuid); std::string hex_str = id.to_string(); - ASSERT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", hex_str.c_str()); + EXPECT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", hex_str.c_str()); UniqueId id2("002bdc546291f4b1", "015ee2a321ce7d15"); - ASSERT_TRUE(id == id2); + EXPECT_TRUE(id == id2); } { TUniqueId tuid; @@ -68,9 +68,9 @@ TEST_F(UidUtilTest, UniqueId) { UniqueId id(tuid); std::stringstream ss; ss << id; - ASSERT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", ss.str().c_str()); + EXPECT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", ss.str().c_str()); UniqueId id2("002bdc546291f4b1", "015ee2a321ce7d15"); - ASSERT_TRUE(id == id2); + EXPECT_TRUE(id == id2); } { @@ -80,13 +80,13 @@ TEST_F(UidUtilTest, UniqueId) { UniqueId id(tuid); std::stringstream ss; ss << id; - ASSERT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", ss.str().c_str()); + EXPECT_STREQ("002bdc546291f4b1-015ee2a321ce7d15", ss.str().c_str()); UniqueId id2("002bdc546291f4b1", "015ee2a321ce7d15"); - ASSERT_TRUE(id == id2); - ASSERT_FALSE(id != id2); + EXPECT_TRUE(id == id2); + EXPECT_FALSE(id != id2); UniqueId id3("002bdc546291f4b1", "015ee2a321ce7d16"); - ASSERT_TRUE(id != id3); - ASSERT_FALSE(id == id3); + EXPECT_TRUE(id != id3); + EXPECT_FALSE(id == id3); } } @@ -98,22 +98,16 @@ TEST_F(UidUtilTest, Hash) { tuid.__set_hi(1); tuid.__set_lo(2); - ASSERT_EQ(hasher(uid), hasher(tuid)); - ASSERT_TRUE(uid == UniqueId(tuid)); + EXPECT_EQ(hasher(uid), hasher(tuid)); + EXPECT_TRUE(uid == UniqueId(tuid)); } { TUniqueId tuid; tuid.__set_hi(1); tuid.__set_lo(1); - ASSERT_NE(hasher(uid), hasher(tuid)); + EXPECT_NE(hasher(uid), hasher(tuid)); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/url_coding_test.cpp b/be/test/util/url_coding_test.cpp index 8ae03663d4..e62f13018c 100644 --- a/be/test/util/url_coding_test.cpp +++ b/be/test/util/url_coding_test.cpp @@ -110,14 +110,3 @@ TEST(HtmlEscapingTest, Basic) { } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - init_glog("be-test"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/utf8_check_test.cpp b/be/test/util/utf8_check_test.cpp index da6b9002d1..134c9494c6 100644 --- a/be/test/util/utf8_check_test.cpp +++ b/be/test/util/utf8_check_test.cpp @@ -91,34 +91,28 @@ private: 35}}; }; TEST_F(Utf8CheckTest, empty) { - ASSERT_TRUE(validate_utf8(pos[0].data, pos[0].len)); + EXPECT_TRUE(validate_utf8(pos[0].data, pos[0].len)); } TEST_F(Utf8CheckTest, normal) { for (int i = 0; i < sizeof(pos) / sizeof(pos[0]); ++i) { - ASSERT_TRUE(validate_utf8(pos[i].data, pos[i].len)); + EXPECT_TRUE(validate_utf8(pos[i].data, pos[i].len)); } } TEST_F(Utf8CheckTest, abnormal) { for (int i = 0; i < sizeof(neg) / sizeof(neg[0]); ++i) { - ASSERT_FALSE(validate_utf8(neg[i].data, neg[i].len)); + EXPECT_FALSE(validate_utf8(neg[i].data, neg[i].len)); } } TEST_F(Utf8CheckTest, naive) { for (int i = 0; i < sizeof(pos) / sizeof(pos[0]); ++i) { - ASSERT_TRUE(validate_utf8_naive(pos[i].data, pos[i].len)); + EXPECT_TRUE(validate_utf8_naive(pos[i].data, pos[i].len)); } for (int i = 0; i < sizeof(neg) / sizeof(neg[0]); ++i) { - std::cout << validate_utf8_naive(neg[i].data, neg[i].len) << std::endl; - ASSERT_FALSE(validate_utf8_naive(neg[i].data, neg[i].len)); + EXPECT_FALSE(validate_utf8_naive(neg[i].data, neg[i].len)); } } } // namespace doris - -int main(int argc, char* argv[]) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/util/zip_util_test.cpp b/be/test/util/zip_util_test.cpp index 72401ad2d8..cf4aecac97 100644 --- a/be/test/util/zip_util_test.cpp +++ b/be/test/util/zip_util_test.cpp @@ -24,9 +24,9 @@ #include "env/env.h" #include "gutil/strings/util.h" +#include "testutil/test_util.h" #include "util/file_utils.h" #include "util/logging.h" -#include "test_util/test_util.h" namespace doris { @@ -35,77 +35,73 @@ using namespace strings; TEST(ZipUtilTest, basic) { std::string path = GetCurrentRunningDir(); - FileUtils::remove_all(path + "/test_data/target"); + FileUtils::remove_all(path + "/util/test_data/target"); - ZipFile zf = ZipFile(path + "/test_data/zip_normal.zip"); - auto st = zf.extract(path + "/test_data", "target"); - ASSERT_TRUE(st.ok()) << st.to_string(); - ASSERT_TRUE(FileUtils::check_exist(path + "/test_data/target/zip_normal_data")); - ASSERT_FALSE(FileUtils::is_dir(path + "/test_data/target/zip_normal_data")); + ZipFile zf = ZipFile(path + "/util/test_data/zip_normal.zip"); + auto st = zf.extract(path + "/util/test_data", "target"); + EXPECT_TRUE(st.ok()) << st.to_string(); + EXPECT_TRUE(FileUtils::check_exist(path + "/util/test_data/target/zip_normal_data")); + EXPECT_FALSE(FileUtils::is_dir(path + "/util/test_data/target/zip_normal_data")); std::unique_ptr file; - Env::Default()->new_random_access_file(path + "/test_data/target/zip_normal_data", &file); + Env::Default()->new_random_access_file(path + "/util/test_data/target/zip_normal_data", &file); char f[11]; Slice slice(f, 11); file->read_at(0, &slice); - ASSERT_EQ("hello world", slice.to_string()); + EXPECT_EQ("hello world", slice.to_string()); - FileUtils::remove_all(path + "/test_data/target"); + FileUtils::remove_all(path + "/util/test_data/target"); } TEST(ZipUtilTest, dir) { std::string path = GetCurrentRunningDir(); - FileUtils::remove_all(path + "/test_data/target"); + FileUtils::remove_all(path + "/util/test_data/target"); - ZipFile zipFile = ZipFile(path + "/test_data/zip_dir.zip"); - ASSERT_TRUE(zipFile.extract(path + "/test_data", "target").ok()); + ZipFile zipFile = ZipFile(path + "/util/test_data/zip_dir.zip"); + EXPECT_TRUE(zipFile.extract(path + "/util/test_data", "target").ok()); - ASSERT_TRUE(FileUtils::check_exist(path + "/test_data/target/zip_test/one")); - ASSERT_TRUE(FileUtils::is_dir(path + "/test_data/target/zip_test/one")); + EXPECT_TRUE(FileUtils::check_exist(path + "/util/test_data/target/zip_test/one")); + EXPECT_TRUE(FileUtils::is_dir(path + "/util/test_data/target/zip_test/one")); - ASSERT_TRUE(FileUtils::check_exist(path + "/test_data/target/zip_test/one/data")); - ASSERT_FALSE(FileUtils::is_dir(path + "/test_data/target/zip_test/one/data")); + EXPECT_TRUE(FileUtils::check_exist(path + "/util/test_data/target/zip_test/one/data")); + EXPECT_FALSE(FileUtils::is_dir(path + "/util/test_data/target/zip_test/one/data")); - ASSERT_TRUE(FileUtils::check_exist(path + "/test_data/target/zip_test/two")); - ASSERT_TRUE(FileUtils::is_dir(path + "/test_data/target/zip_test/two")); + EXPECT_TRUE(FileUtils::check_exist(path + "/util/test_data/target/zip_test/two")); + EXPECT_TRUE(FileUtils::is_dir(path + "/util/test_data/target/zip_test/two")); std::unique_ptr file; - Env::Default()->new_random_access_file(path + "/test_data/target/zip_test/one/data", &file); + Env::Default()->new_random_access_file(path + "/util/test_data/target/zip_test/one/data", + &file); char f[4]; Slice slice(f, 4); file->read_at(0, &slice); - ASSERT_EQ("test", slice.to_string()); + EXPECT_EQ("test", slice.to_string()); - FileUtils::remove_all(path + "/test_data/target"); + FileUtils::remove_all(path + "/util/test_data/target"); } TEST(ZipUtilTest, targetAlready) { std::string path = GetCurrentRunningDir(); - ZipFile f(path + "/test_data/zip_normal.zip"); + ZipFile f(path + "/util/test_data/zip_normal.zip"); - Status st = f.extract(path + "/test_data", "zip_test"); - ASSERT_FALSE(st.ok()); - ASSERT_TRUE(HasPrefixString(st.to_string(), "Already exist")); + Status st = f.extract(path + "/util/test_data", "zip_test"); + EXPECT_FALSE(st.ok()); + EXPECT_TRUE(HasPrefixString(st.to_string(), "Already exist")); } TEST(ZipUtilTest, notzip) { std::string path = GetCurrentRunningDir(); - ZipFile f(path + "/test_data/zip_normal_data"); + ZipFile f(path + "/util/test_data/zip_normal_data"); Status st = f.extract("test", "test"); - ASSERT_FALSE(st.ok()); - ASSERT_TRUE(HasPrefixString(st.to_string(), "Invalid argument")); + EXPECT_FALSE(st.ok()); + EXPECT_TRUE(HasPrefixString(st.to_string(), "Invalid argument")); } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/aggregate_functions/CMakeLists.txt b/be/test/vec/aggregate_functions/CMakeLists.txt deleted file mode 100644 index 13a1315bbe..0000000000 --- a/be/test/vec/aggregate_functions/CMakeLists.txt +++ /dev/null @@ -1,23 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/aggregate_functions") - -ADD_BE_TEST(agg_test) -ADD_BE_TEST(agg_min_max_test) -ADD_BE_TEST(vec_window_funnel_test) diff --git a/be/test/vec/aggregate_functions/agg_min_max_test.cpp b/be/test/vec/aggregate_functions/agg_min_max_test.cpp index a76f8dbbdb..cb8baadf2e 100644 --- a/be/test/vec/aggregate_functions/agg_min_max_test.cpp +++ b/be/test/vec/aggregate_functions/agg_min_max_test.cpp @@ -20,8 +20,8 @@ #include "gtest/gtest.h" #include "vec/aggregate_functions/aggregate_function.h" -#include "vec/aggregate_functions/aggregate_function_simple_factory.h" #include "vec/aggregate_functions/aggregate_function_min_max.h" +#include "vec/aggregate_functions/aggregate_function_simple_factory.h" #include "vec/columns/column_vector.h" #include "vec/data_types/data_type.h" #include "vec/data_types/data_type_number.h" @@ -62,7 +62,7 @@ TEST_P(AggMinMaxTest, min_max_test) { // Check result. ColumnInt32 ans; agg_function->insert_result_into(place, ans); - ASSERT_EQ(min_max_type == "min" ? 0 : agg_test_batch_size - 1, ans.get_element(0)); + EXPECT_EQ(min_max_type == "min" ? 0 : agg_test_batch_size - 1, ans.get_element(0)); agg_function->destroy(place); } @@ -94,7 +94,7 @@ TEST_P(AggMinMaxTest, min_max_string_test) { // Check result. ColumnString ans; agg_function->insert_result_into(place, ans); - ASSERT_EQ(min_max_type == "min" ? StringRef("") : StringRef("zzz"), ans.get_data_at(0)); + EXPECT_EQ(min_max_type == "min" ? StringRef("") : StringRef("zzz"), ans.get_data_at(0)); agg_function->destroy(place); } @@ -102,8 +102,3 @@ INSTANTIATE_TEST_SUITE_P(Params, AggMinMaxTest, ::testing::ValuesIn(std::vector {"min", "max"})); } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/aggregate_functions/agg_test.cpp b/be/test/vec/aggregate_functions/agg_test.cpp index b0d3c06564..b9840fb099 100644 --- a/be/test/vec/aggregate_functions/agg_test.cpp +++ b/be/test/vec/aggregate_functions/agg_test.cpp @@ -57,7 +57,7 @@ TEST(AggTest, basic_test) { for (int i = 0; i < agg_test_batch_size; i++) { ans += i; } - ASSERT_EQ(ans, *reinterpret_cast(place)); + EXPECT_EQ(ans, *reinterpret_cast(place)); agg_function->destroy(place); } @@ -93,12 +93,7 @@ TEST(AggTest, topn_test) { std::string expect_result = "{\"1\":2048,\"2\":683,\"3\":341,\"4\":205,\"5\":137,\"6\":97,\"7\":73,\"8\":57,\"9\":" "46,\"10\":37}"; - ASSERT_EQ(result, expect_result); + EXPECT_EQ(result, expect_result); agg_function->destroy(place); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/aggregate_functions/vec_window_funnel_test.cpp b/be/test/vec/aggregate_functions/vec_window_funnel_test.cpp index 8bcd255dc6..904d5ce80c 100644 --- a/be/test/vec/aggregate_functions/vec_window_funnel_test.cpp +++ b/be/test/vec/aggregate_functions/vec_window_funnel_test.cpp @@ -31,33 +31,29 @@ namespace doris::vectorized { void register_aggregate_function_window_funnel(AggregateFunctionSimpleFactory& factory); -class WindowFunnelTest : public testing::Test { +class VWindowFunnelTest : public testing::Test { public: AggregateFunctionPtr agg_function; - WindowFunnelTest() {} + VWindowFunnelTest() {} void SetUp() { AggregateFunctionSimpleFactory factory = AggregateFunctionSimpleFactory::instance(); DataTypes data_types = { - std::make_shared(), - std::make_shared(), - std::make_shared(), + std::make_shared(), std::make_shared(), + std::make_shared(), std::make_shared(), + std::make_shared(), std::make_shared(), std::make_shared(), - std::make_shared(), - std::make_shared(), - std::make_shared(), - }; + }; Array array; agg_function = factory.get("window_funnel", data_types, array, false); - ASSERT_NE(agg_function, nullptr); + EXPECT_NE(agg_function, nullptr); } - void TearDown() { - } + void TearDown() {} }; -TEST_F(WindowFunnelTest, testEmpty) { +TEST_F(VWindowFunnelTest, testEmpty) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); @@ -77,17 +73,17 @@ TEST_F(WindowFunnelTest, testEmpty) { agg_function->merge(place, place2, nullptr); ColumnVector column_result; agg_function->insert_result_into(place, column_result); - ASSERT_EQ(column_result.get_data()[0], 0); + EXPECT_EQ(column_result.get_data()[0], 0); ColumnVector column_result2; agg_function->insert_result_into(place2, column_result2); - ASSERT_EQ(column_result2.get_data()[0], 0); + EXPECT_EQ(column_result2.get_data()[0], 0); agg_function->destroy(place); agg_function->destroy(place2); } -TEST_F(WindowFunnelTest, testSerialize) { +TEST_F(VWindowFunnelTest, testSerialize) { const int NUM_CONDS = 4; auto column_mode = ColumnString::create(); for (int i = 0; i < NUM_CONDS; i++) { @@ -98,7 +94,7 @@ TEST_F(WindowFunnelTest, testSerialize) { for (int i = 0; i < NUM_CONDS; i++) { VecDateTimeValue time_value; time_value.set_time(2022, 2, 28, 0, 0, i); - column_timestamp->insert_data((char *)&time_value, 0); + column_timestamp->insert_data((char*)&time_value, 0); } auto column_event1 = ColumnVector::create(); column_event1->insert(1); @@ -132,10 +128,9 @@ TEST_F(WindowFunnelTest, testSerialize) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); - const IColumn* column[7] = { column_window.get(), column_mode.get(), - column_timestamp.get(), - column_event1.get(), column_event2.get(), - column_event3.get(), column_event4.get() }; + const IColumn* column[7] = {column_window.get(), column_mode.get(), column_timestamp.get(), + column_event1.get(), column_event2.get(), column_event3.get(), + column_event4.get()}; for (int i = 0; i < NUM_CONDS; i++) { agg_function->add(place, column, i, nullptr); } @@ -154,17 +149,16 @@ TEST_F(WindowFunnelTest, testSerialize) { ColumnVector column_result; agg_function->insert_result_into(place, column_result); - ASSERT_EQ(column_result.get_data()[0], 3); + EXPECT_EQ(column_result.get_data()[0], 3); agg_function->destroy(place); ColumnVector column_result2; agg_function->insert_result_into(place2, column_result2); - ASSERT_EQ(column_result2.get_data()[0], 3); + EXPECT_EQ(column_result2.get_data()[0], 3); agg_function->destroy(place2); } - -TEST_F(WindowFunnelTest, testMax4SortedNoMerge) { +TEST_F(VWindowFunnelTest, testMax4SortedNoMerge) { const int NUM_CONDS = 4; auto column_mode = ColumnString::create(); for (int i = 0; i < NUM_CONDS; i++) { @@ -174,7 +168,7 @@ TEST_F(WindowFunnelTest, testMax4SortedNoMerge) { for (int i = 0; i < NUM_CONDS; i++) { VecDateTimeValue time_value; time_value.set_time(2022, 2, 28, 0, 0, i); - column_timestamp->insert_data((char *)&time_value, 0); + column_timestamp->insert_data((char*)&time_value, 0); } auto column_event1 = ColumnVector::create(); column_event1->insert(1); @@ -200,7 +194,7 @@ TEST_F(WindowFunnelTest, testMax4SortedNoMerge) { column_event4->insert(0); column_event4->insert(1); - for(int win = -1; win < NUM_CONDS + 1; win++) { + for (int win = -1; win < NUM_CONDS + 1; win++) { auto column_window = ColumnVector::create(); for (int i = 0; i < NUM_CONDS; i++) { column_window->insert(win); @@ -209,22 +203,23 @@ TEST_F(WindowFunnelTest, testMax4SortedNoMerge) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); - const IColumn* column[7] = { column_window.get(), column_mode.get(), - column_timestamp.get(), - column_event1.get(), column_event2.get(), - column_event3.get(), column_event4.get() }; + const IColumn* column[7] = {column_window.get(), column_mode.get(), + column_timestamp.get(), column_event1.get(), + column_event2.get(), column_event3.get(), + column_event4.get()}; for (int i = 0; i < NUM_CONDS; i++) { agg_function->add(place, column, i, nullptr); } ColumnVector column_result; agg_function->insert_result_into(place, column_result); - ASSERT_EQ(column_result.get_data()[0], win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); + EXPECT_EQ(column_result.get_data()[0], + win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); agg_function->destroy(place); } } -TEST_F(WindowFunnelTest, testMax4SortedMerge) { +TEST_F(VWindowFunnelTest, testMax4SortedMerge) { const int NUM_CONDS = 4; auto column_mode = ColumnString::create(); for (int i = 0; i < NUM_CONDS; i++) { @@ -234,7 +229,7 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { for (int i = 0; i < NUM_CONDS; i++) { VecDateTimeValue time_value; time_value.set_time(2022, 2, 28, 0, 0, i); - column_timestamp->insert_data((char *)&time_value, 0); + column_timestamp->insert_data((char*)&time_value, 0); } auto column_event1 = ColumnVector::create(); column_event1->insert(1); @@ -260,7 +255,7 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { column_event4->insert(0); column_event4->insert(1); - for(int win = -1; win < NUM_CONDS + 1; win++) { + for (int win = -1; win < NUM_CONDS + 1; win++) { auto column_window = ColumnVector::create(); for (int i = 0; i < NUM_CONDS; i++) { column_window->insert(win); @@ -269,10 +264,10 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); - const IColumn* column[7] = { column_window.get(), column_mode.get(), - column_timestamp.get(), - column_event1.get(), column_event2.get(), - column_event3.get(), column_event4.get() }; + const IColumn* column[7] = {column_window.get(), column_mode.get(), + column_timestamp.get(), column_event1.get(), + column_event2.get(), column_event3.get(), + column_event4.get()}; for (int i = 0; i < NUM_CONDS; i++) { agg_function->add(place, column, i, nullptr); } @@ -284,13 +279,14 @@ TEST_F(WindowFunnelTest, testMax4SortedMerge) { agg_function->merge(place2, place, nullptr); ColumnVector column_result; agg_function->insert_result_into(place2, column_result); - ASSERT_EQ(column_result.get_data()[0], win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); + EXPECT_EQ(column_result.get_data()[0], + win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); agg_function->destroy(place); agg_function->destroy(place2); } } -TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { +TEST_F(VWindowFunnelTest, testMax4ReverseSortedNoMerge) { const int NUM_CONDS = 4; auto column_mode = ColumnString::create(); for (int i = 0; i < NUM_CONDS; i++) { @@ -300,7 +296,7 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { for (int i = 0; i < NUM_CONDS; i++) { VecDateTimeValue time_value; time_value.set_time(2022, 2, 28, 0, 0, NUM_CONDS - i); - column_timestamp->insert_data((char *)&time_value, 0); + column_timestamp->insert_data((char*)&time_value, 0); } auto column_event1 = ColumnVector::create(); column_event1->insert(0); @@ -326,7 +322,7 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { column_event4->insert(0); column_event4->insert(0); - for(int win = -1; win < NUM_CONDS + 1; win++) { + for (int win = -1; win < NUM_CONDS + 1; win++) { auto column_window = ColumnVector::create(); for (int i = 0; i < NUM_CONDS; i++) { column_window->insert(win); @@ -335,10 +331,10 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); - const IColumn* column[7] = { column_window.get(), column_mode.get(), - column_timestamp.get(), - column_event1.get(), column_event2.get(), - column_event3.get(), column_event4.get() }; + const IColumn* column[7] = {column_window.get(), column_mode.get(), + column_timestamp.get(), column_event1.get(), + column_event2.get(), column_event3.get(), + column_event4.get()}; for (int i = 0; i < NUM_CONDS; i++) { agg_function->add(place, column, i, nullptr); } @@ -346,12 +342,13 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedNoMerge) { LOG(INFO) << "win " << win; ColumnVector column_result; agg_function->insert_result_into(place, column_result); - ASSERT_EQ(column_result.get_data()[0], win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); + EXPECT_EQ(column_result.get_data()[0], + win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); agg_function->destroy(place); } } -TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { +TEST_F(VWindowFunnelTest, testMax4ReverseSortedMerge) { const int NUM_CONDS = 4; auto column_mode = ColumnString::create(); for (int i = 0; i < NUM_CONDS; i++) { @@ -361,7 +358,7 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { for (int i = 0; i < NUM_CONDS; i++) { VecDateTimeValue time_value; time_value.set_time(2022, 2, 28, 0, 0, NUM_CONDS - i); - column_timestamp->insert_data((char *)&time_value, 0); + column_timestamp->insert_data((char*)&time_value, 0); } auto column_event1 = ColumnVector::create(); column_event1->insert(0); @@ -387,7 +384,7 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { column_event4->insert(0); column_event4->insert(0); - for(int win = -1; win < NUM_CONDS + 1; win++) { + for (int win = -1; win < NUM_CONDS + 1; win++) { auto column_window = ColumnVector::create(); for (int i = 0; i < NUM_CONDS; i++) { column_window->insert(win); @@ -396,10 +393,10 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { std::unique_ptr memory(new char[agg_function->size_of_data()]); AggregateDataPtr place = memory.get(); agg_function->create(place); - const IColumn* column[7] = { column_window.get(), column_mode.get(), - column_timestamp.get(), - column_event1.get(), column_event2.get(), - column_event3.get(), column_event4.get() }; + const IColumn* column[7] = {column_window.get(), column_mode.get(), + column_timestamp.get(), column_event1.get(), + column_event2.get(), column_event3.get(), + column_event4.get()}; for (int i = 0; i < NUM_CONDS; i++) { agg_function->add(place, column, i, nullptr); } @@ -411,15 +408,11 @@ TEST_F(WindowFunnelTest, testMax4ReverseSortedMerge) { agg_function->merge(place2, place, NULL); ColumnVector column_result; agg_function->insert_result_into(place2, column_result); - ASSERT_EQ(column_result.get_data()[0], win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); + EXPECT_EQ(column_result.get_data()[0], + win < 0 ? 1 : (win < NUM_CONDS ? win + 1 : NUM_CONDS)); agg_function->destroy(place); agg_function->destroy(place2); } } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/core/CMakeLists.txt b/be/test/vec/core/CMakeLists.txt deleted file mode 100644 index 8df76781d6..0000000000 --- a/be/test/vec/core/CMakeLists.txt +++ /dev/null @@ -1,25 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/core") - -ADD_BE_TEST(block_test) -ADD_BE_TEST(column_array_test) -ADD_BE_TEST(column_complex_test) -ADD_BE_TEST(column_nullable_test) - diff --git a/be/test/vec/core/block_test.cpp b/be/test/vec/core/block_test.cpp index a621564d8c..f9a8a86824 100644 --- a/be/test/vec/core/block_test.cpp +++ b/be/test/vec/core/block_test.cpp @@ -122,20 +122,20 @@ TEST(BlockTest, RowBatchCovertToBlock) { vectorized::ColumnPtr column7 = block.get_columns()[6]; if (i % 5 != 0) { - ASSERT_EQ((int16_t)column1->get64(i), k1); + EXPECT_EQ((int16_t)column1->get64(i), k1); } else { - ASSERT_TRUE(column1->is_null_at(i)); + EXPECT_TRUE(column1->is_null_at(i)); } - ASSERT_EQ(column2->get_int(i), k2++); - ASSERT_EQ(column3->get_float64(i), k3); - ASSERT_STREQ(column4->get_data_at(i).data, std::to_string(k1).c_str()); + EXPECT_EQ(column2->get_int(i), k2++); + EXPECT_EQ(column3->get_float64(i), k3); + EXPECT_STREQ(column4->get_data_at(i).data, std::to_string(k1).c_str()); auto decimal_field = column5->operator[](i).get>(); DecimalV2Value decimalv2_num(std::to_string(k3)); - ASSERT_EQ(DecimalV2Value(decimal_field.get_value()), decimalv2_num); + EXPECT_EQ(DecimalV2Value(decimal_field.get_value()), decimalv2_num); int128_t larget_int = k1; - ASSERT_EQ(column6->operator[](i).get(), k1); + EXPECT_EQ(column6->operator[](i).get(), k1); larget_int = column7->operator[](i).get(); vectorized::VecDateTimeValue k7; @@ -146,7 +146,7 @@ TEST(BlockTest, RowBatchCovertToBlock) { vectorized::TimeInterval time_interval(vectorized::TimeUnit::DAY, k1, false); date_time_value.date_add_interval(time_interval, vectorized::TimeUnit::DAY); - ASSERT_EQ(k7, date_time_value); + EXPECT_EQ(k7, date_time_value); k1++; k3 += 0.1; @@ -157,13 +157,15 @@ void block_to_pb(const vectorized::Block& block, PBlock* pblock) { size_t uncompressed_bytes = 0; size_t compressed_bytes = 0; std::string column_values_buffer; - Status st = block.serialize(pblock, &uncompressed_bytes, &compressed_bytes, &column_values_buffer); + Status st = + block.serialize(pblock, &uncompressed_bytes, &compressed_bytes, &column_values_buffer); EXPECT_TRUE(st.ok()); EXPECT_TRUE(uncompressed_bytes >= compressed_bytes); EXPECT_EQ(compressed_bytes, column_values_buffer.size()); pblock->set_column_values(column_values_buffer); - - const vectorized::ColumnWithTypeAndName& type_and_name = block.get_columns_with_type_and_name()[0]; + + const vectorized::ColumnWithTypeAndName& type_and_name = + block.get_columns_with_type_and_name()[0]; EXPECT_EQ(type_and_name.name, pblock->column_metas()[0].name()); } @@ -197,7 +199,8 @@ TEST(BlockTest, SerializeAndDeserializeBlock) { strcol->insert_data(is.c_str(), is.size()); } vectorized::DataTypePtr data_type(std::make_shared()); - vectorized::ColumnWithTypeAndName type_and_name(strcol->get_ptr(), data_type, "test_string"); + vectorized::ColumnWithTypeAndName type_and_name(strcol->get_ptr(), data_type, + "test_string"); vectorized::Block block({type_and_name}); PBlock pblock; block_to_pb(block, &pblock); @@ -214,13 +217,14 @@ TEST(BlockTest, SerializeAndDeserializeBlock) { vectorized::DataTypePtr decimal_data_type(doris::vectorized::create_decimal(27, 9)); auto decimal_column = decimal_data_type->create_column(); auto& data = ((vectorized::ColumnDecimal>*) - decimal_column.get())->get_data(); + decimal_column.get()) + ->get_data(); for (int i = 0; i < 1024; ++i) { __int128_t value = i * pow(10, 9) + i * pow(10, 8); data.push_back(value); } - vectorized::ColumnWithTypeAndName type_and_name(decimal_column->get_ptr(), decimal_data_type, - "test_decimal"); + vectorized::ColumnWithTypeAndName type_and_name(decimal_column->get_ptr(), + decimal_data_type, "test_decimal"); vectorized::Block block({type_and_name}); PBlock pblock; block_to_pb(block, &pblock); @@ -236,15 +240,17 @@ TEST(BlockTest, SerializeAndDeserializeBlock) { { vectorized::DataTypePtr bitmap_data_type(std::make_shared()); auto bitmap_column = bitmap_data_type->create_column(); - std::vector& container = ((vectorized::ColumnComplexType*) bitmap_column.get())->get_data(); + std::vector& container = + ((vectorized::ColumnComplexType*)bitmap_column.get())->get_data(); for (int i = 0; i < 1024; ++i) { BitmapValue bv; for (int j = 0; j <= i; ++j) { bv.add(j); } - container.push_back(bv); + container.push_back(bv); } - vectorized::ColumnWithTypeAndName type_and_name(bitmap_column->get_ptr(), bitmap_data_type, "test_bitmap"); + vectorized::ColumnWithTypeAndName type_and_name(bitmap_column->get_ptr(), bitmap_data_type, + "test_bitmap"); vectorized::Block block({type_and_name}); PBlock pblock; block_to_pb(block, &pblock); @@ -259,11 +265,12 @@ TEST(BlockTest, SerializeAndDeserializeBlock) { // nullable string { vectorized::DataTypePtr string_data_type(std::make_shared()); - vectorized::DataTypePtr nullable_data_type(std::make_shared(string_data_type)); + vectorized::DataTypePtr nullable_data_type( + std::make_shared(string_data_type)); auto nullable_column = nullable_data_type->create_column(); - ((vectorized::ColumnNullable*) nullable_column.get())->insert_null_elements(1024); - vectorized::ColumnWithTypeAndName type_and_name(nullable_column->get_ptr(), nullable_data_type, - "test_nullable"); + ((vectorized::ColumnNullable*)nullable_column.get())->insert_null_elements(1024); + vectorized::ColumnWithTypeAndName type_and_name(nullable_column->get_ptr(), + nullable_data_type, "test_nullable"); vectorized::Block block({type_and_name}); PBlock pblock; block_to_pb(block, &pblock); @@ -278,11 +285,12 @@ TEST(BlockTest, SerializeAndDeserializeBlock) { // nullable decimal { vectorized::DataTypePtr decimal_data_type(doris::vectorized::create_decimal(27, 9)); - vectorized::DataTypePtr nullable_data_type(std::make_shared(decimal_data_type)); + vectorized::DataTypePtr nullable_data_type( + std::make_shared(decimal_data_type)); auto nullable_column = nullable_data_type->create_column(); - ((vectorized::ColumnNullable*) nullable_column.get())->insert_null_elements(1024); - vectorized::ColumnWithTypeAndName type_and_name(nullable_column->get_ptr(), nullable_data_type, - "test_nullable_decimal"); + ((vectorized::ColumnNullable*)nullable_column.get())->insert_null_elements(1024); + vectorized::ColumnWithTypeAndName type_and_name( + nullable_column->get_ptr(), nullable_data_type, "test_nullable_decimal"); vectorized::Block block({type_and_name}); PBlock pblock; block_to_pb(block, &pblock); @@ -378,21 +386,11 @@ TEST(BlockTest, dump_data) { datetime_data.push_back(*reinterpret_cast(&value)); } vectorized::DataTypePtr datetime_type(std::make_shared()); - vectorized::ColumnWithTypeAndName test_datetime(column_vector_datetime->get_ptr(), datetime_type, - "test_datetime"); + vectorized::ColumnWithTypeAndName test_datetime(column_vector_datetime->get_ptr(), + datetime_type, "test_datetime"); vectorized::Block block( {test_int, test_string, test_decimal, test_nullable_int32, test_date, test_datetime}); EXPECT_GT(block.dump_data().size(), 1); } } // namespace doris - -int main(int argc, char** argv) { - std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; - if (!doris::config::init(conffile.c_str(), false)) { - fprintf(stderr, "error read config file. \n"); - return -1; - } - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/core/column_array_test.cpp b/be/test/vec/core/column_array_test.cpp index 251f769e47..a65c7d8c0b 100644 --- a/be/test/vec/core/column_array_test.cpp +++ b/be/test/vec/core/column_array_test.cpp @@ -15,16 +15,17 @@ // specific language governing permissions and limitations // under the License. -#include "vec/columns/column.h" #include "vec/columns/column_array.h" -#include "vec/columns/column_string.h" -#include "vec/columns/column_vector.h" #include #include #include +#include "vec/columns/column.h" +#include "vec/columns/column_string.h" +#include "vec/columns/column_vector.h" + namespace doris::vectorized { TEST(ColumnArrayTest, IntArrayTest) { @@ -42,12 +43,12 @@ TEST(ColumnArrayTest, IntArrayTest) { // check column array result ColumnArray array_column(std::move(data_column), std::move(off_column)); - ASSERT_EQ(array_column.size(), offs.size() - 1); + EXPECT_EQ(array_column.size(), offs.size() - 1); for (size_t i = 0; i < array_column.size(); ++i) { auto v = get(array_column[i]); - ASSERT_EQ(v.size(), offs[i + 1] - offs[i]); + EXPECT_EQ(v.size(), offs[i + 1] - offs[i]); for (size_t j = 0; j < v.size(); ++j) { - ASSERT_EQ(vals[offs[i] + j], get(v[j])); + EXPECT_EQ(vals[offs[i] + j], get(v[j])); } } } @@ -67,19 +68,14 @@ TEST(ColumnArrayTest, StringArrayTest) { // check column array result ColumnArray array_column(std::move(data_column), std::move(off_column)); - ASSERT_EQ(array_column.size(), offs.size() - 1); + EXPECT_EQ(array_column.size(), offs.size() - 1); for (size_t i = 0; i < array_column.size(); ++i) { auto v = get(array_column[i]); - ASSERT_EQ(v.size(), offs[i + 1] - offs[i]); + EXPECT_EQ(v.size(), offs[i + 1] - offs[i]); for (size_t j = 0; j < v.size(); ++j) { - ASSERT_EQ(vals[offs[i] + j], get(v[j])); + EXPECT_EQ(vals[offs[i] + j], get(v[j])); } } } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/core/column_complex_test.cpp b/be/test/vec/core/column_complex_test.cpp index c8267f7e54..1eb8cd906d 100644 --- a/be/test/vec/core/column_complex_test.cpp +++ b/be/test/vec/core/column_complex_test.cpp @@ -27,7 +27,7 @@ namespace doris::vectorized { TEST(ColumnComplexTest, BasicTest) { using ColumnSTLString = ColumnComplexType; auto column = ColumnSTLString::create(); - ASSERT_EQ(column->size(), 0); + EXPECT_EQ(column->size(), 0); std::string val0 = ""; std::string val1 = "str-1"; @@ -35,9 +35,9 @@ TEST(ColumnComplexTest, BasicTest) { column->insert_data(reinterpret_cast(&val1), sizeof(val1)); StringRef ref = column->get_data_at(0); - ASSERT_EQ((*reinterpret_cast(ref.data)), ""); + EXPECT_EQ((*reinterpret_cast(ref.data)), ""); ref = column->get_data_at(1); - ASSERT_EQ((*reinterpret_cast(ref.data)), val1); + EXPECT_EQ((*reinterpret_cast(ref.data)), val1); } // Test the compile failed @@ -45,8 +45,3 @@ TEST(ColumnComplexType, DataTypeBitmapTest) { std::make_shared(); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/core/column_nullable_test.cpp b/be/test/vec/core/column_nullable_test.cpp index bfd969c9c9..2f0130f5fa 100644 --- a/be/test/vec/core/column_nullable_test.cpp +++ b/be/test/vec/core/column_nullable_test.cpp @@ -17,14 +17,15 @@ // under the License. #include "vec/columns/column_nullable.h" -#include "vec/columns/column_vector.h" -#include "vec/common/sip_hash.h" #include #include #include +#include "vec/columns/column_vector.h" +#include "vec/common/sip_hash.h" + namespace doris::vectorized { TEST(ColumnNullableTest, HashTest) { @@ -34,24 +35,19 @@ TEST(ColumnNullableTest, HashTest) { tmp_column->insert_data((const char*)(&val1), 0); tmp_column->insert_data((const char*)(&val2), 0); ColumnPtr column = std::move(tmp_column); - ASSERT_EQ(column->size(), 2); + EXPECT_EQ(column->size(), 2); auto nullable_column = ColumnNullable::create(column, ColumnUInt8::create(column->size(), 0)); SipHash hashes[2]; column->update_hash_with_value(0, hashes[0]); nullable_column->update_hash_with_value(0, hashes[1]); - ASSERT_EQ(hashes[0].get64(), hashes[1].get64()); + EXPECT_EQ(hashes[0].get64(), hashes[1].get64()); auto& null_map = ((ColumnNullable)(*nullable_column)).get_null_map_data(); null_map[1] = true; column->update_hash_with_value(1, hashes[0]); nullable_column->update_hash_with_value(1, hashes[1]); - ASSERT_NE(hashes[0].get64(), hashes[1].get64()); + EXPECT_NE(hashes[0].get64(), hashes[1].get64()); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/exec/CMakeLists.txt b/be/test/vec/exec/CMakeLists.txt deleted file mode 100644 index 07bdcbc767..0000000000 --- a/be/test/vec/exec/CMakeLists.txt +++ /dev/null @@ -1,21 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/exec") - -ADD_BE_TEST(vgeneric_iterators_test) diff --git a/be/test/vec/exec/vgeneric_iterators_test.cpp b/be/test/vec/exec/vgeneric_iterators_test.cpp index d38f657e08..2a66c2556d 100644 --- a/be/test/vec/exec/vgeneric_iterators_test.cpp +++ b/be/test/vec/exec/vgeneric_iterators_test.cpp @@ -49,12 +49,11 @@ Schema create_schema() { return schema; } -static void create_block(Schema& schema, vectorized::Block& block) -{ - for (auto &column_desc : schema.columns()) { - ASSERT_TRUE(column_desc); +static void create_block(Schema& schema, vectorized::Block& block) { + for (auto& column_desc : schema.columns()) { + EXPECT_TRUE(column_desc); auto data_type = Schema::get_data_type_ptr(*column_desc); - ASSERT_NE(data_type, nullptr); + EXPECT_NE(data_type, nullptr); auto column = data_type->create_column(); vectorized::ColumnWithTypeAndName ctn(std::move(column), data_type, column_desc->name()); block.insert(ctn); @@ -67,14 +66,14 @@ TEST(VGenericIteratorsTest, AutoIncrement) { StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); vectorized::Block block; create_block(schema, block); auto ret = iter->next_batch(&block); - ASSERT_TRUE(ret.ok()); - ASSERT_EQ(block.rows(), 10); + EXPECT_TRUE(ret.ok()); + EXPECT_EQ(block.rows(), 10); auto c0 = block.get_by_position(0).column; auto c1 = block.get_by_position(1).column; @@ -83,9 +82,9 @@ TEST(VGenericIteratorsTest, AutoIncrement) { int row_count = 0; size_t rows = block.rows(); for (size_t i = 0; i < rows; ++i) { - ASSERT_EQ(row_count, (*c0)[i].get()); - ASSERT_EQ(row_count + 1, (*c1)[i].get()); - ASSERT_EQ(row_count + 2, (*c2)[i].get()); + EXPECT_EQ(row_count, (*c0)[i].get()); + EXPECT_EQ(row_count + 1, (*c1)[i].get()); + EXPECT_EQ(row_count + 2, (*c2)[i].get()); row_count++; } @@ -103,7 +102,7 @@ TEST(VGenericIteratorsTest, Union) { auto iter = vectorized::new_union_iterator(inputs); StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); vectorized::Block block; create_block(schema, block); @@ -112,8 +111,8 @@ TEST(VGenericIteratorsTest, Union) { st = iter->next_batch(&block); } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(block.rows(), 600); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(block.rows(), 600); auto c0 = block.get_by_position(0).column; auto c1 = block.get_by_position(1).column; @@ -128,9 +127,9 @@ TEST(VGenericIteratorsTest, Union) { base_value -= 100; } - ASSERT_EQ(base_value, (*c0)[i].get()); - ASSERT_EQ(base_value + 1, (*c1)[i].get()); - ASSERT_EQ(base_value + 2, (*c2)[i].get()); + EXPECT_EQ(base_value, (*c0)[i].get()); + EXPECT_EQ(base_value + 1, (*c1)[i].get()); + EXPECT_EQ(base_value + 2, (*c2)[i].get()); row_count++; } @@ -138,7 +137,7 @@ TEST(VGenericIteratorsTest, Union) { } TEST(VGenericIteratorsTest, Merge) { - ASSERT_TRUE(1); + EXPECT_TRUE(1); auto schema = create_schema(); std::vector inputs; @@ -149,7 +148,7 @@ TEST(VGenericIteratorsTest, Merge) { auto iter = vectorized::new_merge_iterator(inputs, -1); StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); vectorized::Block block; create_block(schema, block); @@ -158,8 +157,8 @@ TEST(VGenericIteratorsTest, Merge) { st = iter->next_batch(&block); } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(block.rows(), 600); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(block.rows(), 600); auto c0 = block.get_by_position(0).column; auto c1 = block.get_by_position(1).column; @@ -177,9 +176,9 @@ TEST(VGenericIteratorsTest, Merge) { base_value = row_count - 300; } - ASSERT_EQ(base_value, (*c0)[i].get()); - ASSERT_EQ(base_value + 1, (*c1)[i].get()); - ASSERT_EQ(base_value + 2, (*c2)[i].get()); + EXPECT_EQ(base_value, (*c0)[i].get()); + EXPECT_EQ(base_value + 1, (*c1)[i].get()); + EXPECT_EQ(base_value + 2, (*c2)[i].get()); row_count++; } @@ -190,14 +189,17 @@ TEST(VGenericIteratorsTest, Merge) { class SeqColumnUtIterator : public RowwiseIterator { public: // Will generate num_rows rows in total - SeqColumnUtIterator(const Schema& schema, size_t num_rows, size_t rows_returned, size_t seq_col_idx, size_t seq_col_rows_returned) - : _schema(schema), _num_rows(num_rows), _rows_returned(rows_returned), _seq_col_idx(seq_col_idx), _seq_col_rows_returned(seq_col_rows_returned) {} + SeqColumnUtIterator(const Schema& schema, size_t num_rows, size_t rows_returned, + size_t seq_col_idx, size_t seq_col_rows_returned) + : _schema(schema), + _num_rows(num_rows), + _rows_returned(rows_returned), + _seq_col_idx(seq_col_idx), + _seq_col_rows_returned(seq_col_rows_returned) {} ~SeqColumnUtIterator() override {} // NOTE: Currently, this function will ignore StorageReadOptions - Status init(const StorageReadOptions& opts) override { - return Status::OK(); - }; + Status init(const StorageReadOptions& opts) override { return Status::OK(); }; Status next_batch(vectorized::Block* block) override { int row_idx = 0; @@ -210,28 +212,28 @@ public: size_t data_len = 0; const auto* col_schema = _schema.column(j); switch (col_schema->type()) { - case OLAP_FIELD_TYPE_SMALLINT: - *(int16_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; - data_len = sizeof(int16_t); - break; - case OLAP_FIELD_TYPE_INT: - *(int32_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; - data_len = sizeof(int32_t); - break; - case OLAP_FIELD_TYPE_BIGINT: - *(int64_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; - data_len = sizeof(int64_t); - break; - case OLAP_FIELD_TYPE_FLOAT: - *(float*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; - data_len = sizeof(float); - break; - case OLAP_FIELD_TYPE_DOUBLE: - *(double*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; - data_len = sizeof(double); - break; - default: - break; + case OLAP_FIELD_TYPE_SMALLINT: + *(int16_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; + data_len = sizeof(int16_t); + break; + case OLAP_FIELD_TYPE_INT: + *(int32_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; + data_len = sizeof(int32_t); + break; + case OLAP_FIELD_TYPE_BIGINT: + *(int64_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; + data_len = sizeof(int64_t); + break; + case OLAP_FIELD_TYPE_FLOAT: + *(float*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; + data_len = sizeof(float); + break; + case OLAP_FIELD_TYPE_DOUBLE: + *(double*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1; + data_len = sizeof(double); + break; + default: + break; } vi.insert_data(data, data_len); @@ -241,9 +243,8 @@ public: _seq_col_rows_returned++; row_idx++; } - - if (row_idx > 0) - return Status::OK(); + + if (row_idx > 0) return Status::OK(); return Status::EndOfFile("End of VAutoIncrementIterator"); } @@ -257,7 +258,7 @@ public: }; TEST(VGenericIteratorsTest, MergeWithSeqColumn) { - ASSERT_TRUE(1); + EXPECT_TRUE(1); auto schema = create_schema(); std::vector inputs; @@ -267,16 +268,17 @@ TEST(VGenericIteratorsTest, MergeWithSeqColumn) { int rows_begin = 0; // The same key in each file will only keep one with the largest seq id // keep the key columns all the same, but seq column value different - // input seg file in Ascending, expect output seq column in Descending + // input seg file in Ascending, expect output seq column in Descending for (int i = 0; i < seg_iter_num; i++) { int seq_id_in_every_file = i; - inputs.push_back(new SeqColumnUtIterator(schema, num_rows, rows_begin, seq_column_id, seq_id_in_every_file)); + inputs.push_back(new SeqColumnUtIterator(schema, num_rows, rows_begin, seq_column_id, + seq_id_in_every_file)); } auto iter = vectorized::new_merge_iterator(inputs, seq_column_id); StorageReadOptions opts; auto st = iter->init(opts); - ASSERT_TRUE(st.ok()); + EXPECT_TRUE(st.ok()); vectorized::Block block; create_block(schema, block); @@ -285,28 +287,22 @@ TEST(VGenericIteratorsTest, MergeWithSeqColumn) { st = iter->next_batch(&block); } while (st.ok()); - ASSERT_TRUE(st.is_end_of_file()); - ASSERT_EQ(block.rows(), seg_iter_num); + EXPECT_TRUE(st.is_end_of_file()); + EXPECT_EQ(block.rows(), seg_iter_num); auto col0 = block.get_by_position(0).column; auto col1 = block.get_by_position(1).column; auto seq_col = block.get_by_position(seq_column_id).column; for (size_t i = 0; i < seg_iter_num; i++) { - size_t expected_value = seg_iter_num - i - 1; // in Descending + size_t expected_value = seg_iter_num - i - 1; // in Descending size_t actual_value = (*seq_col)[i].get(); - ASSERT_EQ(expected_value, actual_value); + EXPECT_EQ(expected_value, actual_value); } delete iter; } - } // namespace vectorized } // namespace doris - -int main(int argc, char** argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/exprs/CMakeLists.txt b/be/test/vec/exprs/CMakeLists.txt deleted file mode 100644 index ffd85600ed..0000000000 --- a/be/test/vec/exprs/CMakeLists.txt +++ /dev/null @@ -1,22 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/exprs") - -ADD_BE_TEST(vexpr_test) - diff --git a/be/test/vec/exprs/vexpr_test.cpp b/be/test/vec/exprs/vexpr_test.cpp index f2de7ba5ac..bf0448acdf 100644 --- a/be/test/vec/exprs/vexpr_test.cpp +++ b/be/test/vec/exprs/vexpr_test.cpp @@ -81,7 +81,7 @@ TEST(TEST_VEXPR, ABSTEST) { FunctionContext* fun_ct = context->fn_context(0); context->close(&runtime_stat); - if(fun_ct) { + if (fun_ct) { delete fun_ct; } } @@ -131,7 +131,7 @@ TEST(TEST_VEXPR, ABSTEST2) { FunctionContext* fun_ct = context->fn_context(0); context->close(&runtime_stat); - if(fun_ct) { + if (fun_ct) { delete fun_ct; } } @@ -280,7 +280,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); bool v = ctn.column->get_bool(0); - ASSERT_EQ(v, true); + EXPECT_EQ(v, true); } { VLiteral literal(create_literal(1024)); @@ -289,7 +289,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = ctn.column->get64(0); - ASSERT_EQ(v, 1024); + EXPECT_EQ(v, 1024); } { VLiteral literal(create_literal(1024)); @@ -298,7 +298,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = ctn.column->get64(0); - ASSERT_EQ(v, 1024); + EXPECT_EQ(v, 1024); } { VLiteral literal(create_literal(1024)); @@ -307,7 +307,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = ctn.column->get64(0); - ASSERT_EQ(v, 1024); + EXPECT_EQ(v, 1024); } { VLiteral literal(create_literal(1024)); @@ -316,7 +316,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = (*ctn.column)[0].get<__int128_t>(); - ASSERT_EQ(v, 1024); + EXPECT_EQ(v, 1024); } { VLiteral literal(create_literal(1024.0f)); @@ -325,7 +325,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = (*ctn.column)[0].get(); - ASSERT_FLOAT_EQ(v, 1024.0f); + EXPECT_FLOAT_EQ(v, 1024.0f); } { VLiteral literal(create_literal(1024.0)); @@ -334,7 +334,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = (*ctn.column)[0].get(); - ASSERT_FLOAT_EQ(v, 1024.0); + EXPECT_FLOAT_EQ(v, 1024.0); } { vectorized::VecDateTimeValue data_time_value; @@ -348,7 +348,7 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = (*ctn.column)[0].get<__int64_t>(); - ASSERT_EQ(v, dt); + EXPECT_EQ(v, dt); } { VLiteral literal(create_literal(std::string("1234.56"))); @@ -357,11 +357,6 @@ TEST(TEST_VEXPR, LITERALTEST) { literal.execute(nullptr, &block, &ret); auto ctn = block.safe_get_by_position(ret); auto v = (*ctn.column)[0].get>(); - ASSERT_FLOAT_EQ(((double)v.get_value()) / (std::pow(10, v.get_scale())), 1234.56); + EXPECT_FLOAT_EQ(((double)v.get_value()) / (std::pow(10, v.get_scale())), 1234.56); } } - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/CMakeLists.txt b/be/test/vec/function/CMakeLists.txt deleted file mode 100644 index 4a68ad1231..0000000000 --- a/be/test/vec/function/CMakeLists.txt +++ /dev/null @@ -1,35 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/function") - -ADD_BE_TEST(function_array_element_test) -ADD_BE_TEST(function_array_index_test) -ADD_BE_TEST(function_bitmap_test) -ADD_BE_TEST(function_comparison_test) -ADD_BE_TEST(function_hash_test) -ADD_BE_TEST(function_math_test) -ADD_BE_TEST(function_string_test) -ADD_BE_TEST(function_time_test) -ADD_BE_TEST(function_ifnull_test) -ADD_BE_TEST(function_nullif_test) -ADD_BE_TEST(function_like_test) -ADD_BE_TEST(function_arithmetic_test) -ADD_BE_TEST(function_json_test) -ADD_BE_TEST(function_geo_test) -ADD_BE_TEST(table_function_test) diff --git a/be/test/vec/function/function_arithmetic_test.cpp b/be/test/vec/function/function_arithmetic_test.cpp index 8dfe3d74a0..a0c22a2686 100644 --- a/be/test/vec/function/function_arithmetic_test.cpp +++ b/be/test/vec/function/function_arithmetic_test.cpp @@ -117,9 +117,3 @@ TEST(function_arithmetic_test, bitxor_test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_array_element_test.cpp b/be/test/vec/function/function_array_element_test.cpp index 67b953dafb..f36c33c38a 100644 --- a/be/test/vec/function/function_array_element_test.cpp +++ b/be/test/vec/function/function_array_element_test.cpp @@ -77,8 +77,3 @@ TEST(function_array_element_test, element_at) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_array_index_test.cpp b/be/test/vec/function/function_array_index_test.cpp index 311468df10..eb4c27f7f6 100644 --- a/be/test/vec/function/function_array_index_test.cpp +++ b/be/test/vec/function/function_array_index_test.cpp @@ -144,8 +144,3 @@ TEST(function_array_index_test, array_position) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_bitmap_test.cpp b/be/test/vec/function/function_bitmap_test.cpp index 2341c9152e..77c0cbd549 100644 --- a/be/test/vec/function/function_bitmap_test.cpp +++ b/be/test/vec/function/function_bitmap_test.cpp @@ -222,8 +222,3 @@ TEST(function_bitmap_test, function_bitmap_has_all) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_comparison_test.cpp b/be/test/vec/function/function_comparison_test.cpp index ede480925f..889b11595d 100644 --- a/be/test/vec/function/function_comparison_test.cpp +++ b/be/test/vec/function/function_comparison_test.cpp @@ -81,7 +81,7 @@ TEST(ComparisonTest, ComparisonFunctionTest) { k2 = 100; for (int i = 0; i < 1024; ++i, k1++, k2--) { vectorized::ColumnPtr column = block.get_columns()[3]; - ASSERT_EQ(column->get_bool(i), k1 > k2); + EXPECT_EQ(column->get_bool(i), k1 > k2); } // 2. compute the k2 <= k3 @@ -100,7 +100,7 @@ TEST(ComparisonTest, ComparisonFunctionTest) { k3 = 7.7; for (int i = 0; i < 1024; ++i, k3 += 0.1, k2--) { vectorized::ColumnPtr column = block.get_columns()[4]; - ASSERT_EQ(column->get_bool(i), k2 <= k3); + EXPECT_EQ(column->get_bool(i), k2 <= k3); } num_columns_without_result = block.columns(); @@ -119,7 +119,7 @@ TEST(ComparisonTest, ComparisonFunctionTest) { k3 = 7.7; for (int i = 0; i < 1024; ++i, k1++, k3 += 0.1, k2--) { vectorized::ColumnPtr column = block.get_columns()[5]; - ASSERT_EQ(column->get_bool(i), k1 > k2 and k2 <= k3); + EXPECT_EQ(column->get_bool(i), k1 > k2 and k2 <= k3); } num_columns_without_result = block.columns(); @@ -137,13 +137,8 @@ TEST(ComparisonTest, ComparisonFunctionTest) { k3 = 7.7; for (int i = 0; i < 1024; ++i, k1++, k3 += 0.1, k2--) { vectorized::ColumnPtr column = block.get_columns()[6]; - ASSERT_EQ(column->get_bool(i), k1 > k2 or k2 <= k3); + EXPECT_EQ(column->get_bool(i), k1 > k2 or k2 <= k3); } } } // namespace doris - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_geo_test.cpp b/be/test/vec/function/function_geo_test.cpp index f514233459..0b833a987a 100644 --- a/be/test/vec/function/function_geo_test.cpp +++ b/be/test/vec/function/function_geo_test.cpp @@ -30,119 +30,115 @@ namespace doris::vectorized { using namespace ut_type; -TEST(function_geo_test, function_geo_st_point_test) { +TEST(VGeoFunctionsTest, function_geo_st_point_test) { std::string func_name = "st_point"; { InputTypeSet input_types = {TypeIndex::Float64, TypeIndex::Float64}; GeoPoint point; auto cur_res = point.from_coord(24.7, 56.7); - ASSERT_TRUE(cur_res == GEO_PARSE_OK); + EXPECT_TRUE(cur_res == GEO_PARSE_OK); std::string buf; point.encode_to(&buf); - DataSet data_set = { - {{(double) 24.7, (double) 56.7}, buf}, - {{Null(), (double) 5}, Null()}, - {{(double) 5, Null()}, Null()}}; + DataSet data_set = {{{(double)24.7, (double)56.7}, buf}, + {{Null(), (double)5}, Null()}, + {{(double)5, Null()}, Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_as_text) { +TEST(VGeoFunctionsTest, function_geo_st_as_text) { std::string func_name = "st_astext"; { InputTypeSet input_types = {TypeIndex::String}; GeoPoint point; auto cur_res = point.from_coord(24.7, 56.7); - ASSERT_TRUE(cur_res == GEO_PARSE_OK); + EXPECT_TRUE(cur_res == GEO_PARSE_OK); std::string buf; point.encode_to(&buf); - DataSet data_set = { - {{buf}, std::string("POINT (24.7 56.7)")}, - {{Null()}, Null()}}; + DataSet data_set = {{{buf}, std::string("POINT (24.7 56.7)")}, {{Null()}, Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_as_wkt) { +TEST(VGeoFunctionsTest, function_geo_st_as_wkt) { std::string func_name = "st_aswkt"; { InputTypeSet input_types = {TypeIndex::String}; GeoPoint point; auto cur_res = point.from_coord(24.7, 56.7); - ASSERT_TRUE(cur_res == GEO_PARSE_OK); + EXPECT_TRUE(cur_res == GEO_PARSE_OK); std::string buf; point.encode_to(&buf); - DataSet data_set = { - {{buf}, std::string("POINT (24.7 56.7)")}, - {{Null()}, Null()}}; + DataSet data_set = {{{buf}, std::string("POINT (24.7 56.7)")}, {{Null()}, Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_x) { +TEST(VGeoFunctionsTest, function_geo_st_x) { std::string func_name = "st_x"; { InputTypeSet input_types = {TypeIndex::String}; GeoPoint point; auto cur_res = point.from_coord(24.7, 56.7); - ASSERT_TRUE(cur_res == GEO_PARSE_OK); + EXPECT_TRUE(cur_res == GEO_PARSE_OK); std::string buf; point.encode_to(&buf); - DataSet data_set = { - {{buf}, (double) 24.7}, - {{Null()}, Null()}}; + DataSet data_set = {{{buf}, (double)24.7}, {{Null()}, Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_y) { +TEST(VGeoFunctionsTest, function_geo_st_y) { std::string func_name = "st_y"; { InputTypeSet input_types = {TypeIndex::String}; GeoPoint point; auto cur_res = point.from_coord(24.7, 56.7); - ASSERT_TRUE(cur_res == GEO_PARSE_OK); + EXPECT_TRUE(cur_res == GEO_PARSE_OK); std::string buf; point.encode_to(&buf); - DataSet data_set = { - {{buf}, (double) 56.7}, - {{Null()}, Null()}}; + DataSet data_set = {{{buf}, (double)56.7}, {{Null()}, Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_distance_sphere) { +TEST(VGeoFunctionsTest, function_geo_st_distance_sphere) { std::string func_name = "st_distance_sphere"; { - InputTypeSet input_types = {TypeIndex::Float64, TypeIndex::Float64, TypeIndex::Float64, TypeIndex::Float64}; + InputTypeSet input_types = {TypeIndex::Float64, TypeIndex::Float64, TypeIndex::Float64, + TypeIndex::Float64}; DataSet data_set = { - {{(double) 116.35620117, (double) 39.939093, (double) 116.4274406433, (double) 39.9020987219}, (double) 7336.9135549995917}, - {{(double) 116.35620117, (double) 39.939093, (double) 116.4274406433, Null()}, Null()}, - {{(double) 116.35620117, (double) 39.939093, Null(), (double) 39.9020987219}, Null()}, - {{(double) 116.35620117, Null(), (double) 116.4274406433, (double) 39.9020987219}, Null()}, - {{Null(), (double) 39.939093, (double) 116.4274406433, (double) 39.9020987219}, Null()}}; + {{(double)116.35620117, (double)39.939093, (double)116.4274406433, + (double)39.9020987219}, + (double)7336.9135549995917}, + {{(double)116.35620117, (double)39.939093, (double)116.4274406433, Null()}, Null()}, + {{(double)116.35620117, (double)39.939093, Null(), (double)39.9020987219}, Null()}, + {{(double)116.35620117, Null(), (double)116.4274406433, (double)39.9020987219}, + Null()}, + {{Null(), (double)39.939093, (double)116.4274406433, (double)39.9020987219}, + Null()}}; check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_contains) { +TEST(VGeoFunctionsTest, function_geo_st_contains) { std::string func_name = "st_contains"; { InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; @@ -153,33 +149,31 @@ TEST(function_geo_test, function_geo_st_contains) { GeoParseStatus status; std::string shape1 = std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"); - std::unique_ptr shape( - GeoShape::from_wkt(shape1.data(), shape1.size(), &status)); - ASSERT_TRUE(status == GEO_PARSE_OK); - ASSERT_TRUE(shape != nullptr); + std::unique_ptr shape(GeoShape::from_wkt(shape1.data(), shape1.size(), &status)); + EXPECT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); shape->encode_to(&buf1); GeoPoint point1; status = point1.from_coord(5, 5); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(status == GEO_PARSE_OK); point1.encode_to(&buf2); GeoPoint point2; status = point2.from_coord(50, 50); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(status == GEO_PARSE_OK); point2.encode_to(&buf3); - DataSet data_set = { - {{buf1, buf2}, (uint8_t) 1}, - {{buf1, buf3}, (uint8_t) 0}, - {{buf1, Null()}, Null()}, - {{Null(), buf3}, Null()}}; + DataSet data_set = {{{buf1, buf2}, (uint8_t)1}, + {{buf1, buf3}, (uint8_t)0}, + {{buf1, Null()}, Null()}, + {{Null(), buf3}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_circle) { +TEST(VGeoFunctionsTest, function_geo_st_circle) { std::string func_name = "st_circle"; { InputTypeSet input_types = {TypeIndex::Float64, TypeIndex::Float64, TypeIndex::Float64}; @@ -187,19 +181,18 @@ TEST(function_geo_test, function_geo_st_circle) { GeoCircle circle; std::string buf; auto value = circle.init(111, 64, 10000); - ASSERT_TRUE(value == GEO_PARSE_OK); + EXPECT_TRUE(value == GEO_PARSE_OK); circle.encode_to(&buf); - DataSet data_set = { - {{(double) 111, (double) 64, (double) 10000}, buf}, - {{Null(), (double) 64, (double) 10000}, Null()}, - {{(double) 111, Null(), (double) 10000}, Null()}, - {{(double) 111, (double) 64, Null()}, Null()}}; + DataSet data_set = {{{(double)111, (double)64, (double)10000}, buf}, + {{Null(), (double)64, (double)10000}, Null()}, + {{(double)111, Null(), (double)10000}, Null()}, + {{(double)111, (double)64, Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_geometryfromtext) { +TEST(VGeoFunctionsTest, function_geo_st_geometryfromtext) { std::string func_name = "st_geometryfromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -208,18 +201,16 @@ TEST(function_geo_test, function_geo_st_geometryfromtext) { std::string buf; std::string input = "LINESTRING (1 1, 2 2)"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("LINESTRING (1 1, 2 2)")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("LINESTRING (1 1, 2 2)")}, buf}, {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_geomfromtext) { +TEST(VGeoFunctionsTest, function_geo_st_geomfromtext) { std::string func_name = "st_geomfromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -228,18 +219,16 @@ TEST(function_geo_test, function_geo_st_geomfromtext) { std::string buf; std::string input = "LINESTRING (1 1, 2 2)"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("LINESTRING (1 1, 2 2)")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("LINESTRING (1 1, 2 2)")}, buf}, {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_linefromtext) { +TEST(VGeoFunctionsTest, function_geo_st_linefromtext) { std::string func_name = "st_linefromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -248,18 +237,16 @@ TEST(function_geo_test, function_geo_st_linefromtext) { std::string buf; std::string input = "LINESTRING (1 1, 2 2)"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("LINESTRING (1 1, 2 2)")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("LINESTRING (1 1, 2 2)")}, buf}, {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_linestringfromtext) { +TEST(VGeoFunctionsTest, function_geo_st_linestringfromtext) { std::string func_name = "st_linestringfromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -268,18 +255,16 @@ TEST(function_geo_test, function_geo_st_linestringfromtext) { std::string buf; std::string input = "LINESTRING (1 1, 2 2)"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("LINESTRING (1 1, 2 2)")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("LINESTRING (1 1, 2 2)")}, buf}, {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_polygon) { +TEST(VGeoFunctionsTest, function_geo_st_polygon) { std::string func_name = "st_polygon"; { InputTypeSet input_types = {TypeIndex::String}; @@ -288,18 +273,17 @@ TEST(function_geo_test, function_geo_st_polygon) { std::string buf; std::string input = "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, + {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_polygonfromtext) { +TEST(VGeoFunctionsTest, function_geo_st_polygonfromtext) { std::string func_name = "st_polygonfromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -308,18 +292,17 @@ TEST(function_geo_test, function_geo_st_polygonfromtext) { std::string buf; std::string input = "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, + {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } -TEST(function_geo_test, function_geo_st_polyfromtext) { +TEST(VGeoFunctionsTest, function_geo_st_polyfromtext) { std::string func_name = "st_polyfromtext"; { InputTypeSet input_types = {TypeIndex::String}; @@ -328,21 +311,14 @@ TEST(function_geo_test, function_geo_st_polyfromtext) { std::string buf; std::string input = "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"; std::unique_ptr shape(GeoShape::from_wkt(input.data(), input.size(), &status)); - ASSERT_TRUE(shape != nullptr); - ASSERT_TRUE(status == GEO_PARSE_OK); + EXPECT_TRUE(shape != nullptr); + EXPECT_TRUE(status == GEO_PARSE_OK); shape->encode_to(&buf); - DataSet data_set = { - {{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, - {{Null()}, Null()}}; + DataSet data_set = {{{std::string("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")}, buf}, + {{Null()}, Null()}}; - check_function(func_name, input_types, data_set); + check_function(func_name, input_types, data_set); } } } // namespace doris::vectorized - -int main(int argc, char** argv) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_hash_test.cpp b/be/test/vec/function/function_hash_test.cpp index 41cfc522dc..be22cea4bd 100644 --- a/be/test/vec/function/function_hash_test.cpp +++ b/be/test/vec/function/function_hash_test.cpp @@ -89,8 +89,3 @@ TEST(HashFunctionTest, murmur_hash_2_test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_ifnull_test.cpp b/be/test/vec/function/function_ifnull_test.cpp index 9d5df6c2c6..1d1379d457 100644 --- a/be/test/vec/function/function_ifnull_test.cpp +++ b/be/test/vec/function/function_ifnull_test.cpp @@ -65,8 +65,3 @@ TEST(IfNullTest, String_Int_Test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_json_test.cpp b/be/test/vec/function/function_json_test.cpp index acb3fb90be..0f87e45c11 100644 --- a/be/test/vec/function/function_json_test.cpp +++ b/be/test/vec/function/function_json_test.cpp @@ -67,8 +67,3 @@ TEST(FunctionJsonTEST, GetJsonStringTest) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_like_test.cpp b/be/test/vec/function/function_like_test.cpp index 5674c07c4a..e3c63fd294 100644 --- a/be/test/vec/function/function_like_test.cpp +++ b/be/test/vec/function/function_like_test.cpp @@ -106,34 +106,46 @@ TEST(FunctionLikeTest, regexp) { check_function(func_name, input_types, data_set); } - TEST(FunctionLikeTest, regexp_extract) { std::string func_name = "regexp_extract"; - DataSet data_set = { - {{std::string("x=a3&x=18abc&x=2&y=3&x=4"), std::string("x=([0-9]+)([a-z]+)"), (int64_t)0}, std::string("x=18abc")}, - {{std::string("x=a3&x=18abc&x=2&y=3&x=4"), std::string("^x=([a-z]+)([0-9]+)"),(int64_t)0}, std::string("x=a3")}, - {{std::string("x=a3&x=18abc&x=2&y=3&x=4"), std::string("^x=([a-z]+)([0-9]+)"),(int64_t)1}, std::string("a")}, - {{std::string("http://a.m.baidu.com/i41915173660.htm"), std::string("i([0-9]+)"),(int64_t)0}, std::string("i41915173660")}, - {{std::string("http://a.m.baidu.com/i41915173660.htm"), std::string("i([0-9]+)"),(int64_t)1}, std::string("41915173660")}, + DataSet data_set = {{{std::string("x=a3&x=18abc&x=2&y=3&x=4"), + std::string("x=([0-9]+)([a-z]+)"), (int64_t)0}, + std::string("x=18abc")}, + {{std::string("x=a3&x=18abc&x=2&y=3&x=4"), + std::string("^x=([a-z]+)([0-9]+)"), (int64_t)0}, + std::string("x=a3")}, + {{std::string("x=a3&x=18abc&x=2&y=3&x=4"), + std::string("^x=([a-z]+)([0-9]+)"), (int64_t)1}, + std::string("a")}, + {{std::string("http://a.m.baidu.com/i41915173660.htm"), + std::string("i([0-9]+)"), (int64_t)0}, + std::string("i41915173660")}, + {{std::string("http://a.m.baidu.com/i41915173660.htm"), + std::string("i([0-9]+)"), (int64_t)1}, + std::string("41915173660")}, - {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"),(int64_t)0}, std::string("itde")}, - {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"),(int64_t)1}, std::string("i")}, - {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"),(int64_t)2}, std::string("td")}, + {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"), (int64_t)0}, + std::string("itde")}, + {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"), (int64_t)1}, + std::string("i")}, + {{std::string("hitdecisiondlist"), std::string("(i)(.*?)(e)"), (int64_t)2}, + std::string("td")}, // null {{std::string("abc"), Null(), (int64_t)0}, Null()}, {{Null(), std::string("i([0-9]+)"), (int64_t)0}, Null()}}; // pattern is constant value - InputTypeSet const_pattern_input_types = {TypeIndex::String, Consted {TypeIndex::String}, TypeIndex::Int64}; + InputTypeSet const_pattern_input_types = {TypeIndex::String, Consted {TypeIndex::String}, + TypeIndex::Int64}; for (const auto& line : data_set) { DataSet const_pattern_dataset = {line}; check_function(func_name, const_pattern_input_types, - const_pattern_dataset); + const_pattern_dataset); } // pattern is not constant value - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String , TypeIndex::Int64}; + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::Int64}; check_function(func_name, input_types, data_set); } @@ -141,34 +153,34 @@ TEST(FunctionLikeTest, regexp_replace) { std::string func_name = "regexp_replace"; DataSet data_set = { - {{std::string("2022-03-02"), std::string("-"), std::string("")}, std::string("20220302")}, - {{std::string("2022-03-02"), std::string(""),std::string("s")}, std::string("s2s0s2s2s-s0s3s-s0s2s")}, - {{std::string("100-200"), std::string("(\\d+)"),std::string("doris")}, std::string("doris-doris")}, + {{std::string("2022-03-02"), std::string("-"), std::string("")}, + std::string("20220302")}, + {{std::string("2022-03-02"), std::string(""), std::string("s")}, + std::string("s2s0s2s2s-s0s3s-s0s2s")}, + {{std::string("100-200"), std::string("(\\d+)"), std::string("doris")}, + std::string("doris-doris")}, - {{std::string("a b c"), std::string(" "),std::string("-")}, std::string("a-b-c")}, - {{std::string("a b c"), std::string("(b)"),std::string("<\\1>")}, std::string("a c")}, - {{std::string("qwewe"), std::string(""),std::string("true")}, std::string("trueqtruewtrueetruewtrueetrue")}, - // null - {{std::string("abc"), std::string("x=18abc"), Null()}, Null()}, - {{Null(), std::string("i([0-9]+)"), std::string("x=18abc")}, Null()}}; + {{std::string("a b c"), std::string(" "), std::string("-")}, std::string("a-b-c")}, + {{std::string("a b c"), std::string("(b)"), std::string("<\\1>")}, + std::string("a c")}, + {{std::string("qwewe"), std::string(""), std::string("true")}, + std::string("trueqtruewtrueetruewtrueetrue")}, + // null + {{std::string("abc"), std::string("x=18abc"), Null()}, Null()}, + {{Null(), std::string("i([0-9]+)"), std::string("x=18abc")}, Null()}}; // pattern is constant value - InputTypeSet const_pattern_input_types = {TypeIndex::String, Consted {TypeIndex::String}, TypeIndex::String}; + InputTypeSet const_pattern_input_types = {TypeIndex::String, Consted {TypeIndex::String}, + TypeIndex::String}; for (const auto& line : data_set) { DataSet const_pattern_dataset = {line}; check_function(func_name, const_pattern_input_types, - const_pattern_dataset); + const_pattern_dataset); } // pattern is not constant value - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String , TypeIndex::String}; + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String}; check_function(func_name, input_types, data_set); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - doris::CpuInfo::init(); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_math_test.cpp b/be/test/vec/function/function_math_test.cpp index 448cf840e0..2a28521ff5 100644 --- a/be/test/vec/function/function_math_test.cpp +++ b/be/test/vec/function/function_math_test.cpp @@ -147,7 +147,7 @@ TEST(MathFunctionTest, ln_test) { {{-2.0}, Null()}, {{100.0}, 4.6051701859880918}, {{1000.0}, 6.9077552789821368}}; - + check_function(func_name, input_types, data_set); } @@ -170,9 +170,11 @@ TEST(MathFunctionTest, log10_test) { InputTypeSet input_types = {TypeIndex::Float64}; - DataSet data_set = { - {{1.0}, 0.0}, {{0.5}, -0.3010299956639812}, - {{100.0}, 2.0}, {{-1.0}, Null()}, {{1000.0}, 3.0}}; + DataSet data_set = {{{1.0}, 0.0}, + {{0.5}, -0.3010299956639812}, + {{100.0}, 2.0}, + {{-1.0}, Null()}, + {{1000.0}, 3.0}}; check_function(func_name, input_types, data_set); } @@ -182,12 +184,9 @@ TEST(MathFunctionTest, log_test) { InputTypeSet input_types = {TypeIndex::Float64, TypeIndex::Float64}; - DataSet data_set = {{{10.0, 1.0}, 0.0}, - {{10.0, 100.0}, 2.0}, - {{0.1, 5.0}, -0.69897000433601886}, - {{-2.0, 5.0}, Null()}, - {{2.0, -5.0}, Null()}, - {{2.0, 0.5}, -1.0}}; + DataSet data_set = { + {{10.0, 1.0}, 0.0}, {{10.0, 100.0}, 2.0}, {{0.1, 5.0}, -0.69897000433601886}, + {{-2.0, 5.0}, Null()}, {{2.0, -5.0}, Null()}, {{2.0, 0.5}, -1.0}}; check_function(func_name, input_types, data_set); } @@ -389,8 +388,8 @@ TEST(MathFunctionTest, least_test) { InputTypeSet input_types = {TypeIndex::Int32, TypeIndex::Int32}; - DataSet data_set = {{{3, 2}, 2}, {{3, 3}, 3}, {{Null(), -2}, Null()}, - {{193, -2}, -2}, {{193, -1}, -1}}; + DataSet data_set = { + {{3, 2}, 2}, {{3, 3}, 3}, {{Null(), -2}, Null()}, {{193, -2}, -2}, {{193, -1}, -1}}; check_function(func_name, input_types, data_set); } @@ -400,8 +399,8 @@ TEST(MathFunctionTest, greatest_test) { InputTypeSet input_types = {TypeIndex::Int32, TypeIndex::Int32}; - DataSet data_set = {{{3, 2}, 3}, {{3, 3}, 3}, {{Null(), -2}, Null()}, - {{193, -2}, 193}, {{193, -1}, 193}}; + DataSet data_set = { + {{3, 2}, 3}, {{3, 3}, 3}, {{Null(), -2}, Null()}, {{193, -2}, 193}, {{193, -1}, 193}}; check_function(func_name, input_types, data_set); } @@ -519,8 +518,3 @@ TEST(MathFunctionTest, money_format_test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_nullif_test.cpp b/be/test/vec/function/function_nullif_test.cpp index 73d0ca93de..b750520383 100644 --- a/be/test/vec/function/function_nullif_test.cpp +++ b/be/test/vec/function/function_nullif_test.cpp @@ -57,8 +57,3 @@ TEST(NullIfTest, String_Int_Test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/be/test/vec/function/function_string_test.cpp b/be/test/vec/function/function_string_test.cpp index 61b1e529bc..94e877e2ac 100644 --- a/be/test/vec/function/function_string_test.cpp +++ b/be/test/vec/function/function_string_test.cpp @@ -568,40 +568,50 @@ TEST(function_string_test, function_sm3sum_test) { { InputTypeSet input_types = {TypeIndex::String}; DataSet data_set = { - {{std::string("asd你好")}, {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, - {{std::string("hello world")}, {std::string("44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88")}}, - {{std::string("HELLO,!^%")}, {std::string("5fc6e38f40b31a659a59e1daba9b68263615f20c02037b419d9deb3509e6b5c6")}}, - {{std::string("")}, {std::string("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b")}}, - {{std::string(" ")}, {std::string("2ae1d69bb8483e5944310c877573b21d0a420c3bf4a2a91b1a8370d760ba67c5")}}, + {{std::string("asd你好")}, + {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, + {{std::string("hello world")}, + {std::string("44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88")}}, + {{std::string("HELLO,!^%")}, + {std::string("5fc6e38f40b31a659a59e1daba9b68263615f20c02037b419d9deb3509e6b5c6")}}, + {{std::string("")}, + {std::string("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b")}}, + {{std::string(" ")}, + {std::string("2ae1d69bb8483e5944310c877573b21d0a420c3bf4a2a91b1a8370d760ba67c5")}}, {{Null()}, {Null()}}, - {{std::string("MYtestSTR")}, {std::string("3155ae9f834cae035385fc15b69b6f2c051b91de943ea9a03ab8bfd497aef4c6")}}, - {{std::string("ò&ø")}, {std::string("aa47ac31c85aa819d4cc80c932e7900fa26a3073a67aa7eb011bc2ba4924a066")}}}; + {{std::string("MYtestSTR")}, + {std::string("3155ae9f834cae035385fc15b69b6f2c051b91de943ea9a03ab8bfd497aef4c6")}}, + {{std::string("ò&ø")}, + {std::string( + "aa47ac31c85aa819d4cc80c932e7900fa26a3073a67aa7eb011bc2ba4924a066")}}}; check_function(func_name, input_types, data_set); } { InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; - DataSet data_set = {{{std::string("asd"), std::string("你好")}, - {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, - {{std::string("hello "), std::string("world")}, - {std::string("44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88")}}, - {{std::string("HELLO "), std::string(",!^%")}, - {std::string("1f5866e786ebac9ffed0dbd8f2586e3e99d1d05f7efe7c5915478b57b7423570")}}, - {{Null(), std::string("HELLO")}, {Null()}}}; + DataSet data_set = { + {{std::string("asd"), std::string("你好")}, + {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, + {{std::string("hello "), std::string("world")}, + {std::string("44f0061e69fa6fdfc290c494654a05dc0c053da7e5c52b84ef93a9d67d3fff88")}}, + {{std::string("HELLO "), std::string(",!^%")}, + {std::string("1f5866e786ebac9ffed0dbd8f2586e3e99d1d05f7efe7c5915478b57b7423570")}}, + {{Null(), std::string("HELLO")}, {Null()}}}; check_function(func_name, input_types, data_set); } { InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String}; - DataSet data_set = {{{std::string("a"), std::string("sd"), std::string("你好")}, - {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, - {{std::string(""), std::string(""), std::string("")}, - {std::string("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b")}}, - {{std::string("HEL"), std::string("LO,!"), std::string("^%")}, - {std::string("5fc6e38f40b31a659a59e1daba9b68263615f20c02037b419d9deb3509e6b5c6")}}, - {{Null(), std::string("HELLO"), Null()}, {Null()}}}; + DataSet data_set = { + {{std::string("a"), std::string("sd"), std::string("你好")}, + {std::string("0d6b9dfa8fe5708eb0dccfbaff4f2964abaaa976cc4445a7ecace49c0ceb31d3")}}, + {{std::string(""), std::string(""), std::string("")}, + {std::string("1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b")}}, + {{std::string("HEL"), std::string("LO,!"), std::string("^%")}, + {std::string("5fc6e38f40b31a659a59e1daba9b68263615f20c02037b419d9deb3509e6b5c6")}}, + {{Null(), std::string("HELLO"), Null()}, {Null()}}}; check_function(func_name, input_types, data_set); } @@ -609,253 +619,263 @@ TEST(function_string_test, function_sm3sum_test) { TEST(function_string_test, function_aes_encrypt_test) { std::string func_name = "aes_encrypt"; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; - const char* key = "doris"; - const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; - std::string r[5]; + const char* key = "doris"; + const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; + std::string r[5]; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; - int outlen = EncryptionUtil::encrypt(AES_128_ECB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), NULL, true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + int outlen = EncryptionUtil::encrypt(AES_128_ECB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + NULL, true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } + + DataSet data_set = {{{std::string(src[0]), std::string(key)}, r[0]}, + {{std::string(src[1]), std::string(key)}, r[1]}, + {{std::string(src[2]), std::string(key)}, r[2]}, + {{std::string(src[3]), std::string(key)}, r[3]}, + {{std::string(src[4]), std::string(key)}, r[4]}, + {{std::string(src[5]), std::string(key)}, Null()}, + {{Null(), std::string(key)}, Null()}}; + + check_function(func_name, input_types, data_set); } + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, + TypeIndex::String}; + const char* iv = "0123456789abcdef"; + const char* mode = "AES_256_ECB"; + const char* key = "vectorized"; + const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; + std::string r[5]; - DataSet data_set = {{{std::string(src[0]), std::string(key)}, r[0]}, - {{std::string(src[1]), std::string(key)}, r[1]}, - {{std::string(src[2]), std::string(key)}, r[2]}, - {{std::string(src[3]), std::string(key)}, r[3]}, - {{std::string(src[4]), std::string(key)}, r[4]}, - {{std::string(src[5]), std::string(key)}, Null()}, - {{Null(), std::string(key)}, Null()}}; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; + int iv_len = 32; + std::unique_ptr init_vec; + init_vec.reset(new char[iv_len]); + std::memset(init_vec.get(), 0, strlen(iv) + 1); + memcpy(init_vec.get(), iv, strlen(iv)); + int outlen = EncryptionUtil::encrypt(AES_256_ECB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + init_vec.get(), true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } - check_function(func_name, input_types, data_set); -} -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, TypeIndex::String}; - const char* iv = "0123456789abcdef"; - const char* mode = "AES_256_ECB"; - const char* key = "vectorized"; - const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; - std::string r[5]; + DataSet data_set = { + {{std::string(src[0]), std::string(key), std::string(iv), std::string(mode)}, r[0]}, + {{std::string(src[1]), std::string(key), std::string(iv), std::string(mode)}, r[1]}, + {{std::string(src[2]), std::string(key), std::string(iv), std::string(mode)}, r[2]}, + {{std::string(src[3]), std::string(key), std::string(iv), std::string(mode)}, r[3]}, + {{std::string(src[4]), std::string(key), std::string(iv), std::string(mode)}, r[4]}, + {{std::string(src[5]), std::string(key), std::string(iv), std::string(mode)}, + Null()}, + {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; - int iv_len = 32; - std::unique_ptr init_vec; - init_vec.reset(new char[iv_len]); - std::memset(init_vec.get(), 0, strlen(iv) + 1); - memcpy(init_vec.get(), iv, strlen(iv)); - int outlen = EncryptionUtil::encrypt(AES_256_ECB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), init_vec.get(), true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + check_function(func_name, input_types, data_set); } - - DataSet data_set = {{{std::string(src[0]), std::string(key), std::string(iv), std::string(mode)}, r[0]}, - {{std::string(src[1]), std::string(key), std::string(iv), std::string(mode)}, r[1]}, - {{std::string(src[2]), std::string(key), std::string(iv), std::string(mode)}, r[2]}, - {{std::string(src[3]), std::string(key), std::string(iv), std::string(mode)}, r[3]}, - {{std::string(src[4]), std::string(key), std::string(iv), std::string(mode)}, r[4]}, - {{std::string(src[5]), std::string(key), std::string(iv), std::string(mode)}, Null()}, - {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - - check_function(func_name, input_types, data_set); -} } TEST(function_string_test, function_aes_decrypt_test) { std::string func_name = "aes_decrypt"; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; - const char* key = "doris"; - const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; - std::string r[5]; + const char* key = "doris"; + const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; + std::string r[5]; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; - int outlen = EncryptionUtil::encrypt(AES_128_ECB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), NULL, true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + int outlen = EncryptionUtil::encrypt(AES_128_ECB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + NULL, true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } + + DataSet data_set = {{{r[0], std::string(key)}, std::string(src[0])}, + {{r[1], std::string(key)}, std::string(src[1])}, + {{r[2], std::string(key)}, std::string(src[2])}, + {{r[3], std::string(key)}, std::string(src[3])}, + {{r[4], std::string(key)}, std::string(src[4])}, + {{Null(), std::string(key)}, Null()}}; + + check_function(func_name, input_types, data_set); } + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, + TypeIndex::String}; + const char* key = "vectorized"; + const char* iv = "0123456789abcdef"; + const char* mode = "AES_128_OFB"; + const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; - DataSet data_set = {{{r[0], std::string(key)}, std::string(src[0])}, - {{r[1], std::string(key)}, std::string(src[1])}, - {{r[2], std::string(key)}, std::string(src[2])}, - {{r[3], std::string(key)}, std::string(src[3])}, - {{r[4], std::string(key)}, std::string(src[4])}, - {{Null(), std::string(key)}, Null()}}; + std::string r[5]; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; + int iv_len = 32; + std::unique_ptr init_vec; + init_vec.reset(new char[iv_len]); + std::memset(init_vec.get(), 0, strlen(iv) + 1); + memcpy(init_vec.get(), iv, strlen(iv)); + int outlen = EncryptionUtil::encrypt(AES_128_OFB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + init_vec.get(), true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } + DataSet data_set = { + {{r[0], std::string(key), std::string(iv), std::string(mode)}, std::string(src[0])}, + {{r[1], std::string(key), std::string(iv), std::string(mode)}, std::string(src[1])}, + {{r[2], std::string(key), std::string(iv), std::string(mode)}, std::string(src[2])}, + {{r[3], std::string(key), std::string(iv), std::string(mode)}, std::string(src[3])}, + {{r[4], std::string(key), std::string(iv), std::string(mode)}, std::string(src[4])}, + {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - check_function(func_name, input_types, data_set); -} -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, TypeIndex::String}; - const char* key = "vectorized"; - const char* iv = "0123456789abcdef"; - const char* mode = "AES_128_OFB"; - const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; - - std::string r[5]; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; - int iv_len = 32; - std::unique_ptr init_vec; - init_vec.reset(new char[iv_len]); - std::memset(init_vec.get(), 0, strlen(iv) + 1); - memcpy(init_vec.get(), iv, strlen(iv)); - int outlen = EncryptionUtil::encrypt(AES_128_OFB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), init_vec.get(), true, - (unsigned char*)p); - r[i] = std::string(p, outlen); - } - DataSet data_set = {{{r[0], std::string(key), std::string(iv), std::string(mode)}, std::string(src[0])}, - {{r[1], std::string(key), std::string(iv), std::string(mode)}, std::string(src[1])}, - {{r[2], std::string(key), std::string(iv), std::string(mode)}, std::string(src[2])}, - {{r[3], std::string(key), std::string(iv), std::string(mode)}, std::string(src[3])}, - {{r[4], std::string(key), std::string(iv), std::string(mode)}, std::string(src[4])}, - {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - - check_function(func_name, input_types, data_set); -} + check_function(func_name, input_types, data_set); + } } TEST(function_string_test, function_sm4_encrypt_test) { std::string func_name = "sm4_encrypt"; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; - const char* key = "doris"; - const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; - std::string r[5]; + const char* key = "doris"; + const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; + std::string r[5]; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; - int outlen = EncryptionUtil::encrypt(SM4_128_ECB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), NULL, true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + int outlen = EncryptionUtil::encrypt(SM4_128_ECB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + NULL, true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } + + DataSet data_set = {{{std::string(src[0]), std::string(key)}, r[0]}, + {{std::string(src[1]), std::string(key)}, r[1]}, + {{std::string(src[2]), std::string(key)}, r[2]}, + {{std::string(src[3]), std::string(key)}, r[3]}, + {{std::string(src[4]), std::string(key)}, r[4]}, + {{std::string(src[5]), std::string(key)}, Null()}, + {{Null(), std::string(key)}, Null()}}; + + check_function(func_name, input_types, data_set); } - DataSet data_set = {{{std::string(src[0]), std::string(key)}, r[0]}, - {{std::string(src[1]), std::string(key)}, r[1]}, - {{std::string(src[2]), std::string(key)}, r[2]}, - {{std::string(src[3]), std::string(key)}, r[3]}, - {{std::string(src[4]), std::string(key)}, r[4]}, - {{std::string(src[5]), std::string(key)}, Null()}, - {{Null(), std::string(key)}, Null()}}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, + TypeIndex::String}; - check_function(func_name, input_types, data_set); -} + const char* key = "vectorized"; + const char* iv = "0123456789abcdef"; + const char* mode = "SM4_128_CTR"; + const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; + std::string r[5]; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, TypeIndex::String}; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; + int iv_len = 32; + std::unique_ptr init_vec; + init_vec.reset(new char[iv_len]); + std::memset(init_vec.get(), 0, strlen(iv) + 1); + memcpy(init_vec.get(), iv, strlen(iv)); + int outlen = EncryptionUtil::encrypt(SM4_128_CTR, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + init_vec.get(), true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } - const char* key = "vectorized"; - const char* iv = "0123456789abcdef"; - const char* mode = "SM4_128_CTR"; - const char* src[6] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee", ""}; - std::string r[5]; + DataSet data_set = { + {{std::string(src[0]), std::string(key), std::string(iv), std::string(mode)}, r[0]}, + {{std::string(src[1]), std::string(key), std::string(iv), std::string(mode)}, r[1]}, + {{std::string(src[2]), std::string(key), std::string(iv), std::string(mode)}, r[2]}, + {{std::string(src[3]), std::string(key), std::string(iv), std::string(mode)}, r[3]}, + {{std::string(src[4]), std::string(key), std::string(iv), std::string(mode)}, r[4]}, + {{std::string(src[5]), std::string(key), std::string(iv), std::string(mode)}, + Null()}, + {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; - int iv_len = 32; - std::unique_ptr init_vec; - init_vec.reset(new char[iv_len]); - std::memset(init_vec.get(), 0, strlen(iv) + 1); - memcpy(init_vec.get(), iv, strlen(iv)); - int outlen = EncryptionUtil::encrypt(SM4_128_CTR, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), init_vec.get(), true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + check_function(func_name, input_types, data_set); } - - DataSet data_set = {{{std::string(src[0]), std::string(key), std::string(iv), std::string(mode)}, r[0]}, - {{std::string(src[1]), std::string(key), std::string(iv), std::string(mode)}, r[1]}, - {{std::string(src[2]), std::string(key), std::string(iv), std::string(mode)}, r[2]}, - {{std::string(src[3]), std::string(key), std::string(iv), std::string(mode)}, r[3]}, - {{std::string(src[4]), std::string(key), std::string(iv), std::string(mode)}, r[4]}, - {{std::string(src[5]), std::string(key), std::string(iv), std::string(mode)}, Null()}, - {{Null(), std::string(key), std::string(iv), std::string(mode)}, Null()}}; - - check_function(func_name, input_types, data_set); -} } TEST(function_string_test, function_sm4_decrypt_test) { std::string func_name = "sm4_decrypt"; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String}; - const char* key = "doris"; - const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; - std::string r[5]; + const char* key = "doris"; + const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; + std::string r[5]; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; - int outlen = EncryptionUtil::encrypt(SM4_128_ECB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), NULL, true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + int outlen = EncryptionUtil::encrypt(SM4_128_ECB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + NULL, true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } + + DataSet data_set = {{{r[0], std::string(key)}, std::string(src[0])}, + {{r[1], std::string(key)}, std::string(src[1])}, + {{r[2], std::string(key)}, std::string(src[2])}, + {{r[3], std::string(key)}, std::string(src[3])}, + {{r[4], std::string(key)}, std::string(src[4])}, + {{Null(), std::string(key)}, Null()}}; + + check_function(func_name, input_types, data_set); } - DataSet data_set = {{{r[0], std::string(key)}, std::string(src[0])}, - {{r[1], std::string(key)}, std::string(src[1])}, - {{r[2], std::string(key)}, std::string(src[2])}, - {{r[3], std::string(key)}, std::string(src[3])}, - {{r[4], std::string(key)}, std::string(src[4])}, - {{Null(), std::string(key)}, Null()}}; + { + InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, + TypeIndex::String}; - check_function(func_name, input_types, data_set); -} + const char* key = "vectorized"; + const char* iv = "0123456789abcdef"; + const char* mode = "SM4_128_OFB"; + const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; + std::string r[5]; -{ - InputTypeSet input_types = {TypeIndex::String, TypeIndex::String, TypeIndex::String, TypeIndex::String}; + for (int i = 0; i < 5; i++) { + int cipher_len = strlen(src[i]) + 16; + char p[cipher_len]; + int iv_len = 32; + std::unique_ptr init_vec; + init_vec.reset(new char[iv_len]); + std::memset(init_vec.get(), 0, strlen(iv) + 1); + memcpy(init_vec.get(), iv, strlen(iv)); + int outlen = EncryptionUtil::encrypt(SM4_128_OFB, (unsigned char*)src[i], + strlen(src[i]), (unsigned char*)key, strlen(key), + init_vec.get(), true, (unsigned char*)p); + r[i] = std::string(p, outlen); + } - const char* key = "vectorized"; - const char* iv = "0123456789abcdef"; - const char* mode = "SM4_128_OFB"; - const char* src[5] = {"aaaaaa", "bbbbbb", "cccccc", "dddddd", "eeeeee"}; - std::string r[5]; + DataSet data_set = { + {{r[0], std::string(key), std::string(iv), std::string(mode)}, std::string(src[0])}, + {{r[1], std::string(key), std::string(iv), std::string(mode)}, std::string(src[1])}, + {{r[2], std::string(key), std::string(iv), std::string(mode)}, std::string(src[2])}, + {{r[3], std::string(key), std::string(iv), std::string(mode)}, std::string(src[3])}, + {{r[4], std::string(key), std::string(iv), std::string(mode)}, std::string(src[4])}, + {{Null(), Null(), std::string(iv), std::string(mode)}, Null()}}; - for (int i = 0; i < 5; i++) { - int cipher_len = strlen(src[i]) + 16; - char p[cipher_len]; - int iv_len = 32; - std::unique_ptr init_vec; - init_vec.reset(new char[iv_len]); - std::memset(init_vec.get(), 0, strlen(iv) + 1); - memcpy(init_vec.get(), iv, strlen(iv)); - int outlen = EncryptionUtil::encrypt(SM4_128_OFB, (unsigned char*)src[i], strlen(src[i]), - (unsigned char*)key, strlen(key), init_vec.get(), true, - (unsigned char*)p); - r[i] = std::string(p, outlen); + check_function(func_name, input_types, data_set); } - - DataSet data_set = {{{r[0], std::string(key), std::string(iv), std::string(mode)}, std::string(src[0])}, - {{r[1], std::string(key), std::string(iv), std::string(mode)}, std::string(src[1])}, - {{r[2], std::string(key), std::string(iv), std::string(mode)}, std::string(src[2])}, - {{r[3], std::string(key), std::string(iv), std::string(mode)}, std::string(src[3])}, - {{r[4], std::string(key), std::string(iv), std::string(mode)}, std::string(src[4])}, - {{Null(), Null(), std::string(iv), std::string(mode)}, Null()}}; - - check_function(func_name, input_types, data_set); -} } TEST(function_string_test, function_parse_url_test) { @@ -1033,9 +1053,3 @@ TEST(function_string_test, function_bit_length_test) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/function_test_util.cpp b/be/test/vec/function/function_test_util.cpp new file mode 100644 index 0000000000..91fa39abed --- /dev/null +++ b/be/test/vec/function/function_test_util.cpp @@ -0,0 +1,309 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "vec/function/function_test_util.h" + +namespace doris::vectorized { +int64_t str_to_data_time(std::string datetime_str, bool data_time) { + VecDateTimeValue v; + v.from_date_str(datetime_str.c_str(), datetime_str.size()); + if (data_time) { //bool data_time only to simplifly means data_time or data to cast, just use in time-functions uint test + v.to_datetime(); + } else { + v.cast_to_date(); + } + return binary_cast(v); +} +size_t type_index_to_data_type(const std::vector& input_types, size_t index, + doris_udf::FunctionContext::TypeDesc& desc, DataTypePtr& type) { + if (index < 0 || index >= input_types.size()) { + return -1; + } + + TypeIndex tp; + if (input_types[index].type() == typeid(Consted)) { + tp = std::any_cast(input_types[index]).tp; + } else { + tp = std::any_cast(input_types[index]); + } + + switch (tp) { + case TypeIndex::String: + desc.type = doris_udf::FunctionContext::TYPE_STRING; + type = std::make_shared(); + return 1; + case TypeIndex::BitMap: + desc.type = doris_udf::FunctionContext::TYPE_OBJECT; + type = std::make_shared(); + return 1; + case TypeIndex::Int8: + desc.type = doris_udf::FunctionContext::TYPE_TINYINT; + type = std::make_shared(); + return 1; + case TypeIndex::Int16: + desc.type = doris_udf::FunctionContext::TYPE_SMALLINT; + type = std::make_shared(); + return 1; + case TypeIndex::Int32: + desc.type = doris_udf::FunctionContext::TYPE_INT; + type = std::make_shared(); + return 1; + case TypeIndex::Int64: + desc.type = doris_udf::FunctionContext::TYPE_BIGINT; + type = std::make_shared(); + return 1; + case TypeIndex::Int128: + desc.type = doris_udf::FunctionContext::TYPE_LARGEINT; + type = std::make_shared(); + return 1; + case TypeIndex::Float64: + desc.type = doris_udf::FunctionContext::TYPE_DOUBLE; + type = std::make_shared(); + return 1; + case TypeIndex::Decimal128: + desc.type = doris_udf::FunctionContext::TYPE_DECIMALV2; + type = std::make_shared>(); + return 1; + case TypeIndex::DateTime: + desc.type = doris_udf::FunctionContext::TYPE_DATETIME; + type = std::make_shared(); + return 1; + case TypeIndex::Date: + desc.type = doris_udf::FunctionContext::TYPE_DATE; + type = std::make_shared(); + return 1; + case TypeIndex::Array: { + desc.type = doris_udf::FunctionContext::TYPE_ARRAY; + doris_udf::FunctionContext::TypeDesc sub_desc; + DataTypePtr sub_type = nullptr; + size_t ret = type_index_to_data_type(input_types, index + 1, sub_desc, sub_type); + if (ret <= 0) { + return ret; + } + desc.children.push_back(doris_udf::FunctionContext::TypeDesc()); + type = std::make_shared(std::move(sub_type)); + return ret + 1; + } + default: + LOG(WARNING) << "not supported TypeIndex:" << (int)tp; + return 0; + } +} +bool parse_ut_data_type(const std::vector& input_types, ut_type::UTDataTypeDescs& descs) { + descs.clear(); + descs.reserve(input_types.size()); + for (size_t i = 0; i < input_types.size();) { + ut_type::UTDataTypeDesc desc; + if (input_types[i].type() == typeid(Consted)) { + desc.is_const = true; + } + size_t res = type_index_to_data_type(input_types, i, desc.type_desc, desc.data_type); + if (res <= 0) { + return false; + } + if (desc.is_nullable) { + desc.data_type = make_nullable(std::move(desc.data_type)); + } + desc.col_name = "k" + std::to_string(i); + descs.emplace_back(desc); + i += res; + } + return true; +} +bool insert_cell(MutableColumnPtr& column, DataTypePtr type_ptr, const std::any& cell) { + if (cell.type() == typeid(Null)) { + column->insert_data(nullptr, 0); + return true; + } + + WhichDataType type(type_ptr); + if (type.is_string()) { + auto str = std::any_cast(cell); + column->insert_data(str.c_str(), str.size()); + } else if (type.idx == TypeIndex::BitMap) { + BitmapValue* bitmap = std::any_cast(cell); + column->insert_data((char*)bitmap, sizeof(BitmapValue)); + } else if (type.is_int8()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_int16()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_int32()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_int64()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_int128()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_float64()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_float64()) { + auto value = std::any_cast(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_decimal128()) { + auto value = std::any_cast>(cell); + column->insert_data(reinterpret_cast(&value), 0); + } else if (type.is_date_time()) { + static std::string date_time_format("%Y-%m-%d %H:%i:%s"); + auto datetime_str = std::any_cast(cell); + VecDateTimeValue v; + v.from_date_format_str(date_time_format.c_str(), date_time_format.size(), + datetime_str.c_str(), datetime_str.size()); + v.to_datetime(); + column->insert_data(reinterpret_cast(&v), 0); + } else if (type.is_date()) { + static std::string date_time_format("%Y-%m-%d"); + auto datetime_str = std::any_cast(cell); + VecDateTimeValue v; + v.from_date_format_str(date_time_format.c_str(), date_time_format.size(), + datetime_str.c_str(), datetime_str.size()); + v.cast_to_date(); + column->insert_data(reinterpret_cast(&v), 0); + } else if (type.is_array()) { + auto v = std::any_cast(cell); + column->insert(v); + } else { + LOG(WARNING) << "dataset not supported for TypeIndex:" << (int)type.idx; + return false; + } + return true; +} + +Block* create_block_from_inputset(const InputTypeSet& input_types, const InputDataSet& input_set) { + // 1.0 create data type + ut_type::UTDataTypeDescs descs; + if (!parse_ut_data_type(input_types, descs)) { + return nullptr; + } + + // 1.1 insert data and create block + auto row_size = input_set.size(); + std::unique_ptr block(new Block()); + for (size_t i = 0; i < descs.size(); ++i) { + auto& desc = descs[i]; + auto column = desc.data_type->create_column(); + column->reserve(row_size); + + auto type_ptr = desc.data_type->is_nullable() + ? ((DataTypeNullable*)(desc.data_type.get()))->get_nested_type() + : desc.data_type; + WhichDataType type(type_ptr); + + for (int j = 0; j < row_size; j++) { + if (!insert_cell(column, type_ptr, input_set[j][i])) { + return nullptr; + } + } + + if (desc.is_const) { + column = ColumnConst::create(std::move(column), row_size); + } + block->insert({std::move(column), desc.data_type, desc.col_name}); + } + return block.release(); +} + +Block* process_table_function(TableFunction* fn, Block* input_block, + const InputTypeSet& output_types) { + // pasrse output data types + ut_type::UTDataTypeDescs descs; + if (!parse_ut_data_type(output_types, descs)) { + return nullptr; + } + if (descs.size() != 1) { + LOG(WARNING) << "Now table function test only support return one column"; + return nullptr; + } + + // process table function init + if (fn->process_init(input_block) != Status::OK()) { + LOG(WARNING) << "TableFunction process_init failed"; + return nullptr; + } + + // prepare output column + vectorized::MutableColumnPtr column = descs[0].data_type->create_column(); + + // process table function for all rows + for (size_t row = 0; row < input_block->rows(); ++row) { + if (fn->process_row(row) != Status::OK()) { + LOG(WARNING) << "TableFunction process_row failed"; + return nullptr; + } + + // consider outer + if (!fn->is_outer() && fn->current_empty()) { + continue; + } + + bool tmp_eos = false; + do { + void* cell = nullptr; + int64_t cell_len = 0; + if (fn->get_value(&cell) != Status::OK() || + fn->get_value_length(&cell_len) != Status::OK()) { + LOG(WARNING) << "TableFunction get_value or get_value_length failed"; + return nullptr; + } + + // copy data from input block + if (cell == nullptr) { + column->insert_default(); + } else { + column->insert_data(reinterpret_cast(cell), cell_len); + } + + fn->forward(&tmp_eos); + } while (!tmp_eos); + } + + std::unique_ptr output_block(new Block()); + output_block->insert({std::move(column), descs[0].data_type, descs[0].col_name}); + return output_block.release(); +} + +void check_vec_table_function(TableFunction* fn, const InputTypeSet& input_types, + const InputDataSet& input_set, const InputTypeSet& output_types, + const InputDataSet& output_set) { + std::unique_ptr input_block(create_block_from_inputset(input_types, input_set)); + EXPECT_TRUE(input_block != nullptr); + + std::unique_ptr expect_output_block( + create_block_from_inputset(output_types, output_set)); + EXPECT_TRUE(expect_output_block != nullptr); + + std::unique_ptr real_output_block( + process_table_function(fn, input_block.get(), output_types)); + EXPECT_TRUE(real_output_block != nullptr); + + // compare real_output_block with expect_output_block + EXPECT_EQ(expect_output_block->columns(), real_output_block->columns()); + EXPECT_EQ(expect_output_block->rows(), real_output_block->rows()); + for (size_t col = 0; col < expect_output_block->columns(); ++col) { + auto left_col = expect_output_block->get_by_position(col).column; + auto right_col = real_output_block->get_by_position(col).column; + for (size_t row = 0; row < expect_output_block->rows(); ++row) { + EXPECT_EQ(left_col->compare_at(row, row, *right_col, 0), 0); + } + } +} + +} // namespace doris::vectorized diff --git a/be/test/vec/function/function_test_util.h b/be/test/vec/function/function_test_util.h index 16b0aac4be..76457131e5 100644 --- a/be/test/vec/function/function_test_util.h +++ b/be/test/vec/function/function_test_util.h @@ -42,16 +42,7 @@ using InputDataSet = std::vector>; // without result using DataSet = std::vector, std::any>>; using InputTypeSet = std::vector; -int64_t str_to_data_time(std::string datetime_str, bool data_time = true) { - VecDateTimeValue v; - v.from_date_str(datetime_str.c_str(), datetime_str.size()); - if (data_time) { //bool data_time only to simplifly means data_time or data to cast, just use in time-functions uint test - v.to_datetime(); - } else { - v.cast_to_date(); - } - return binary_cast(v); -} +int64_t str_to_data_time(std::string datetime_str, bool data_time = true); namespace ut_type { using TINYINT = int8_t; @@ -82,285 +73,19 @@ using UTDataTypeDescs = std::vector; } // namespace ut_type -size_t type_index_to_data_type(const InputTypeSet& input_types, size_t index, - doris_udf::FunctionContext::TypeDesc& desc, DataTypePtr& type) { - if (index < 0 || index >= input_types.size()) { - return -1; - } +size_t type_index_to_data_type(const std::vector& input_types, size_t index, + doris_udf::FunctionContext::TypeDesc& desc, DataTypePtr& type); +bool parse_ut_data_type(const std::vector& input_types, ut_type::UTDataTypeDescs& descs); - TypeIndex tp; - if (input_types[index].type() == typeid(Consted)) { - tp = std::any_cast(input_types[index]).tp; - } else { - tp = std::any_cast(input_types[index]); - } +bool insert_cell(MutableColumnPtr& column, DataTypePtr type_ptr, const std::any& cell); - switch (tp) { - case TypeIndex::String: - desc.type = doris_udf::FunctionContext::TYPE_STRING; - type = std::make_shared(); - return 1; - case TypeIndex::BitMap: - desc.type = doris_udf::FunctionContext::TYPE_OBJECT; - type = std::make_shared(); - return 1; - case TypeIndex::Int8: - desc.type = doris_udf::FunctionContext::TYPE_TINYINT; - type = std::make_shared(); - return 1; - case TypeIndex::Int16: - desc.type = doris_udf::FunctionContext::TYPE_SMALLINT; - type = std::make_shared(); - return 1; - case TypeIndex::Int32: - desc.type = doris_udf::FunctionContext::TYPE_INT; - type = std::make_shared(); - return 1; - case TypeIndex::Int64: - desc.type = doris_udf::FunctionContext::TYPE_BIGINT; - type = std::make_shared(); - return 1; - case TypeIndex::Int128: - desc.type = doris_udf::FunctionContext::TYPE_LARGEINT; - type = std::make_shared(); - return 1; - case TypeIndex::Float64: - desc.type = doris_udf::FunctionContext::TYPE_DOUBLE; - type = std::make_shared(); - return 1; - case TypeIndex::Decimal128: - desc.type = doris_udf::FunctionContext::TYPE_DECIMALV2; - type = std::make_shared>(); - return 1; - case TypeIndex::DateTime: - desc.type = doris_udf::FunctionContext::TYPE_DATETIME; - type = std::make_shared(); - return 1; - case TypeIndex::Date: - desc.type = doris_udf::FunctionContext::TYPE_DATE; - type = std::make_shared(); - return 1; - case TypeIndex::Array: { - desc.type = doris_udf::FunctionContext::TYPE_ARRAY; - doris_udf::FunctionContext::TypeDesc sub_desc; - DataTypePtr sub_type = nullptr; - size_t ret = type_index_to_data_type(input_types, index + 1, sub_desc, sub_type); - if (ret <= 0) { - return ret; - } - desc.children.push_back(doris_udf::FunctionContext::TypeDesc()); - type = std::make_shared(std::move(sub_type)); - return ret + 1; - } - default: - LOG(WARNING) << "not supported TypeIndex:" << (int)tp; - return 0; - } -} - -bool parse_ut_data_type(const InputTypeSet& input_types, ut_type::UTDataTypeDescs& descs) { - descs.clear(); - descs.reserve(input_types.size()); - for (size_t i = 0; i < input_types.size();) { - ut_type::UTDataTypeDesc desc; - if (input_types[i].type() == typeid(Consted)) { - desc.is_const = true; - } - size_t res = type_index_to_data_type(input_types, i, desc.type_desc, desc.data_type); - if (res <= 0) { - return false; - } - if (desc.is_nullable) { - desc.data_type = make_nullable(std::move(desc.data_type)); - } - desc.col_name = "k" + std::to_string(i); - descs.emplace_back(desc); - i += res; - } - return true; -} - -bool insert_cell(MutableColumnPtr& column, DataTypePtr type_ptr, const std::any& cell) { - if (cell.type() == typeid(Null)) { - column->insert_data(nullptr, 0); - return true; - } - - WhichDataType type(type_ptr); - if (type.is_string()) { - auto str = std::any_cast(cell); - column->insert_data(str.c_str(), str.size()); - } else if (type.idx == TypeIndex::BitMap) { - BitmapValue* bitmap = std::any_cast(cell); - column->insert_data((char*)bitmap, sizeof(BitmapValue)); - } else if (type.is_int8()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_int16()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_int32()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_int64()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_int128()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_float64()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_float64()) { - auto value = std::any_cast(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_decimal128()) { - auto value = std::any_cast>(cell); - column->insert_data(reinterpret_cast(&value), 0); - } else if (type.is_date_time()) { - static std::string date_time_format("%Y-%m-%d %H:%i:%s"); - auto datetime_str = std::any_cast(cell); - VecDateTimeValue v; - v.from_date_format_str(date_time_format.c_str(), date_time_format.size(), - datetime_str.c_str(), datetime_str.size()); - v.to_datetime(); - column->insert_data(reinterpret_cast(&v), 0); - } else if (type.is_date()) { - static std::string date_time_format("%Y-%m-%d"); - auto datetime_str = std::any_cast(cell); - VecDateTimeValue v; - v.from_date_format_str(date_time_format.c_str(), date_time_format.size(), - datetime_str.c_str(), datetime_str.size()); - v.cast_to_date(); - column->insert_data(reinterpret_cast(&v), 0); - } else if (type.is_array()) { - auto v = std::any_cast(cell); - column->insert(v); - } else { - LOG(WARNING) << "dataset not supported for TypeIndex:" << (int)type.idx; - return false; - } - return true; -} - -Block* create_block_from_inputset(const InputTypeSet& input_types, const InputDataSet& input_set) { - // 1.0 create data type - ut_type::UTDataTypeDescs descs; - if (!parse_ut_data_type(input_types, descs)) { - return nullptr; - } - - // 1.1 insert data and create block - auto row_size = input_set.size(); - std::unique_ptr block(new Block()); - for (size_t i = 0; i < descs.size(); ++i) { - auto& desc = descs[i]; - auto column = desc.data_type->create_column(); - column->reserve(row_size); - - auto type_ptr = desc.data_type->is_nullable() - ? ((DataTypeNullable*)(desc.data_type.get()))->get_nested_type() - : desc.data_type; - WhichDataType type(type_ptr); - - for (int j = 0; j < row_size; j++) { - if (!insert_cell(column, type_ptr, input_set[j][i])) { - return nullptr; - } - } - - if (desc.is_const) { - column = ColumnConst::create(std::move(column), row_size); - } - block->insert({std::move(column), desc.data_type, desc.col_name}); - } - return block.release(); -} +Block* create_block_from_inputset(const InputTypeSet& input_types, const InputDataSet& input_set); Block* process_table_function(TableFunction* fn, Block* input_block, - const InputTypeSet& output_types) { - // pasrse output data types - ut_type::UTDataTypeDescs descs; - if (!parse_ut_data_type(output_types, descs)) { - return nullptr; - } - if (descs.size() != 1) { - LOG(WARNING) << "Now table function test only support return one column"; - return nullptr; - } - - // process table function init - if (fn->process_init(input_block) != Status::OK()) { - LOG(WARNING) << "TableFunction process_init failed"; - return nullptr; - } - - // prepare output column - vectorized::MutableColumnPtr column = descs[0].data_type->create_column(); - - // process table function for all rows - for (size_t row = 0; row < input_block->rows(); ++row) { - if (fn->process_row(row) != Status::OK()) { - LOG(WARNING) << "TableFunction process_row failed"; - return nullptr; - } - - // consider outer - if (!fn->is_outer() && fn->current_empty()) { - continue; - } - - bool tmp_eos = false; - do { - void* cell = nullptr; - int64_t cell_len = 0; - if (fn->get_value(&cell) != Status::OK() || - fn->get_value_length(&cell_len) != Status::OK()) { - LOG(WARNING) << "TableFunction get_value or get_value_length failed"; - return nullptr; - } - - // copy data from input block - if (cell == nullptr) { - column->insert_default(); - } else { - column->insert_data(reinterpret_cast(cell), cell_len); - } - - fn->forward(&tmp_eos); - } while (!tmp_eos); - } - - std::unique_ptr output_block(new Block()); - output_block->insert({std::move(column), descs[0].data_type, descs[0].col_name}); - return output_block.release(); -} - + const InputTypeSet& output_types); void check_vec_table_function(TableFunction* fn, const InputTypeSet& input_types, const InputDataSet& input_set, const InputTypeSet& output_types, - const InputDataSet& output_set) { - std::unique_ptr input_block(create_block_from_inputset(input_types, input_set)); - ASSERT_TRUE(input_block != nullptr); - - std::unique_ptr expect_output_block( - create_block_from_inputset(output_types, output_set)); - ASSERT_TRUE(expect_output_block != nullptr); - - std::unique_ptr real_output_block( - process_table_function(fn, input_block.get(), output_types)); - ASSERT_TRUE(real_output_block != nullptr); - - // compare real_output_block with expect_output_block - ASSERT_EQ(expect_output_block->columns(), real_output_block->columns()); - ASSERT_EQ(expect_output_block->rows(), real_output_block->rows()); - for (size_t col = 0; col < expect_output_block->columns(); ++col) { - auto left_col = expect_output_block->get_by_position(col).column; - auto right_col = real_output_block->get_by_position(col).column; - for (size_t row = 0; row < expect_output_block->rows(); ++row) { - ASSERT_EQ(left_col->compare_at(row, row, *right_col, 0), 0); - } - } -} + const InputDataSet& output_set); // Null values are represented by Null() // The type of the constant column is represented as follows: Consted {TypeIndex::String} @@ -370,7 +95,7 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type const DataSet& data_set) { // 1.0 create data type ut_type::UTDataTypeDescs descs; - ASSERT_TRUE(parse_ut_data_type(input_types, descs)); + EXPECT_TRUE(parse_ut_data_type(input_types, descs)); // 1.1 insert data and create block auto row_size = data_set.size(); @@ -383,9 +108,8 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type auto type_ptr = desc.data_type->is_nullable() ? ((DataTypeNullable*)(desc.data_type.get()))->get_nested_type() : desc.data_type; - for (int j = 0; j < row_size; j++) { - ASSERT_TRUE(insert_cell(column, type_ptr, data_set[j].first[i])); + EXPECT_TRUE(insert_cell(column, type_ptr, data_set[j].first[i])); } if (desc.is_const) { @@ -417,7 +141,7 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type : std::make_shared(); auto func = SimpleFunctionFactory::instance().get_function( func_name, block.get_columns_with_type_and_name(), return_type); - ASSERT_TRUE(func != nullptr); + EXPECT_TRUE(func != nullptr); doris_udf::FunctionContext::TypeDesc fn_ctx_return; if (std::is_same_v) { @@ -448,7 +172,7 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type // 3. check the result of function ColumnPtr column = block.get_columns()[result]; - ASSERT_TRUE(column != nullptr); + EXPECT_TRUE(column != nullptr); for (int i = 0; i < row_size; ++i) { auto check_column_data = [&]() { @@ -459,12 +183,12 @@ void check_function(const std::string& func_name, const InputTypeSet& input_type const auto& expect_data = std::any_cast(data_set[i].second); - ASSERT_EQ(column_data, expect_data); + EXPECT_EQ(column_data, expect_data); }; if constexpr (nullable) { bool is_null = data_set[i].second.type() == typeid(Null); - ASSERT_EQ(column->is_null_at(i), is_null); + EXPECT_EQ(column->is_null_at(i), is_null); if (!is_null) check_column_data(); } else { check_column_data(); diff --git a/be/test/vec/function/function_time_test.cpp b/be/test/vec/function/function_time_test.cpp index 7e45295c4d..9d2f935384 100644 --- a/be/test/vec/function/function_time_test.cpp +++ b/be/test/vec/function/function_time_test.cpp @@ -31,7 +31,7 @@ namespace doris::vectorized { using namespace ut_type; -TEST(TimestampFunctionsTest, day_of_week_test) { +TEST(VTimestampFunctionsTest, day_of_week_test) { std::string func_name = "dayofweek"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -43,7 +43,7 @@ TEST(TimestampFunctionsTest, day_of_week_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, day_of_month_test) { +TEST(VTimestampFunctionsTest, day_of_month_test) { std::string func_name = "dayofmonth"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -55,7 +55,7 @@ TEST(TimestampFunctionsTest, day_of_month_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, day_of_year_test) { +TEST(VTimestampFunctionsTest, day_of_year_test) { std::string func_name = "dayofyear"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -67,7 +67,7 @@ TEST(TimestampFunctionsTest, day_of_year_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, week_of_year_test) { +TEST(VTimestampFunctionsTest, week_of_year_test) { std::string func_name = "weekofyear"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -79,7 +79,7 @@ TEST(TimestampFunctionsTest, week_of_year_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, year_test) { +TEST(VTimestampFunctionsTest, year_test) { std::string func_name = "year"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -91,7 +91,7 @@ TEST(TimestampFunctionsTest, year_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, quarter_test) { +TEST(VTimestampFunctionsTest, quarter_test) { std::string func_name = "quarter"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -104,7 +104,7 @@ TEST(TimestampFunctionsTest, quarter_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, month_test) { +TEST(VTimestampFunctionsTest, month_test) { std::string func_name = "month"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -117,7 +117,7 @@ TEST(TimestampFunctionsTest, month_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, day_test) { +TEST(VTimestampFunctionsTest, day_test) { std::string func_name = "day"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -130,7 +130,7 @@ TEST(TimestampFunctionsTest, day_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, hour_test) { +TEST(VTimestampFunctionsTest, hour_test) { std::string func_name = "hour"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -143,7 +143,7 @@ TEST(TimestampFunctionsTest, hour_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, minute_test) { +TEST(VTimestampFunctionsTest, minute_test) { std::string func_name = "minute"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -156,7 +156,7 @@ TEST(TimestampFunctionsTest, minute_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, second_test) { +TEST(VTimestampFunctionsTest, second_test) { std::string func_name = "second"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -169,7 +169,7 @@ TEST(TimestampFunctionsTest, second_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, from_unix_test) { +TEST(VTimestampFunctionsTest, from_unix_test) { std::string func_name = "from_unixtime"; InputTypeSet input_types = {TypeIndex::Int32}; @@ -179,7 +179,7 @@ TEST(TimestampFunctionsTest, from_unix_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, timediff_test) { +TEST(VTimestampFunctionsTest, timediff_test) { std::string func_name = "timediff"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::DateTime}; @@ -193,7 +193,7 @@ TEST(TimestampFunctionsTest, timediff_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, date_format_test) { +TEST(VTimestampFunctionsTest, date_format_test) { std::string func_name = "date_format"; InputTypeSet input_types = {TypeIndex::DateTime, Consted {TypeIndex::String}}; @@ -242,7 +242,7 @@ TEST(TimestampFunctionsTest, date_format_test) { check_function(func_name, input_types, data_set); } } -TEST(TimestampFunctionsTest, years_add_test) { +TEST(VTimestampFunctionsTest, years_add_test) { std::string func_name = "years_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -257,7 +257,7 @@ TEST(TimestampFunctionsTest, years_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, years_sub_test) { +TEST(VTimestampFunctionsTest, years_sub_test) { std::string func_name = "years_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -272,7 +272,7 @@ TEST(TimestampFunctionsTest, years_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, months_add_test) { +TEST(VTimestampFunctionsTest, months_add_test) { std::string func_name = "months_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -287,7 +287,7 @@ TEST(TimestampFunctionsTest, months_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, months_sub_test) { +TEST(VTimestampFunctionsTest, months_sub_test) { std::string func_name = "months_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -302,7 +302,7 @@ TEST(TimestampFunctionsTest, months_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, days_add_test) { +TEST(VTimestampFunctionsTest, days_add_test) { std::string func_name = "days_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -317,7 +317,7 @@ TEST(TimestampFunctionsTest, days_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, days_sub_test) { +TEST(VTimestampFunctionsTest, days_sub_test) { std::string func_name = "days_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -332,7 +332,7 @@ TEST(TimestampFunctionsTest, days_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, hours_add_test) { +TEST(VTimestampFunctionsTest, hours_add_test) { std::string func_name = "hours_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -347,7 +347,7 @@ TEST(TimestampFunctionsTest, hours_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, hours_sub_test) { +TEST(VTimestampFunctionsTest, hours_sub_test) { std::string func_name = "hours_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -362,7 +362,7 @@ TEST(TimestampFunctionsTest, hours_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, minutes_add_test) { +TEST(VTimestampFunctionsTest, minutes_add_test) { std::string func_name = "minutes_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -377,7 +377,7 @@ TEST(TimestampFunctionsTest, minutes_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, minutes_sub_test) { +TEST(VTimestampFunctionsTest, minutes_sub_test) { std::string func_name = "minutes_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -392,7 +392,7 @@ TEST(TimestampFunctionsTest, minutes_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, seconds_add_test) { +TEST(VTimestampFunctionsTest, seconds_add_test) { std::string func_name = "seconds_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -407,7 +407,7 @@ TEST(TimestampFunctionsTest, seconds_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, seconds_sub_test) { +TEST(VTimestampFunctionsTest, seconds_sub_test) { std::string func_name = "seconds_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -422,7 +422,7 @@ TEST(TimestampFunctionsTest, seconds_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, weeks_add_test) { +TEST(VTimestampFunctionsTest, weeks_add_test) { std::string func_name = "weeks_add"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -437,7 +437,7 @@ TEST(TimestampFunctionsTest, weeks_add_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, weeks_sub_test) { +TEST(VTimestampFunctionsTest, weeks_sub_test) { std::string func_name = "weeks_sub"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::Int32}; @@ -452,7 +452,7 @@ TEST(TimestampFunctionsTest, weeks_sub_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, to_days_test) { +TEST(VTimestampFunctionsTest, to_days_test) { std::string func_name = "to_days"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -465,7 +465,7 @@ TEST(TimestampFunctionsTest, to_days_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, date_test) { +TEST(VTimestampFunctionsTest, date_test) { std::string func_name = "date"; InputTypeSet input_types = {TypeIndex::DateTime}; @@ -479,49 +479,45 @@ TEST(TimestampFunctionsTest, date_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, week_test) { +TEST(VTimestampFunctionsTest, week_test) { std::string func_name = "week"; InputTypeSet input_types = {TypeIndex::DateTime}; - DataSet data_set = { - {{std::string("1989-03-21 06:00:00")}, 12}, - {{std::string("")}, Null()}, - {{std::string("9999-12-12 00:00:00")}, 50}}; + DataSet data_set = {{{std::string("1989-03-21 06:00:00")}, 12}, + {{std::string("")}, Null()}, + {{std::string("9999-12-12 00:00:00")}, 50}}; check_function(func_name, input_types, data_set); InputTypeSet new_input_types = {TypeIndex::Date}; - DataSet new_data_set = { - {{std::string("1989-03-21")}, 12}, - {{std::string("")}, Null()}, - {{std::string("9999-12-12")}, 50}}; + DataSet new_data_set = {{{std::string("1989-03-21")}, 12}, + {{std::string("")}, Null()}, + {{std::string("9999-12-12")}, 50}}; check_function(func_name, new_input_types, new_data_set); } -TEST(TimestampFunctionsTest, yearweek_test) { +TEST(VTimestampFunctionsTest, yearweek_test) { std::string func_name = "yearweek"; InputTypeSet input_types = {TypeIndex::DateTime}; - DataSet data_set = { - {{std::string("1989-03-21 06:00:00")}, 198912}, - {{std::string("")}, Null()}, - {{std::string("9999-12-12 00:00:00")}, 999950}}; + DataSet data_set = {{{std::string("1989-03-21 06:00:00")}, 198912}, + {{std::string("")}, Null()}, + {{std::string("9999-12-12 00:00:00")}, 999950}}; check_function(func_name, input_types, data_set); InputTypeSet new_input_types = {TypeIndex::Date}; - DataSet new_data_set = { - {{std::string("1989-03-21")}, 198912}, - {{std::string("")}, Null()}, - {{std::string("9999-12-12")}, 999950}}; + DataSet new_data_set = {{{std::string("1989-03-21")}, 198912}, + {{std::string("")}, Null()}, + {{std::string("9999-12-12")}, 999950}}; check_function(func_name, new_input_types, new_data_set); } -TEST(TimestampFunctionsTest, makedate_test) { +TEST(VTimestampFunctionsTest, makedate_test) { std::string func_name = "makedate"; InputTypeSet input_types = {TypeIndex::Int32, TypeIndex::Int32}; @@ -537,7 +533,7 @@ TEST(TimestampFunctionsTest, makedate_test) { check_function(func_name, input_types, data_set); } -TEST(TimestampFunctionsTest, convert_tz_test) { +TEST(VTimestampFunctionsTest, convert_tz_test) { std::string func_name = "convert_tz"; InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::String, TypeIndex::String}; @@ -552,8 +548,3 @@ TEST(TimestampFunctionsTest, convert_tz_test) { check_function(func_name, input_types, data_set); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/function/table_function_test.cpp b/be/test/vec/function/table_function_test.cpp index 8404892480..f525138d65 100644 --- a/be/test/vec/function/table_function_test.cpp +++ b/be/test/vec/function/table_function_test.cpp @@ -167,8 +167,3 @@ TEST_F(TableFunctionTest, vexplode_split) { } } // namespace doris::vectorized - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/be/test/vec/runtime/CMakeLists.txt b/be/test/vec/runtime/CMakeLists.txt deleted file mode 100644 index f01816299d..0000000000 --- a/be/test/vec/runtime/CMakeLists.txt +++ /dev/null @@ -1,22 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. - -# where to put generated libraries -set(EXECUTABLE_OUTPUT_PATH "${BUILD_DIR}/test/vec/runtime") - -ADD_BE_TEST(vdata_stream_test) - diff --git a/be/test/vec/runtime/vdata_stream_test.cpp b/be/test/vec/runtime/vdata_stream_test.cpp index 7559919db0..2c7d9d5521 100644 --- a/be/test/vec/runtime/vdata_stream_test.cpp +++ b/be/test/vec/runtime/vdata_stream_test.cpp @@ -15,13 +15,13 @@ // specific language governing permissions and limitations // under the License. -#include "service/brpc.h" #include "common/object_pool.h" #include "gen_cpp/internal_service.pb.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/service.h" #include "gtest/gtest.h" #include "runtime/exec_env.h" +#include "service/brpc.h" #include "testutil/desc_tbl_builder.h" #include "util/proto_util.h" #include "vec/columns/columns_number.h" @@ -46,8 +46,8 @@ public: st = stream_mgr->transmit_block(request, &done); if (!st.ok()) { LOG(WARNING) << "transmit_block failed, message=" << st.get_error_msg() - << ", fragment_instance_id=" << print_id(request->finst_id()) - << ", node=" << request->node_id(); + << ", fragment_instance_id=" << print_id(request->finst_id()) + << ", node=" << request->node_id(); } } @@ -177,16 +177,10 @@ TEST_F(VDataStreamTest, BasicTest) { bool eos; recv->get_next(&block_2, &eos); - ASSERT_EQ(block_2.rows(), 1024); + EXPECT_EQ(block_2.rows(), 1024); Status exec_status; sender.close(&runtime_stat, exec_status); recv->close(); } } // namespace doris::vectorized - -int main(int argc, char** argv) { - doris::CpuInfo::init(); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/run-be-ut.sh b/run-be-ut.sh index 2b9d873527..ffda8e14af 100755 --- a/run-be-ut.sh +++ b/run-be-ut.sh @@ -30,48 +30,45 @@ # GTest result xml files will be in "be/ut_build_ASAN/gtest_output/" ##################################################################### -set -eo pipefail - ROOT=`dirname "$0"` ROOT=`cd "$ROOT"; pwd` export DORIS_HOME=${ROOT} -. ${DORIS_HOME}/env.sh - # Check args usage() { echo " Usage: $0 Optional options: - --clean clean and build ut - --run build and run all ut - --run xx build and run specified ut - -v build and run all vectorized ut - -j build parallel + --clean clean and build ut + --run build and run all ut + --run --filter=xx build and run specified ut + -v build and run all vectorized ut + -j build parallel + -h print this help message Eg. - $0 build ut - $0 --run build and run all ut - $0 --run test build and run "test" ut - $0 --clean clean and build ut - $0 --clean --run clean, build and run all ut + $0 build tests + $0 --run build and run all tests + $0 --run --filter=* also runs everything + $0 --run --filter=FooTest.* runs everything in test suite FooTest + $0 --run --filter=*Null*:*Constructor* runs any test whose full name contains either 'Null' or 'Constructor' + $0 --run --filter=-*DeathTest.* runs all non-death tests + $0 --run --filter=FooTest.*-FooTest.Bar runs everything in test suite FooTest except FooTest.Bar + $0 --run --filter=FooTest.*:BarTest.*-FooTest.Bar:BarTest.Foo runs everything in test suite FooTest except FooTest.Bar and everything in test suite BarTest except BarTest.Foo + $0 --clean clean and build tests + $0 --clean --run clean, build and run all tests " exit 1 } -OPTS=$(getopt \ - -n $0 \ - -o '' \ - -l 'run' \ - -l 'clean' \ - -o 'vj:' \ - -- "$@") - -if [ $? != 0 ] ; then - usage +OPTS=$(getopt -n $0 -o vhj:f: -l run,clean,filter: -- "$@") +if [ "$?" != "0" ]; then + usage fi +set -eo pipefail + eval set -- "$OPTS" PARALLEL=$[$(nproc)/5+1] @@ -83,15 +80,17 @@ fi CLEAN=0 RUN=0 VECTORIZED_ONLY=0 +FILTER="" if [ $# != 1 ] ; then while true; do case "$1" in --clean) CLEAN=1 ; shift ;; --run) RUN=1 ; shift ;; + -f | --filter) FILTER="--gtest_filter=$2"; shift 2;; -v) VECTORIZED_ONLY=1 ; shift ;; -j) PARALLEL=$2; shift 2 ;; --) shift ; break ;; - *) echo "Internal error" ; exit 1 ;; + *) usage ; exit 0 ;; esac done fi @@ -105,6 +104,8 @@ echo "Get params: " echo "Build Backend UT" +. ${DORIS_HOME}/env.sh + CMAKE_BUILD_DIR=${DORIS_HOME}/be/ut_build_${CMAKE_BUILD_TYPE} if [ ${CLEAN} -eq 1 ]; then rm ${CMAKE_BUILD_DIR} -rf @@ -119,15 +120,6 @@ if [[ -z ${GLIBC_COMPATIBILITY} ]]; then GLIBC_COMPATIBILITY=ON fi -# get specified ut file if set -RUN_FILE= -if [ $# == 1 ]; then - RUN_FILE=$1 - echo "=== Run test: $RUN_FILE ===" -else - # run all ut - echo "=== Running All tests ===" -fi MAKE_PROGRAM="$(which "${BUILD_SYSTEM}")" echo "-- Make program: ${MAKE_PROGRAM}" @@ -142,7 +134,7 @@ ${CMAKE_CMD} -G "${GENERATOR}" \ -DBUILD_META_TOOL=OFF \ -DWITH_MYSQL=OFF \ ${CMAKE_USE_CCACHE} ../ -${BUILD_SYSTEM} -j ${PARALLEL} $RUN_FILE +${BUILD_SYSTEM} -j ${PARALLEL} if [ ${RUN} -ne 1 ]; then echo "Finished" @@ -225,6 +217,7 @@ GTEST_OUTPUT_DIR=${CMAKE_BUILD_DIR}/gtest_output rm -rf ${GTEST_OUTPUT_DIR} && mkdir ${GTEST_OUTPUT_DIR} # prepare util test_data +mkdir -p ${DORIS_TEST_BINARY_DIR}/util if [ -d ${DORIS_TEST_BINARY_DIR}/util/test_data ]; then rm -rf ${DORIS_TEST_BINARY_DIR}/util/test_data fi @@ -242,15 +235,11 @@ if [ ${VECTORIZED_ONLY} -eq 1 ]; then echo "Run Vectorized ut only" export DORIS_TEST_BINARY_DIR=${DORIS_TEST_BINARY_DIR}/vec fi - -test_files=`find ${DORIS_TEST_BINARY_DIR} -type f -perm -111 -name "*test"` - -for test in ${test_files[@]} -do - file_name=${test##*/} - if [ -z $RUN_FILE ] || [ $file_name == $RUN_FILE ]; then - echo "=== Run $file_name ===" - $test --gtest_output=xml:${GTEST_OUTPUT_DIR}/${file_name}.xml - fi -done -echo "=== Finished. Gtest output: ${GTEST_OUTPUT_DIR}" +test=${DORIS_TEST_BINARY_DIR}doris_be_test +file_name=${test##*/} +if [ -f "$test" ]; then + $test --gtest_output=xml:${GTEST_OUTPUT_DIR}/${file_name}.xml --gtest_print_time=true "${FILTER}" + echo "=== Finished. Gtest output: ${GTEST_OUTPUT_DIR}" +else + echo "unit test file: $test does not exist." +fi