Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

gtestify test/core/gpr (#30196)

Browse Source 
* fix

* gtestify test/core/gpr

* Fix

* fix
pull/30295/head
Esun Kim 3 years ago committed by GitHub
parent 57de9d7353
commit 0f272f836d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 780 additions and 718 deletions
Split View
  1. 512
      CMakeLists.txt
  2. 152
      build_autogenerated.yaml
  3. 8
      test/core/gpr/BUILD
  4. 12
      test/core/gpr/alloc_test.cc
  5. 14
      test/core/gpr/cpu_test.cc
  6. 17
      test/core/gpr/env_test.cc
  7. 12
      test/core/gpr/murmur_hash_test.cc
  8. 20
      test/core/gpr/spinlock_test.cc
  9. 192
      test/core/gpr/string_test.cc
  10. 30
      test/core/gpr/sync_test.cc
  11. 145
      test/core/gpr/time_test.cc
  12. 384
      tools/run_tests/generated/tests.json

512
CMakeLists.txt generated
Unescape View File

@ -776,7 +776,6 @@ protobuf_generate_grpc_cpp_with_import_path_correction(
if(gRPC_BUILD_TESTS)
add_custom_target(buildtests_c)
add_dependencies(buildtests_c alloc_test)
add_dependencies(buildtests_c b64_test)
add_dependencies(buildtests_c bad_server_response_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
@ -791,12 +790,10 @@ if(gRPC_BUILD_TESTS)
add_dependencies(buildtests_c combiner_test)
endif()
add_dependencies(buildtests_c connection_refused_test)
add_dependencies(buildtests_c cpu_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_c dualstack_socket_test)
endif()
add_dependencies(buildtests_c endpoint_pair_test)
add_dependencies(buildtests_c env_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_c fd_conservation_posix_test)
endif()
@ -817,7 +814,6 @@ if(gRPC_BUILD_TESTS)
add_dependencies(buildtests_c load_file_test)
add_dependencies(buildtests_c minimal_stack_is_minimal_test)
add_dependencies(buildtests_c multiple_server_queues_test)
add_dependencies(buildtests_c murmur_hash_test)
add_dependencies(buildtests_c no_server_test)
add_dependencies(buildtests_c parser_test)
add_dependencies(buildtests_c percent_encoding_test)
@ -832,9 +828,6 @@ if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_c socket_utils_test)
endif()
add_dependencies(buildtests_c spinlock_test)
add_dependencies(buildtests_c string_test)
add_dependencies(buildtests_c sync_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_c tcp_client_posix_test)
endif()
@ -844,7 +837,6 @@ if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_c tcp_server_posix_test)
endif()
add_dependencies(buildtests_c test_core_gpr_time_test)
add_dependencies(buildtests_c test_core_iomgr_time_averaged_stats_test)
add_dependencies(buildtests_c test_core_iomgr_timer_heap_test)
add_dependencies(buildtests_c test_core_iomgr_timer_list_test)
@ -861,6 +853,7 @@ if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_cxx alarm_test)
endif()
add_dependencies(buildtests_cxx alloc_test)
add_dependencies(buildtests_cxx alpn_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_cxx alts_concurrent_connectivity_test)
@ -946,6 +939,7 @@ if(gRPC_BUILD_TESTS)
add_dependencies(buildtests_cxx context_test)
add_dependencies(buildtests_cxx core_configuration_test)
add_dependencies(buildtests_cxx cpp_impl_of_test)
add_dependencies(buildtests_cxx cpu_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_cxx crl_ssl_transport_security_test)
endif()
@ -959,6 +953,7 @@ if(gRPC_BUILD_TESTS)
add_dependencies(buildtests_cxx end2end_test)
add_dependencies(buildtests_cxx endpoint_binder_pool_test)
add_dependencies(buildtests_cxx endpoint_config_test)
add_dependencies(buildtests_cxx env_test)
add_dependencies(buildtests_cxx error_details_test)
add_dependencies(buildtests_cxx error_test)
add_dependencies(buildtests_cxx error_utils_test)
@ -1066,6 +1061,7 @@ if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_cxx mpscq_test)
endif()
add_dependencies(buildtests_cxx murmur_hash_test)
add_dependencies(buildtests_cxx nonblocking_test)
add_dependencies(buildtests_cxx num_external_connectivity_watchers_test)
add_dependencies(buildtests_cxx observable_test)
@ -1144,6 +1140,7 @@ if(gRPC_BUILD_TESTS)
add_dependencies(buildtests_cxx smoke_test)
add_dependencies(buildtests_cxx sockaddr_resolver_test)
add_dependencies(buildtests_cxx sockaddr_utils_test)
add_dependencies(buildtests_cxx spinlock_test)
add_dependencies(buildtests_cxx ssl_credentials_test)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
add_dependencies(buildtests_cxx ssl_transport_security_test)
@ -1165,12 +1162,15 @@ if(gRPC_BUILD_TESTS)
endif()
add_dependencies(buildtests_cxx streams_not_seen_test)
add_dependencies(buildtests_cxx string_ref_test)
add_dependencies(buildtests_cxx string_test)
add_dependencies(buildtests_cxx sync_test)
add_dependencies(buildtests_cxx system_roots_test)
add_dependencies(buildtests_cxx table_test)
add_dependencies(buildtests_cxx test_core_event_engine_iomgr_event_engine_time_averaged_stats_test)
add_dependencies(buildtests_cxx test_core_event_engine_iomgr_event_engine_timer_heap_test)
add_dependencies(buildtests_cxx test_core_event_engine_iomgr_event_engine_timer_list_test)
add_dependencies(buildtests_cxx test_core_event_engine_slice_buffer_test)
add_dependencies(buildtests_cxx test_core_gpr_time_test)
add_dependencies(buildtests_cxx test_core_gprpp_time_test)
add_dependencies(buildtests_cxx test_core_security_credentials_test)
add_dependencies(buildtests_cxx test_core_slice_slice_buffer_test)
@ -4284,33 +4284,6 @@ target_link_libraries(gen_hpack_tables
if(gRPC_BUILD_TESTS)
add_executable(alloc_test
test/core/gpr/alloc_test.cc
)
target_include_directories(alloc_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(alloc_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(b64_test
test/core/slice/b64_test.cc
)
@ -4534,33 +4507,6 @@ target_link_libraries(connection_refused_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(cpu_test
test/core/gpr/cpu_test.cc
)
target_include_directories(cpu_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(cpu_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
@ -4619,33 +4565,6 @@ target_link_libraries(endpoint_pair_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(env_test
test/core/gpr/env_test.cc
)
target_include_directories(env_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(env_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
@ -4993,33 +4912,6 @@ target_link_libraries(multiple_server_queues_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(murmur_hash_test
test/core/gpr/murmur_hash_test.cc
)
target_include_directories(murmur_hash_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(murmur_hash_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
@ -5252,87 +5144,6 @@ if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
endif()
endif()
if(gRPC_BUILD_TESTS)
add_executable(spinlock_test
test/core/gpr/spinlock_test.cc
)
target_include_directories(spinlock_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(spinlock_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(string_test
test/core/gpr/string_test.cc
)
target_include_directories(string_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(string_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(sync_test
test/core/gpr/sync_test.cc
)
target_include_directories(sync_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(sync_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
@ -5424,33 +5235,6 @@ endif()
endif()
if(gRPC_BUILD_TESTS)
add_executable(test_core_gpr_time_test
test/core/gpr/time_test.cc
)
target_include_directories(test_core_gpr_time_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
)
target_link_libraries(test_core_gpr_time_test
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(test_core_iomgr_time_averaged_stats_test
test/core/iomgr/time_averaged_stats_test.cc
)
@ -5800,6 +5584,41 @@ endif()
endif()
if(gRPC_BUILD_TESTS)
add_executable(alloc_test
test/core/gpr/alloc_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(alloc_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(alloc_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(alpn_test
test/core/transport/chttp2/alpn_test.cc
third_party/googletest/googletest/src/gtest-all.cc
@ -8807,6 +8626,41 @@ target_link_libraries(cpp_impl_of_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(cpu_test
test/core/gpr/cpu_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(cpu_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(cpu_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
@ -9314,6 +9168,41 @@ target_link_libraries(endpoint_config_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(env_test
test/core/gpr/env_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(env_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(env_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
@ -13210,6 +13099,41 @@ endif()
endif()
if(gRPC_BUILD_TESTS)
add_executable(murmur_hash_test
test/core/gpr/murmur_hash_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(murmur_hash_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(murmur_hash_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(nonblocking_test
${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/testing/echo.pb.cc
${_gRPC_PROTO_GENS_DIR}/src/proto/grpc/testing/echo.grpc.pb.cc
@ -16023,6 +15947,41 @@ target_link_libraries(sockaddr_utils_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(spinlock_test
test/core/gpr/spinlock_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(spinlock_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(spinlock_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
@ -16510,6 +16469,76 @@ target_link_libraries(string_ref_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(string_test
test/core/gpr/string_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(string_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(string_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(sync_test
test/core/gpr/sync_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(sync_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(sync_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)
@ -16894,6 +16923,41 @@ target_link_libraries(test_core_event_engine_slice_buffer_test
)
endif()
if(gRPC_BUILD_TESTS)
add_executable(test_core_gpr_time_test
test/core/gpr/time_test.cc
third_party/googletest/googletest/src/gtest-all.cc
third_party/googletest/googlemock/src/gmock-all.cc
)
target_include_directories(test_core_gpr_time_test
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${_gRPC_ADDRESS_SORTING_INCLUDE_DIR}
${_gRPC_RE2_INCLUDE_DIR}
${_gRPC_SSL_INCLUDE_DIR}
${_gRPC_UPB_GENERATED_DIR}
${_gRPC_UPB_GRPC_GENERATED_DIR}
${_gRPC_UPB_INCLUDE_DIR}
${_gRPC_XXHASH_INCLUDE_DIR}
${_gRPC_ZLIB_INCLUDE_DIR}
third_party/googletest/googletest/include
third_party/googletest/googletest
third_party/googletest/googlemock/include
third_party/googletest/googlemock
${_gRPC_PROTO_GENS_DIR}
)
target_link_libraries(test_core_gpr_time_test
${_gRPC_PROTOBUF_LIBRARIES}
${_gRPC_ALLTARGETS_LIBRARIES}
grpc_test_util
)
endif()
if(gRPC_BUILD_TESTS)

152
build_autogenerated.yaml generated
Unescape View File

@ -3194,15 +3194,6 @@ libs:
deps:
- grpc++
targets:
- name: alloc_test
build: test
language: c
headers: []
src:
- test/core/gpr/alloc_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: b64_test
build: test
language: c
@ -3289,15 +3280,6 @@ targets:
- test/core/end2end/cq_verifier.cc
deps:
- grpc_test_util
- name: cpu_test
build: test
language: c
headers: []
src:
- test/core/gpr/cpu_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: dualstack_socket_test
build: test
language: c
@ -3322,15 +3304,6 @@ targets:
- test/core/iomgr/endpoint_tests.cc
deps:
- grpc_test_util
- name: env_test
build: test
language: c
headers: []
src:
- test/core/gpr/env_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: fd_conservation_posix_test
build: test
language: c
@ -3467,15 +3440,6 @@ targets:
- test/core/end2end/multiple_server_queues_test.cc
deps:
- grpc_test_util
- name: murmur_hash_test
build: test
language: c
headers: []
src:
- test/core/gpr/murmur_hash_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: no_server_test
build: test
language: c
@ -3578,33 +3542,6 @@ targets:
- linux
- posix
- mac
- name: spinlock_test
build: test
language: c
headers: []
src:
- test/core/gpr/spinlock_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: string_test
build: test
language: c
headers: []
src:
- test/core/gpr/string_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: sync_test
build: test
language: c
headers: []
src:
- test/core/gpr/sync_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: tcp_client_posix_test
build: test
language: c
@ -3642,15 +3579,6 @@ targets:
- linux
- posix
- mac
- name: test_core_gpr_time_test
build: test
language: c
headers: []
src:
- test/core/gpr/time_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: test_core_iomgr_time_averaged_stats_test
build: test
language: c
@ -3861,6 +3789,16 @@ targets:
- linux
- posix
- mac
- name: alloc_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/alloc_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: alpn_test
gtest: true
build: test
@ -4998,6 +4936,16 @@ targets:
- test/core/gprpp/cpp_impl_of_test.cc
deps: []
uses_polling: false
- name: cpu_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/cpu_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: crl_ssl_transport_security_test
gtest: true
build: test
@ -5222,6 +5170,16 @@ targets:
deps:
- grpc_test_util
uses_polling: false
- name: env_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/env_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: error_details_test
gtest: true
build: test
@ -6876,6 +6834,16 @@ targets:
- posix
- mac
uses_polling: false
- name: murmur_hash_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/murmur_hash_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: nonblocking_test
gtest: true
build: test
@ -8087,6 +8055,16 @@ targets:
- test/core/address_utils/sockaddr_utils_test.cc
deps:
- grpc_test_util
- name: spinlock_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/spinlock_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: ssl_credentials_test
gtest: true
build: test
@ -8239,6 +8217,26 @@ targets:
- grpc++
- grpc_test_util
uses_polling: false
- name: string_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/string_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: sync_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/sync_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: system_roots_test
gtest: true
build: test
@ -8565,6 +8563,16 @@ targets:
- test/core/event_engine/slice_buffer_test.cc
deps:
- grpc_test_util
- name: test_core_gpr_time_test
gtest: true
build: test
language: c++
headers: []
src:
- test/core/gpr/time_test.cc
deps:
- grpc_test_util
uses_polling: false
- name: test_core_gprpp_time_test
gtest: true
build: test

8
test/core/gpr/BUILD
Unescape View File

@ -21,6 +21,7 @@ grpc_package(name = "test/core/gpr")
grpc_cc_test(
name = "alloc_test",
srcs = ["alloc_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -33,6 +34,7 @@ grpc_cc_test(
grpc_cc_test(
name = "cpu_test",
srcs = ["cpu_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -45,6 +47,7 @@ grpc_cc_test(
grpc_cc_test(
name = "env_test",
srcs = ["env_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -72,6 +75,7 @@ grpc_cc_test(
grpc_cc_test(
name = "murmur_hash_test",
srcs = ["murmur_hash_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -84,6 +88,7 @@ grpc_cc_test(
grpc_cc_test(
name = "spinlock_test",
srcs = ["spinlock_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -96,6 +101,7 @@ grpc_cc_test(
grpc_cc_test(
name = "string_test",
srcs = ["string_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -108,6 +114,7 @@ grpc_cc_test(
grpc_cc_test(
name = "sync_test",
srcs = ["sync_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,
@ -120,6 +127,7 @@ grpc_cc_test(
grpc_cc_test(
name = "time_test",
srcs = ["time_test.cc"],
external_deps = ["gtest"],
language = "C++",
uses_event_engine = False,
uses_polling = False,

12
test/core/gpr/alloc_test.cc
Unescape View File

@ -18,16 +18,18 @@
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "test/core/util/test_config.h"
static void test_malloc_aligned() {
TEST(AllocTest, MallocAligned) {
for (size_t size = 1; size <= 256; ++size) {
void* ptr = gpr_malloc_aligned(size, 16);
GPR_ASSERT(ptr != nullptr);
GPR_ASSERT(((intptr_t)ptr & 0xf) == 0);
ASSERT_NE(ptr, nullptr);
ASSERT_EQ(((intptr_t)ptr & 0xf), 0);
memset(ptr, 0, size);
gpr_free_aligned(ptr);
}
@ -35,6 +37,6 @@ static void test_malloc_aligned() {
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
test_malloc_aligned();
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

14
test/core/gpr/cpu_test.cc
Unescape View File

@ -24,6 +24,8 @@
#include <stdio.h>
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/cpu.h>
#include <grpc/support/log.h>
@ -77,7 +79,7 @@ static void worker_thread(void* arg) {
r = (r * 17) & ((r - i) | (r * i));
}
cpu = gpr_cpu_current_cpu();
GPR_ASSERT(cpu < ct->ncores);
ASSERT_LT(cpu, ct->ncores);
gpr_mu_lock(&ct->mu);
ct->used[cpu] = 1;
for (j = 0; j < ct->ncores; j++) {
@ -103,7 +105,7 @@ static void cpu_test(void) {
int cores_seen = 0;
struct cpu_test ct;
ct.ncores = gpr_cpu_num_cores();
GPR_ASSERT(ct.ncores > 0);
ASSERT_GT(ct.ncores, 0);
ct.nthreads = static_cast<int>(ct.ncores) * 3;
ct.used = static_cast<int*>(gpr_malloc(ct.ncores * sizeof(int)));
memset(ct.used, 0, ct.ncores * sizeof(int));
@ -144,8 +146,10 @@ static void cpu_test(void) {
gpr_free(ct.used);
}
int main(int argc, char* argv[]) {
TEST(CpuTest, MainTest) { cpu_test(); }
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
cpu_test();
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

17
test/core/gpr/env_test.cc
Unescape View File

@ -21,6 +21,8 @@
#include <stdio.h>
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
@ -29,7 +31,7 @@
#define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
static void test_setenv_getenv(void) {
TEST(EnvTest, SetenvGetenv) {
const char* name = "FOO";
const char* value = "BAR";
char* retrieved_value;
@ -38,12 +40,12 @@ static void test_setenv_getenv(void) {
gpr_setenv(name, value);
retrieved_value = gpr_getenv(name);
GPR_ASSERT(retrieved_value != nullptr);
GPR_ASSERT(strcmp(value, retrieved_value) == 0);
ASSERT_NE(retrieved_value, nullptr);
ASSERT_STREQ(value, retrieved_value);
gpr_free(retrieved_value);
}
static void test_unsetenv(void) {
TEST(EnvTest, Unsetenv) {
const char* name = "FOO";
const char* value = "BAR";
char* retrieved_value;
@ -53,12 +55,11 @@ static void test_unsetenv(void) {
gpr_setenv(name, value);
gpr_unsetenv(name);
retrieved_value = gpr_getenv(name);
GPR_ASSERT(retrieved_value == nullptr);
ASSERT_EQ(retrieved_value, nullptr);
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
test_setenv_getenv();
test_unsetenv();
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

12
test/core/gpr/murmur_hash_test.cc
Unescape View File

@ -20,6 +20,8 @@
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
@ -65,11 +67,15 @@ static void verification_test(hash_func hash, uint32_t expected) {
}
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
TEST(MurmurHashTest, MainTest) {
/* basic tests to verify that things don't crash */
gpr_murmur_hash3("", 0, 0);
gpr_murmur_hash3("xyz", 3, 0);
verification_test(gpr_murmur_hash3, 0xB0F57EE3);
return 0;
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

20
test/core/gpr/spinlock_test.cc
Unescape View File

@ -23,6 +23,8 @@
#include <stdio.h>
#include <stdlib.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
@ -87,8 +89,7 @@ static void test_wait(struct test* m) {
incr_step controls by how much m->refcount should be incremented/decremented
(if at all) each time in the tests.
*/
static void test(const char* name, void (*body)(void* m), int timeout_s,
int incr_step) {
static void test(void (*body)(void* m), int timeout_s, int incr_step) {
int64_t iterations = 1024;
struct test* m;
gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
@ -96,8 +97,6 @@ static void test(const char* name, void (*body)(void* m), int timeout_s,
gpr_timespec deadline = gpr_time_add(
start, gpr_time_from_micros(static_cast<int64_t>(timeout_s) * 1000000,
GPR_TIMESPAN));
fprintf(stderr, "%s:", name);
fflush(stderr);
while (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) {
if (iterations < INT64_MAX / 2) iterations <<= 1;
fprintf(stderr, " %ld", static_cast<long>(iterations));
@ -110,7 +109,7 @@ static void test(const char* name, void (*body)(void* m), int timeout_s,
static_cast<long>(m->counter), m->thread_count,
static_cast<long>(m->iterations));
fflush(stderr);
GPR_ASSERT(0);
FAIL();
}
test_destroy(m);
}
@ -148,9 +147,12 @@ static void inctry(void* v /*=m*/) {
/* ------------------------------------------------- */
int main(int argc, char* argv[]) {
TEST(SpinlockTest, Spinlock) { test(&inc, 1, 1); }
TEST(SpinlockTest, SpinlockTry) { test(&inctry, 1, 1); }
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
test("spinlock", &inc, 1, 1);
test("spinlock try", &inctry, 1, 1);
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

192
test/core/gpr/string_test.cc
Unescape View File

@ -23,36 +23,33 @@
#include <stdlib.h>
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
#include "test/core/util/test_config.h"
#define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
static void test_strdup(void) {
TEST(StringTest, Strdup) {
static const char* src1 = "hello world";
char* dst1;
LOG_TEST_NAME("test_strdup");
dst1 = gpr_strdup(src1);
GPR_ASSERT(0 == strcmp(src1, dst1));
ASSERT_STREQ(src1, dst1);
gpr_free(dst1);
GPR_ASSERT(nullptr == gpr_strdup(nullptr));
ASSERT_EQ(nullptr, gpr_strdup(nullptr));
}
static void expect_dump(const char* buf, size_t len, uint32_t flags,
const char* result) {
char* got = gpr_dump(buf, len, flags);
GPR_ASSERT(0 == strcmp(got, result));
ASSERT_STREQ(got, result);
gpr_free(got);
}
static void test_dump(void) {
LOG_TEST_NAME("test_dump");
TEST(StringTest, Dump) {
expect_dump("\x01", 1, GPR_DUMP_HEX, "01");
expect_dump("\x01", 1, GPR_DUMP_HEX | GPR_DUMP_ASCII, "01 '.'");
expect_dump("\x01\x02", 2, GPR_DUMP_HEX, "01 02");
@ -63,18 +60,16 @@ static void test_dump(void) {
static void test_pu32_fail(const char* s) {
uint32_t out;
GPR_ASSERT(!gpr_parse_bytes_to_uint32(s, strlen(s), &out));
ASSERT_FALSE(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
}
static void test_pu32_succeed(const char* s, uint32_t want) {
uint32_t out;
GPR_ASSERT(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
GPR_ASSERT(out == want);
ASSERT_TRUE(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
ASSERT_EQ(out, want);
}
static void test_parse_uint32(void) {
LOG_TEST_NAME("test_parse_uint32");
TEST(StringTest, ParseUint32) {
test_pu32_fail("-1");
test_pu32_fail("a");
test_pu32_fail("");
@ -106,208 +101,179 @@ static void test_parse_uint32(void) {
test_pu32_fail("4294967299");
}
static void test_asprintf(void) {
TEST(StringTest, Asprintf) {
char* buf;
int i, j;
LOG_TEST_NAME("test_asprintf");
/* Print an empty string. */
GPR_ASSERT(gpr_asprintf(&buf, "%s", "") == 0);
GPR_ASSERT(buf[0] == '\0');
ASSERT_EQ(gpr_asprintf(&buf, "%s", ""), 0);
ASSERT_EQ(buf[0], '\0');
gpr_free(buf);
/* Print strings of various lengths. */
for (i = 1; i < 100; i++) {
GPR_ASSERT(gpr_asprintf(&buf, "%0*d", i, 1) == i);
ASSERT_EQ(gpr_asprintf(&buf, "%0*d", i, 1), i);
/* The buffer should resemble "000001\0". */
for (j = 0; j < i - 2; j++) {
GPR_ASSERT(buf[j] == '0');
ASSERT_EQ(buf[j], '0');
}
GPR_ASSERT(buf[i - 1] == '1');
GPR_ASSERT(buf[i] == '\0');
ASSERT_EQ(buf[i - 1], '1');
ASSERT_EQ(buf[i], '\0');
gpr_free(buf);
}
}
static void test_strjoin(void) {
TEST(StringTest, Strjoin) {
const char* parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char* joined;
LOG_TEST_NAME("test_strjoin");
joined = gpr_strjoin(parts, 4, &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
ASSERT_STREQ("onetwothreefour", joined);
gpr_free(joined);
joined = gpr_strjoin(parts, 0, &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
ASSERT_STREQ("", joined);
gpr_free(joined);
joined = gpr_strjoin(parts, 1, &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
ASSERT_STREQ("one", joined);
gpr_free(joined);
}
static void test_strjoin_sep(void) {
TEST(StringTest, StrjoinSep) {
const char* parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char* joined;
LOG_TEST_NAME("test_strjoin_sep");
joined = gpr_strjoin_sep(parts, 4, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one, two, three, four", joined));
ASSERT_STREQ("one, two, three, four", joined);
gpr_free(joined);
/* empty separator */
joined = gpr_strjoin_sep(parts, 4, "", &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
ASSERT_STREQ("onetwothreefour", joined);
gpr_free(joined);
/* degenerated case specifying zero input parts */
joined = gpr_strjoin_sep(parts, 0, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
ASSERT_STREQ("", joined);
gpr_free(joined);
/* single part should have no separator */
joined = gpr_strjoin_sep(parts, 1, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
ASSERT_STREQ("one", joined);
gpr_free(joined);
}
static void test_ltoa() {
TEST(StringTest, Ltoa) {
char* str;
char buf[GPR_LTOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_ltoa");
/* zero */
GPR_ASSERT(1 == gpr_ltoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
ASSERT_EQ(1, gpr_ltoa(0, buf));
ASSERT_STREQ("0", buf);
/* positive number */
GPR_ASSERT(3 == gpr_ltoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
ASSERT_EQ(3, gpr_ltoa(123, buf));
ASSERT_STREQ("123", buf);
/* negative number */
GPR_ASSERT(6 == gpr_ltoa(-12345, buf));
GPR_ASSERT(0 == strcmp("-12345", buf));
ASSERT_EQ(6, gpr_ltoa(-12345, buf));
ASSERT_STREQ("-12345", buf);
/* large negative - we don't know the size of long in advance */
GPR_ASSERT(gpr_asprintf(&str, "%lld", (long long)LONG_MIN));
GPR_ASSERT(strlen(str) == (size_t)gpr_ltoa(LONG_MIN, buf));
GPR_ASSERT(0 == strcmp(str, buf));
ASSERT_TRUE(gpr_asprintf(&str, "%lld", (long long)LONG_MIN));
ASSERT_EQ(strlen(str), (size_t)gpr_ltoa(LONG_MIN, buf));
ASSERT_STREQ(str, buf);
gpr_free(str);
}
static void test_int64toa() {
TEST(StringTest, Int64Toa) {
char buf[GPR_INT64TOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_int64toa");
/* zero */
GPR_ASSERT(1 == int64_ttoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
ASSERT_EQ(1, int64_ttoa(0, buf));
ASSERT_STREQ("0", buf);
/* positive */
GPR_ASSERT(3 == int64_ttoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
ASSERT_EQ(3, int64_ttoa(123, buf));
ASSERT_STREQ("123", buf);
/* large positive */
GPR_ASSERT(19 == int64_ttoa(9223372036854775807LL, buf));
GPR_ASSERT(0 == strcmp("9223372036854775807", buf));
ASSERT_EQ(19, int64_ttoa(9223372036854775807LL, buf));
ASSERT_STREQ("9223372036854775807", buf);
/* large negative */
GPR_ASSERT(20 == int64_ttoa(-9223372036854775807LL - 1, buf));
GPR_ASSERT(0 == strcmp("-9223372036854775808", buf));
ASSERT_EQ(20, int64_ttoa(-9223372036854775807LL - 1, buf));
ASSERT_STREQ("-9223372036854775808", buf);
}
static void test_leftpad() {
TEST(StringTest, Leftpad) {
char* padded;
LOG_TEST_NAME("test_leftpad");
padded = gpr_leftpad("foo", ' ', 5);
GPR_ASSERT(0 == strcmp(" foo", padded));
ASSERT_STREQ(" foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 4);
GPR_ASSERT(0 == strcmp(" foo", padded));
ASSERT_STREQ(" foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 3);
GPR_ASSERT(0 == strcmp("foo", padded));
ASSERT_STREQ("foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 2);
GPR_ASSERT(0 == strcmp("foo", padded));
ASSERT_STREQ("foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 1);
GPR_ASSERT(0 == strcmp("foo", padded));
ASSERT_STREQ("foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 0);
GPR_ASSERT(0 == strcmp("foo", padded));
ASSERT_STREQ("foo", padded);
gpr_free(padded);
padded = gpr_leftpad("foo", '0', 5);
GPR_ASSERT(0 == strcmp("00foo", padded));
ASSERT_STREQ("00foo", padded);
gpr_free(padded);
}
static void test_stricmp(void) {
LOG_TEST_NAME("test_stricmp");
GPR_ASSERT(0 == gpr_stricmp("hello", "hello"));
GPR_ASSERT(0 == gpr_stricmp("HELLO", "hello"));
GPR_ASSERT(gpr_stricmp("a", "b") < 0);
GPR_ASSERT(gpr_stricmp("b", "a") > 0);
TEST(StringTest, Stricmp) {
ASSERT_EQ(0, gpr_stricmp("hello", "hello"));
ASSERT_EQ(0, gpr_stricmp("HELLO", "hello"));
ASSERT_LT(gpr_stricmp("a", "b"), 0);
ASSERT_GT(gpr_stricmp("b", "a"), 0);
}
static void test_memrchr(void) {
LOG_TEST_NAME("test_memrchr");
GPR_ASSERT(nullptr == gpr_memrchr(nullptr, 'a', 0));
GPR_ASSERT(nullptr == gpr_memrchr("", 'a', 0));
GPR_ASSERT(nullptr == gpr_memrchr("hello", 'b', 5));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'h', 5), "hello"));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'o', 5), "o"));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'l', 5), "lo"));
TEST(StringTest, Memrchr) {
ASSERT_EQ(nullptr, gpr_memrchr(nullptr, 'a', 0));
ASSERT_EQ(nullptr, gpr_memrchr("", 'a', 0));
ASSERT_EQ(nullptr, gpr_memrchr("hello", 'b', 5));
ASSERT_STREQ((const char*)gpr_memrchr("hello", 'h', 5), "hello");
ASSERT_STREQ((const char*)gpr_memrchr("hello", 'o', 5), "o");
ASSERT_STREQ((const char*)gpr_memrchr("hello", 'l', 5), "lo");
}
static void test_parse_bool_value(void) {
LOG_TEST_NAME("test_parse_bool_value");
TEST(StringTest, ParseBoolValue) {
bool ret;
GPR_ASSERT(true == gpr_parse_bool_value("truE", &ret) && true == ret);
GPR_ASSERT(true == gpr_parse_bool_value("falsE", &ret) && false == ret);
GPR_ASSERT(true == gpr_parse_bool_value("1", &ret) && true == ret);
GPR_ASSERT(true == gpr_parse_bool_value("0", &ret) && false == ret);
GPR_ASSERT(true == gpr_parse_bool_value("Yes", &ret) && true == ret);
GPR_ASSERT(true == gpr_parse_bool_value("No", &ret) && false == ret);
GPR_ASSERT(true == gpr_parse_bool_value("Y", &ret) && true == ret);
GPR_ASSERT(true == gpr_parse_bool_value("N", &ret) && false == ret);
GPR_ASSERT(false == gpr_parse_bool_value(nullptr, &ret));
GPR_ASSERT(false == gpr_parse_bool_value("", &ret));
ASSERT_TRUE(true == gpr_parse_bool_value("truE", &ret) && true == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("falsE", &ret) && false == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("1", &ret) && true == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("0", &ret) && false == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("Yes", &ret) && true == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("No", &ret) && false == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("Y", &ret) && true == ret);
ASSERT_TRUE(true == gpr_parse_bool_value("N", &ret) && false == ret);
ASSERT_EQ(false, gpr_parse_bool_value(nullptr, &ret));
ASSERT_EQ(false, gpr_parse_bool_value("", &ret));
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
test_strdup();
test_dump();
test_parse_uint32();
test_asprintf();
test_strjoin();
test_strjoin_sep();
test_ltoa();
test_int64toa();
test_leftpad();
test_stricmp();
test_memrchr();
test_parse_bool_value();
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

30
test/core/gpr/sync_test.cc
Unescape View File

@ -21,6 +21,8 @@
#include <stdio.h>
#include <stdlib.h>
#include <gtest/gtest.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
@ -224,7 +226,7 @@ static int thread_id(struct test* m) {
and signalling done_cv if m->done==0. */
static void mark_thread_done(struct test* m) {
gpr_mu_lock(&m->mu);
GPR_ASSERT(m->done != 0);
ASSERT_NE(m->done, 0);
m->done--;
if (m->done == 0) {
gpr_cv_signal(&m->done_cv);
@ -269,7 +271,7 @@ static void test(const char* name, void (*body)(void* m),
static_cast<long>(m->counter), m->nthreads,
static_cast<long>(m->iterations));
fflush(stderr);
GPR_ASSERT(0);
ASSERT_TRUE(0);
}
test_destroy(m);
iterations <<= 1;
@ -353,7 +355,7 @@ static void inc_with_1ms_delay_event(void* v /*=m*/) {
gpr_timespec deadline;
deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_micros(1000, GPR_TIMESPAN));
GPR_ASSERT(gpr_event_wait(&m->event, deadline) == nullptr);
ASSERT_EQ(gpr_event_wait(&m->event, deadline), nullptr);
gpr_mu_lock(&m->mu);
m->counter++;
gpr_mu_unlock(&m->mu);
@ -395,7 +397,7 @@ static void consumer(void* v /*=m*/) {
gpr_mu_lock(&m->mu);
m->counter = n;
gpr_mu_unlock(&m->mu);
GPR_ASSERT(
ASSERT_TRUE(
!queue_remove(&m->q, &value,
gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
gpr_time_from_micros(1000000, GPR_TIMESPAN))));
@ -442,22 +444,21 @@ static void refcheck(void* v /*=m*/) {
struct test* m = static_cast<struct test*>(v);
int64_t n = m->iterations * m->nthreads * m->incr_step;
int64_t i;
GPR_ASSERT(gpr_event_wait(&m->event, gpr_inf_future(GPR_CLOCK_REALTIME)) ==
(void*)1);
GPR_ASSERT(gpr_event_get(&m->event) == (void*)1);
ASSERT_EQ(gpr_event_wait(&m->event, gpr_inf_future(GPR_CLOCK_REALTIME)),
(void*)1);
ASSERT_EQ(gpr_event_get(&m->event), (void*)1);
for (i = 1; i != n; i++) {
GPR_ASSERT(!gpr_unref(&m->refcount));
ASSERT_FALSE(gpr_unref(&m->refcount));
m->counter++;
}
GPR_ASSERT(gpr_unref(&m->refcount));
ASSERT_TRUE(gpr_unref(&m->refcount));
m->counter++;
mark_thread_done(m);
}
/* ------------------------------------------------- */
int main(int argc, char* argv[]) {
grpc::testing::TestEnvironment env(&argc, argv);
TEST(SyncTest, MainTest) {
test("mutex", &inc, nullptr, 1, 1);
test("mutex try", &inctry, nullptr, 1, 1);
test("cv", &inc_by_turns, nullptr, 1, 1);
@ -469,5 +470,10 @@ int main(int argc, char* argv[]) {
arbitrary choice. Any
number > 1 is okay here */
test("timedevent", &inc_with_1ms_delay_event, nullptr, 1, 1);
return 0;
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

145
test/core/gpr/time_test.cc
Unescape View File

@ -24,6 +24,8 @@
#include <stdlib.h>
#include <string.h>
#include <gtest/gtest.h>
#include <grpc/support/log.h>
#include <grpc/support/sync.h>
#include <grpc/support/time.h>
@ -41,7 +43,7 @@ static void i_to_s(intmax_t x, int base, int chars,
void* arg) {
char buf[64];
char fmt[32];
GPR_ASSERT(base == 16 || base == 10);
ASSERT_TRUE(base == 16 || base == 10);
sprintf(fmt, "%%0%d%s", chars, base == 16 ? PRIxMAX : PRIdMAX);
sprintf(buf, fmt, x);
(*writer)(arg, buf, strlen(buf));
@ -60,18 +62,18 @@ static void ts_to_s(gpr_timespec t,
i_to_s(t.tv_nsec, 10, 9, writer, arg);
}
static void test_values(void) {
TEST(TimeTest, Values) {
int i;
gpr_timespec x = gpr_time_0(GPR_CLOCK_REALTIME);
GPR_ASSERT(x.tv_sec == 0 && x.tv_nsec == 0);
ASSERT_TRUE(x.tv_sec == 0 && x.tv_nsec == 0);
x = gpr_inf_future(GPR_CLOCK_REALTIME);
fprintf(stderr, "far future ");
fflush(stderr);
i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
fprintf(stderr, "\n");
GPR_ASSERT(x.tv_sec == INT64_MAX);
ASSERT_EQ(x.tv_sec, INT64_MAX);
fprintf(stderr, "far future ");
fflush(stderr);
ts_to_s(x, &to_fp, stderr);
@ -84,7 +86,7 @@ static void test_values(void) {
i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
GPR_ASSERT(x.tv_sec == INT64_MIN);
ASSERT_EQ(x.tv_sec, INT64_MIN);
fprintf(stderr, "far past ");
fflush(stderr);
ts_to_s(x, &to_fp, stderr);
@ -93,41 +95,41 @@ static void test_values(void) {
for (i = 1; i != 1000 * 1000 * 1000; i *= 10) {
x = gpr_time_from_micros(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec == i / GPR_US_PER_SEC &&
x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
ASSERT_TRUE(x.tv_sec == i / GPR_US_PER_SEC &&
x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
x = gpr_time_from_nanos(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec == i / GPR_NS_PER_SEC &&
x.tv_nsec == (i % GPR_NS_PER_SEC));
ASSERT_TRUE(x.tv_sec == i / GPR_NS_PER_SEC &&
x.tv_nsec == (i % GPR_NS_PER_SEC));
x = gpr_time_from_millis(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec == i / GPR_MS_PER_SEC &&
x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
ASSERT_TRUE(x.tv_sec == i / GPR_MS_PER_SEC &&
x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
}
/* Test possible overflow in conversion of -ve values. */
x = gpr_time_from_micros(-(INT64_MAX - 999997), GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec < 0);
GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
x = gpr_time_from_nanos(-(INT64_MAX - 999999997), GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec < 0);
GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
x = gpr_time_from_millis(-(INT64_MAX - 997), GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec < 0);
GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
/* Test general -ve values. */
for (i = -1; i > -1000 * 1000 * 1000; i *= 7) {
x = gpr_time_from_micros(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US == i);
ASSERT_EQ(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US, i);
x = gpr_time_from_nanos(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec == i);
ASSERT_EQ(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec, i);
x = gpr_time_from_millis(i, GPR_TIMESPAN);
GPR_ASSERT(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS == i);
ASSERT_EQ(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS, i);
}
}
static void test_add_sub(void) {
TEST(TimeTest, AddSub) {
int i;
int j;
int k;
@ -148,7 +150,7 @@ static void test_add_sub(void) {
ts_to_s(sumt, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
GPR_ASSERT(0);
ASSERT_TRUE(0);
}
if (gpr_time_cmp(gpr_time_from_micros(diff * k, GPR_TIMESPAN), difft) !=
0) {
@ -157,28 +159,28 @@ static void test_add_sub(void) {
ts_to_s(sumt, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
GPR_ASSERT(0);
ASSERT_TRUE(0);
}
}
}
}
}
static void test_overflow(void) {
TEST(TimeTest, Overflow) {
/* overflow */
gpr_timespec x = gpr_time_from_micros(1, GPR_TIMESPAN);
do {
x = gpr_time_add(x, x);
} while (gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) < 0);
GPR_ASSERT(gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) == 0);
ASSERT_EQ(gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)), 0);
x = gpr_time_from_micros(-1, GPR_TIMESPAN);
do {
x = gpr_time_add(x, x);
} while (gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) > 0);
GPR_ASSERT(gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) == 0);
ASSERT_EQ(gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)), 0);
}
static void test_sticky_infinities(void) {
TEST(TimeTest, StickyInfinities) {
int i;
int j;
int k;
@ -194,75 +196,68 @@ static void test_sticky_infinities(void) {
for (i = 0; i != sizeof(infinity) / sizeof(infinity[0]); i++) {
for (j = 0; j != sizeof(addend) / sizeof(addend[0]); j++) {
gpr_timespec x = gpr_time_add(infinity[i], addend[j]);
GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
x = gpr_time_sub(infinity[i], addend[j]);
GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
}
for (k = -200; k <= 200; k++) {
gpr_timespec y = gpr_time_from_micros(k * 100000, GPR_TIMESPAN);
gpr_timespec x = gpr_time_add(infinity[i], y);
GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
x = gpr_time_sub(infinity[i], y);
GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
}
}
}
static void test_similar(void) {
GPR_ASSERT(1 == gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
GPR_ASSERT(1 == gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
GPR_ASSERT(0 == gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
GPR_ASSERT(0 == gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
TEST(TimeTest, Similar) {
ASSERT_EQ(1, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
}
static void test_convert_extreme(void) {
TEST(TimeTest, ConvertExtreme) {
gpr_timespec realtime = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
gpr_timespec monotime = gpr_convert_clock_type(realtime, GPR_CLOCK_MONOTONIC);
GPR_ASSERT(monotime.tv_sec == realtime.tv_sec);
GPR_ASSERT(monotime.clock_type == GPR_CLOCK_MONOTONIC);
ASSERT_EQ(monotime.tv_sec, realtime.tv_sec);
ASSERT_EQ(monotime.clock_type, GPR_CLOCK_MONOTONIC);
}
static void test_cmp_extreme(void) {
TEST(TimeTest, CmpExtreme) {
gpr_timespec t1 = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
gpr_timespec t2 = {INT64_MAX, 2, GPR_CLOCK_REALTIME};
GPR_ASSERT(gpr_time_cmp(t1, t2) == 0);
ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
t1.tv_sec = INT64_MIN;
t2.tv_sec = INT64_MIN;
GPR_ASSERT(gpr_time_cmp(t1, t2) == 0);
ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
}
int main(int argc, char* argv[]) {
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
test_values();
test_add_sub();
test_overflow();
test_sticky_infinities();
test_similar();
test_convert_extreme();
test_cmp_extreme();
return 0;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

384
tools/run_tests/generated/tests.json generated
Unescape View File

@ -1,30 +1,6 @@
[
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "alloc_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -211,30 +187,6 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "cpu_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -281,30 +233,6 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "env_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -585,30 +513,6 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "murmur_hash_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -799,78 +703,6 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "spinlock_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "string_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "sync_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -935,30 +767,6 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": false,
"language": "c",
"name": "test_core_gpr_time_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -1145,6 +953,30 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "alloc_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -2841,6 +2673,30 @@
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "cpu_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -3079,6 +2935,30 @@
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "env_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -4949,6 +4829,30 @@
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "murmur_hash_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -6375,6 +6279,30 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "spinlock_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -6679,6 +6607,54 @@
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "string_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "sync_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,
@ -6823,6 +6799,30 @@
],
"uses_polling": true
},
{
"args": [],
"benchmark": false,
"ci_platforms": [
"linux",
"mac",
"posix",
"windows"
],
"cpu_cost": 1.0,
"exclude_configs": [],
"exclude_iomgrs": [],
"flaky": false,
"gtest": true,
"language": "c++",
"name": "test_core_gpr_time_test",
"platforms": [
"linux",
"mac",
"posix",
"windows"
],
"uses_polling": false
},
{
"args": [],
"benchmark": false,

Write Preview
Loading…
Cancel
Save