From be2696905820da446f96e939fd138ef6e48827b2 Mon Sep 17 00:00:00 2001 From: Esun Kim Date: Thu, 29 Aug 2024 09:50:14 -0700 Subject: [PATCH] [CI] Upgraded clang to 18 in sanity tests (#37593) Closes #37593 PiperOrigin-RevId: 668971470 --- .clang-tidy | 9 +- include/grpc/support/sync_generic.h | 6 +- .../chaotic_good/server/chaotic_good_server.h | 2 +- .../cf_engine/cftype_unique_ref.h | 2 +- .../posix_engine/posix_engine_listener.h | 4 +- .../posix_engine/tcp_socket_utils.h | 2 +- .../windows/grpc_polled_fd_windows.cc | 2 +- src/core/lib/promise/interceptor_list.h | 6 +- .../dns/c_ares/grpc_ares_ev_driver_windows.cc | 2 +- src/core/util/latent_see.h | 2 +- src/core/util/ring_buffer.h | 2 +- src/core/util/spinlock.h | 3 +- .../GrpcIosTestUITests/GrpcIosTestUITests.m | 3 +- .../grpc_clang_format/Dockerfile.template | 2 +- .../grpc_clang_tidy/Dockerfile.template | 2 +- .../test/sanity/Dockerfile.template | 10 +- test/core/end2end/end2end_test_suites.cc | 754 +++++++++--------- test/core/end2end/h2_ssl_cert_test.cc | 14 +- .../default_engine_methods_test.cc | 2 +- .../posix/posix_engine_test_utils.h | 2 +- test/core/gprpp/match_test.cc | 3 +- .../iomgr/pollset_windows_starvation_test.cc | 6 +- test/core/promise/bm_party.cc | 3 +- test/core/promise/if_test.cc | 8 +- .../transport/chttp2/ping_callbacks_test.cc | 44 +- test/cpp/cocoapods/generic/generic.mm | 6 +- test/cpp/qps/interarrival.h | 2 +- test/cpp/qps/server_async.cc | 2 +- ...server_builder_with_socket_mutator_test.cc | 2 +- .../dockerimage_current_versions.bzl | 2 +- tools/dockerfile/grpc_clang_format/Dockerfile | 2 +- tools/dockerfile/grpc_clang_tidy/Dockerfile | 2 +- tools/dockerfile/test/sanity.current_version | 2 +- tools/dockerfile/test/sanity/Dockerfile | 10 +- 34 files changed, 439 insertions(+), 486 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index 32eed8a70e6..3c6c0f03e99 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -69,31 +69,37 @@ Checks: '-*, bugprone-*, -bugprone-assignment-in-if-condition, -bugprone-branch-clone, + -bugprone-casting-through-void, -bugprone-easily-swappable-parameters, -bugprone-empty-catch, -bugprone-exception-escape, -bugprone-implicit-widening-of-multiplication-result, + -bugprone-inc-dec-in-conditions, -bugprone-infinite-loop, + -bugprone-multi-level-implicit-pointer-conversion, -bugprone-narrowing-conversions, -bugprone-not-null-terminated-result, + -bugprone-optional-value-conversion, -bugprone-reserved-identifier, -bugprone-signed-char-misuse, -bugprone-sizeof-expression, -bugprone-switch-missing-default-case, -bugprone-too-small-loop-variable, -bugprone-unchecked-optional-access, + -bugprone-unused-local-non-trivial-variable, + -bugprone-unused-return-value, google-*, -google-readability-casting, -google-runtime-int, -google-runtime-references, performance-*, -performance-avoid-endl, + -performance-enum-size, -performance-no-automatic-move, -performance-no-int-to-ptr, -performance-noexcept-swap, -performance-unnecessary-copy-initialization, -performance-unnecessary-value-param, - clang-diagnostic-deprecated-declarations, clang-diagnostic-deprecated-register, clang-diagnostic-expansion-to-defined, clang-diagnostic-ignored-attributes, @@ -102,6 +108,7 @@ Checks: '-*, clang-diagnostic-shift-sign-overflow, clang-diagnostic-tautological-undefined-compare, clang-diagnostic-thread-safety*, + -clang-diagnostic-thread-safety-reference-return, clang-diagnostic-undefined-bool-conversion, clang-diagnostic-unreachable-code, clang-diagnostic-unreachable-code-loop-increment, diff --git a/include/grpc/support/sync_generic.h b/include/grpc/support/sync_generic.h index b3e638ce549..aa0261c2b6c 100644 --- a/include/grpc/support/sync_generic.h +++ b/include/grpc/support/sync_generic.h @@ -29,8 +29,7 @@ typedef struct { gpr_atm state; } gpr_event; -#define GPR_EVENT_INIT \ - { 0 } +#define GPR_EVENT_INIT {0} /* gpr_refcount */ typedef struct { @@ -42,7 +41,6 @@ typedef struct { gpr_atm value; } gpr_stats_counter; -#define GPR_STATS_INIT \ - { 0 } +#define GPR_STATS_INIT {0} #endif /* GRPC_SUPPORT_SYNC_GENERIC_H */ diff --git a/src/core/ext/transport/chaotic_good/server/chaotic_good_server.h b/src/core/ext/transport/chaotic_good/server/chaotic_good_server.h index 8da7bc7513e..0b20dcbb363 100644 --- a/src/core/ext/transport/chaotic_good/server/chaotic_good_server.h +++ b/src/core/ext/transport/chaotic_good/server/chaotic_good_server.h @@ -83,7 +83,7 @@ class ChaoticGoodServerListener final : public Server::ListenerInterface { class HandshakingState : public RefCounted { public: explicit HandshakingState(RefCountedPtr connection); - ~HandshakingState() override{}; + ~HandshakingState() override {}; void Start(std::unique_ptr< grpc_event_engine::experimental::EventEngine::Endpoint> endpoint); diff --git a/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h b/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h index 04953cade29..5deb68f327d 100644 --- a/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h +++ b/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h @@ -37,7 +37,7 @@ class CFTypeUniqueRef { CFTypeUniqueRef(CFTypeUniqueRef const&) = delete; CFTypeUniqueRef& operator=(CFTypeUniqueRef const&) = delete; - CFTypeUniqueRef(CFTypeUniqueRef&& other) : cf_type_ref_(other.release()){}; + CFTypeUniqueRef(CFTypeUniqueRef&& other) : cf_type_ref_(other.release()) {}; CFTypeUniqueRef& operator=(CFTypeUniqueRef&& other) { reset(other.release()); return *this; diff --git a/src/core/lib/event_engine/posix_engine/posix_engine_listener.h b/src/core/lib/event_engine/posix_engine/posix_engine_listener.h index 5a15129ddbd..73a921a35e4 100644 --- a/src/core/lib/event_engine/posix_engine/posix_engine_listener.h +++ b/src/core/lib/event_engine/posix_engine/posix_engine_listener.h @@ -93,7 +93,7 @@ class PosixEngineListenerImpl ResolvedAddressToNormalizedString(socket_.addr), listener_->poller_->CanTrackErrors())), notify_on_accept_(PosixEngineClosure::ToPermanentClosure( - [this](absl::Status status) { NotifyOnAccept(status); })){}; + [this](absl::Status status) { NotifyOnAccept(status); })) {}; // Start listening for incoming connections on the socket. void Start(); // Internal callback invoked when the socket has incoming connections to @@ -129,7 +129,7 @@ class PosixEngineListenerImpl class ListenerAsyncAcceptors : public ListenerSocketsContainer { public: explicit ListenerAsyncAcceptors(PosixEngineListenerImpl* listener) - : listener_(listener){}; + : listener_(listener) {}; void UpdateOnAppendCallback( PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_append) { diff --git a/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h b/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h index 6eb6742e339..412fafcad32 100644 --- a/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h +++ b/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h @@ -163,7 +163,7 @@ class PosixSocketWrapper { public: explicit PosixSocketWrapper(int fd) : fd_(fd) { CHECK_GT(fd_, 0); } - PosixSocketWrapper() : fd_(-1){}; + PosixSocketWrapper() : fd_(-1) {}; ~PosixSocketWrapper() = default; diff --git a/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc b/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc index 6116fc65853..b9542b0bb6b 100644 --- a/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc +++ b/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc @@ -82,7 +82,7 @@ grpc_slice FlattenIovec(const struct iovec* iov, int iov_count) { // instantiated at the top of the virtual socket function callstack. class WSAErrorContext { public: - explicit WSAErrorContext(){}; + explicit WSAErrorContext() {}; ~WSAErrorContext() { if (error_ != 0) { diff --git a/src/core/lib/promise/interceptor_list.h b/src/core/lib/promise/interceptor_list.h index a47a75bc97a..dc9b63d3f8c 100644 --- a/src/core/lib/promise/interceptor_list.h +++ b/src/core/lib/promise/interceptor_list.h @@ -217,15 +217,13 @@ class InterceptorList { // Append a new map to the end of the chain. template void AppendMap(Fn fn, DebugLocation from) { - Append(MakeMapToAdd( - std::move(fn), [] {}, from)); + Append(MakeMapToAdd(std::move(fn), [] {}, from)); } // Prepend a new map to the beginning of the chain. template void PrependMap(Fn fn, DebugLocation from) { - Prepend(MakeMapToAdd( - std::move(fn), [] {}, from)); + Prepend(MakeMapToAdd(std::move(fn), [] {}, from)); } // Append a new map to the end of the chain, with a cleanup function to be diff --git a/src/core/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc b/src/core/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc index a9f257f5b4d..9b9a79b3206 100644 --- a/src/core/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc +++ b/src/core/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc @@ -72,7 +72,7 @@ namespace { // instantiated at the top of the virtual socket function callstack. class WSAErrorContext final { public: - explicit WSAErrorContext(){}; + explicit WSAErrorContext() {}; ~WSAErrorContext() { if (error_ != 0) { diff --git a/src/core/util/latent_see.h b/src/core/util/latent_see.h index cf499caa84b..4d4f1584b06 100644 --- a/src/core/util/latent_see.h +++ b/src/core/util/latent_see.h @@ -156,7 +156,7 @@ class Log { static std::atomic free_bins_; absl::AnyInvocable stats_flusher_ = nullptr; struct Fragment { - Fragment() : active(&primary){}; + Fragment() : active(&primary) {}; Mutex mu; RingBuffer* active ABSL_GUARDED_BY(mu); diff --git a/src/core/util/ring_buffer.h b/src/core/util/ring_buffer.h index 4831c2202c1..ab0f30f6350 100644 --- a/src/core/util/ring_buffer.h +++ b/src/core/util/ring_buffer.h @@ -64,7 +64,7 @@ class RingBuffer { T operator*() { return buffer_->data_[head_]; } - RingBufferIterator() : buffer_(nullptr), head_(0), size_(0){}; + RingBufferIterator() : buffer_(nullptr), head_(0), size_(0) {}; RingBufferIterator(const RingBufferIterator& other) = default; explicit RingBufferIterator(const RingBuffer* buffer) : buffer_(buffer), head_(buffer->head_), size_(buffer->size_) { diff --git a/src/core/util/spinlock.h b/src/core/util/spinlock.h index b46db8e2a6f..b95d324e988 100644 --- a/src/core/util/spinlock.h +++ b/src/core/util/spinlock.h @@ -34,8 +34,7 @@ struct gpr_spinlock { #else #define GPR_SPINLOCK_INITIALIZER ((gpr_spinlock){0}) #endif -#define GPR_SPINLOCK_STATIC_INITIALIZER \ - { 0 } +#define GPR_SPINLOCK_STATIC_INITIALIZER {0} #define gpr_spinlock_trylock(lock) (gpr_atm_acq_cas(&(lock)->atm, 0, 1)) #define gpr_spinlock_unlock(lock) (gpr_atm_rel_store(&(lock)->atm, 0)) diff --git a/src/objective-c/manual_tests/GrpcIosTestUITests/GrpcIosTestUITests.m b/src/objective-c/manual_tests/GrpcIosTestUITests/GrpcIosTestUITests.m index a75b6322148..8424780461b 100644 --- a/src/objective-c/manual_tests/GrpcIosTestUITests/GrpcIosTestUITests.m +++ b/src/objective-c/manual_tests/GrpcIosTestUITests/GrpcIosTestUITests.m @@ -75,8 +75,7 @@ int const kNumIterations = 1; [NSThread sleepForTimeInterval:1]; } // Wait until all events in run loop have been processed - while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, true) == kCFRunLoopRunHandledSource) - ; + while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, true) == kCFRunLoopRunHandledSource); NSLog(@"Pressing button: %@", name); [testApp.buttons[name] tap]; diff --git a/templates/tools/dockerfile/grpc_clang_format/Dockerfile.template b/templates/tools/dockerfile/grpc_clang_format/Dockerfile.template index 5fac5f1d894..8d21fb6038d 100644 --- a/templates/tools/dockerfile/grpc_clang_format/Dockerfile.template +++ b/templates/tools/dockerfile/grpc_clang_format/Dockerfile.template @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. - FROM silkeh/clang:17-bookworm + FROM silkeh/clang:18-bookworm ADD clang_format_all_the_things.sh / diff --git a/templates/tools/dockerfile/grpc_clang_tidy/Dockerfile.template b/templates/tools/dockerfile/grpc_clang_tidy/Dockerfile.template index 0d3aa6d8675..3b7a7b036e7 100644 --- a/templates/tools/dockerfile/grpc_clang_tidy/Dockerfile.template +++ b/templates/tools/dockerfile/grpc_clang_tidy/Dockerfile.template @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. - FROM silkeh/clang:17-bookworm + FROM silkeh/clang:18-bookworm # Install prerequisites for the clang-tidy script RUN apt-get update && apt-get install -y python3 jq git && apt-get clean diff --git a/templates/tools/dockerfile/test/sanity/Dockerfile.template b/templates/tools/dockerfile/test/sanity/Dockerfile.template index 88fa82fb70d..e429c78ce32 100644 --- a/templates/tools/dockerfile/test/sanity/Dockerfile.template +++ b/templates/tools/dockerfile/test/sanity/Dockerfile.template @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. - FROM silkeh/clang:17-bookworm + FROM silkeh/clang:18-bookworm <%include file="../../apt_get_basic.include"/> @@ -22,13 +22,13 @@ # (Bullseye comes with Python 3.9 which isn't supported by pytype yet) RUN apt update && apt install -y build-essential zlib1g-dev libncurses5-dev libgdbm-dev ${'\\'} libnss3-dev libssl-dev libreadline-dev libffi-dev libbz2-dev - RUN curl -O https://www.python.org/ftp/python/3.7.9/Python-3.7.9.tar.xz && ${'\\'} - tar -xf Python-3.7.9.tar.xz && ${'\\'} - cd Python-3.7.9 && ${'\\'} + RUN curl -O https://www.python.org/ftp/python/3.7.17/Python-3.7.17.tar.xz && ${'\\'} + tar -xf Python-3.7.17.tar.xz && ${'\\'} + cd Python-3.7.17 && ${'\\'} ./configure && ${'\\'} make -j 4 && ${'\\'} make install - RUN curl https://bootstrap.pypa.io/get-pip.py | python3 + RUN curl https://bootstrap.pypa.io/pip/3.7/get-pip.py | python3 <%include file="../../gcp_api_libraries.include"/> <%include file="../../run_tests_addons.include"/> diff --git a/test/core/end2end/end2end_test_suites.cc b/test/core/end2end/end2end_test_suites.cc index 61bc29cdb19..72c06d9d2c2 100644 --- a/test/core/end2end/end2end_test_suites.cc +++ b/test/core/end2end/end2end_test_suites.cc @@ -585,378 +585,367 @@ std::string GetTempDir() { const std::string temp_dir = GetTempDir(); std::vector DefaultConfigs() { - return std::vector { + return std::vector{ #ifdef GRPC_POSIX_SOCKET - CoreTestConfiguration{"Chttp2Fd", - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(); - }}, + CoreTestConfiguration{"Chttp2Fd", + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(); + }}, #endif - CoreTestConfiguration{ - "Chttp2FakeSecurityFullstack", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE | - FEATURE_MASK_IS_HTTP2, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(); - }}, - CoreTestConfiguration{ - "Chttp2Fullstack", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - return std::make_unique(); - }}, - CoreTestConfiguration{ - "Chttp2FullstackCompression", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(); - }}, + CoreTestConfiguration{ + "Chttp2FakeSecurityFullstack", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE | + FEATURE_MASK_IS_HTTP2, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(); + }}, + CoreTestConfiguration{ + "Chttp2Fullstack", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + return std::make_unique(); + }}, + CoreTestConfiguration{ + "Chttp2FullstackCompression", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(); + }}, #ifdef GPR_LINUX - CoreTestConfiguration{ - "Chttp2FullstackLocalAbstractUdsPercentEncoded", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); - return std::make_unique( - absl::StrFormat( - "unix-abstract:grpc_fullstack_test.%%00.%d.%" PRId64 - ".%" PRId32 ".%" PRId64 ".%" PRId64, - getpid(), now.tv_sec, now.tv_nsec, - unique.fetch_add(1, std::memory_order_relaxed), Rand()), - UDS); - }}, + CoreTestConfiguration{ + "Chttp2FullstackLocalAbstractUdsPercentEncoded", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); + return std::make_unique( + absl::StrFormat( + "unix-abstract:grpc_fullstack_test.%%00.%d.%" PRId64 + ".%" PRId32 ".%" PRId64 ".%" PRId64, + getpid(), now.tv_sec, now.tv_nsec, + unique.fetch_add(1, std::memory_order_relaxed), Rand()), + UDS); + }}, #endif - CoreTestConfiguration{"Chttp2FullstackLocalIpv4", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - int port = grpc_pick_unused_port_or_die(); - return std::make_unique( - JoinHostPort("127.0.0.1", port), LOCAL_TCP); - }}, - CoreTestConfiguration{"Chttp2FullstackLocalIpv6", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - int port = grpc_pick_unused_port_or_die(); - return std::make_unique( - JoinHostPort("[::1]", port), LOCAL_TCP); - }}, + CoreTestConfiguration{"Chttp2FullstackLocalIpv4", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + int port = grpc_pick_unused_port_or_die(); + return std::make_unique( + JoinHostPort("127.0.0.1", port), LOCAL_TCP); + }}, + CoreTestConfiguration{"Chttp2FullstackLocalIpv6", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + int port = grpc_pick_unused_port_or_die(); + return std::make_unique( + JoinHostPort("[::1]", port), LOCAL_TCP); + }}, #ifdef GRPC_HAVE_UNIX_SOCKET - CoreTestConfiguration{ - "Chttp2FullstackLocalUdsPercentEncoded", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); - return std::make_unique( - absl::StrFormat( - "unix:%s" - "grpc_fullstack_test.%%25.%d.%" PRId64 ".%" PRId32 - ".%" PRId64 ".%" PRId64, - temp_dir, getpid(), now.tv_sec, now.tv_nsec, - unique.fetch_add(1, std::memory_order_relaxed), Rand()), - UDS); - }}, - CoreTestConfiguration{ - "Chttp2FullstackLocalUds", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); - return std::make_unique( - absl::StrFormat( - "unix:%s" - "grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 ".%" PRId64 - ".%" PRId64, - temp_dir, getpid(), now.tv_sec, now.tv_nsec, - unique.fetch_add(1, std::memory_order_relaxed), Rand()), - UDS); - }}, + CoreTestConfiguration{ + "Chttp2FullstackLocalUdsPercentEncoded", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC); + return std::make_unique( + absl::StrFormat("unix:%s" + "grpc_fullstack_test.%%25.%d.%" PRId64 + ".%" PRId32 ".%" PRId64 ".%" PRId64, + temp_dir, getpid(), now.tv_sec, now.tv_nsec, + unique.fetch_add(1, std::memory_order_relaxed), + Rand()), + UDS); + }}, + CoreTestConfiguration{ + "Chttp2FullstackLocalUds", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); + return std::make_unique( + absl::StrFormat("unix:%s" + "grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 + ".%" PRId64 ".%" PRId64, + temp_dir, getpid(), now.tv_sec, now.tv_nsec, + unique.fetch_add(1, std::memory_order_relaxed), + Rand()), + UDS); + }}, #endif - CoreTestConfiguration{"Chttp2FullstackNoRetry", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DOES_NOT_SUPPORT_RETRY, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - return std::make_unique(); - }}, - CoreTestConfiguration{ - "Chttp2FullstackWithCensus", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(); - }}, - CoreTestConfiguration{ - "Chttp2FullstackWithProxy", - FEATURE_MASK_SUPPORTS_REQUEST_PROXYING | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ, - nullptr, - [](const ChannelArgs& client_args, const ChannelArgs& server_args) { - return std::make_unique(client_args, server_args); - }}, - CoreTestConfiguration{ - "Chttp2HttpProxy", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ, - nullptr, - [](const ChannelArgs& client_args, const ChannelArgs&) { - return std::make_unique(client_args); - }}, - CoreTestConfiguration{ - "Chttp2SslProxy", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_REQUEST_PROXYING | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ, - "foo.test.google.fr", - [](const ChannelArgs& client_args, const ChannelArgs& server_args) { - return std::make_unique(client_args, - server_args); - }}, - CoreTestConfiguration{ - "Chttp2InsecureCredentials", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE | - FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(); - }, - }, - CoreTestConfiguration{ - "Chttp2SimpleSslWithOauth2FullstackTls12", - FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(grpc_tls_version::TLS1_2); - }}, - CoreTestConfiguration{ - "Chttp2SimpleSslWithOauth2FullstackTls13", - FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(grpc_tls_version::TLS1_3); - }}, - CoreTestConfiguration{ - "Chttp2SimplSslFullstackTls12", - FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(grpc_tls_version::TLS1_2); - }}, - CoreTestConfiguration{ - "Chttp2SimplSslFullstackTls13", - FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_DOES_NOT_SUPPORT_CLIENT_HANDSHAKE_COMPLETE_FIRST | - FEATURE_MASK_IS_HTTP2, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(grpc_tls_version::TLS1_3); - }}, - CoreTestConfiguration{ - "Chttp2SocketPair", - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(ChannelArgs()); - }}, - CoreTestConfiguration{ - "Chttp2SocketPair1ByteAtATime", - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_1BYTE_AT_A_TIME | - FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - ChannelArgs() - .Set(GRPC_ARG_TCP_READ_CHUNK_SIZE, 1) - .Set(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE, 1) - .Set(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE, 1)); - }}, - CoreTestConfiguration{ - "Chttp2SocketPairMinstack", - FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_IS_MINSTACK | - FEATURE_MASK_DO_NOT_FUZZ, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - ChannelArgs()); - }}, - CoreTestConfiguration{ - "Inproc", - FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(false); - }, - }, - CoreTestConfiguration{ - "InprocWithPromises", - FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING | - FEATURE_MASK_IS_CALL_V3, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(true); - }, - }, - CoreTestConfiguration{ - "Chttp2SslCredReloadTls12", - FEATURE_MASK_IS_SECURE | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(TLS1_2); - }}, - CoreTestConfiguration{ - "Chttp2SslCredReloadTls13", - FEATURE_MASK_IS_SECURE | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_DOES_NOT_SUPPORT_CLIENT_HANDSHAKE_COMPLETE_FIRST, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique(TLS1_3); - }}, - CoreTestConfiguration{ - // client: certificate watcher provider + async external verifier - // server: certificate watcher provider + async external verifier - // extra: TLS 1.3 - "Chttp2CertWatcherProviderAsyncVerifierTls13", - kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - SecurityPrimitives::TlsVersion::V_13, - SecurityPrimitives::ProviderType::FILE_PROVIDER, - SecurityPrimitives::VerifierType::EXTERNAL_ASYNC_VERIFIER); - }, - }, - CoreTestConfiguration{ - // client: certificate watcher provider + hostname verifier - // server: certificate watcher provider + sync external verifier - // extra: TLS 1.2 - "Chttp2CertWatcherProviderSyncVerifierTls12", - kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - SecurityPrimitives::TlsVersion::V_12, - SecurityPrimitives::ProviderType::FILE_PROVIDER, - SecurityPrimitives::VerifierType::HOSTNAME_VERIFIER); - }, - }, - CoreTestConfiguration{ - // client: static data provider + sync external verifier - // server: static data provider + sync external verifier - // extra: TLS 1.2 - "Chttp2SimpleSslFullstack", - kH2TLSFeatureMask, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - SecurityPrimitives::TlsVersion::V_12, - SecurityPrimitives::ProviderType::STATIC_PROVIDER, - SecurityPrimitives::VerifierType::EXTERNAL_SYNC_VERIFIER); - }, - }, - CoreTestConfiguration{ - // client: static data provider + async external verifier - // server: static data provider + async external verifier - // extra: TLS 1.3 - "Chttp2StaticProviderAsyncVerifierTls13", - kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - "foo.test.google.fr", - [](const ChannelArgs&, const ChannelArgs&) { - return std::make_unique( - SecurityPrimitives::TlsVersion::V_13, - SecurityPrimitives::ProviderType::STATIC_PROVIDER, - SecurityPrimitives::VerifierType::EXTERNAL_ASYNC_VERIFIER); - }, - }, + CoreTestConfiguration{"Chttp2FullstackNoRetry", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DOES_NOT_SUPPORT_RETRY, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + return std::make_unique(); + }}, + CoreTestConfiguration{ + "Chttp2FullstackWithCensus", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(); + }}, + CoreTestConfiguration{ + "Chttp2FullstackWithProxy", + FEATURE_MASK_SUPPORTS_REQUEST_PROXYING | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ, + nullptr, + [](const ChannelArgs& client_args, const ChannelArgs& server_args) { + return std::make_unique(client_args, server_args); + }}, + CoreTestConfiguration{ + "Chttp2HttpProxy", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ, + nullptr, + [](const ChannelArgs& client_args, const ChannelArgs&) { + return std::make_unique(client_args); + }}, + CoreTestConfiguration{ + "Chttp2SslProxy", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_SECURE | + FEATURE_MASK_SUPPORTS_REQUEST_PROXYING | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ, + "foo.test.google.fr", + [](const ChannelArgs& client_args, const ChannelArgs& server_args) { + return std::make_unique(client_args, server_args); + }}, + CoreTestConfiguration{ + "Chttp2InsecureCredentials", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS_LEVEL_INSECURE | + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(); + }, + }, + CoreTestConfiguration{ + "Chttp2SimpleSslWithOauth2FullstackTls12", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(grpc_tls_version::TLS1_2); + }}, + CoreTestConfiguration{ + "Chttp2SimpleSslWithOauth2FullstackTls13", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(grpc_tls_version::TLS1_3); + }}, + CoreTestConfiguration{ + "Chttp2SimplSslFullstackTls12", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(grpc_tls_version::TLS1_2); + }}, + CoreTestConfiguration{ + "Chttp2SimplSslFullstackTls13", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_DOES_NOT_SUPPORT_CLIENT_HANDSHAKE_COMPLETE_FIRST | + FEATURE_MASK_IS_HTTP2, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(grpc_tls_version::TLS1_3); + }}, + CoreTestConfiguration{"Chttp2SocketPair", + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + ChannelArgs()); + }}, + CoreTestConfiguration{ + "Chttp2SocketPair1ByteAtATime", + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_1BYTE_AT_A_TIME | + FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + ChannelArgs() + .Set(GRPC_ARG_TCP_READ_CHUNK_SIZE, 1) + .Set(GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE, 1) + .Set(GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE, 1)); + }}, + CoreTestConfiguration{ + "Chttp2SocketPairMinstack", + FEATURE_MASK_IS_HTTP2 | FEATURE_MASK_IS_MINSTACK | + FEATURE_MASK_DO_NOT_FUZZ, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(ChannelArgs()); + }}, + CoreTestConfiguration{ + "Inproc", + FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(false); + }, + }, + CoreTestConfiguration{ + "InprocWithPromises", + FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING | + FEATURE_MASK_IS_CALL_V3, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(true); + }, + }, + CoreTestConfiguration{ + "Chttp2SslCredReloadTls12", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(TLS1_2); + }}, + CoreTestConfiguration{ + "Chttp2SslCredReloadTls13", + FEATURE_MASK_IS_SECURE | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_DOES_NOT_SUPPORT_CLIENT_HANDSHAKE_COMPLETE_FIRST, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique(TLS1_3); + }}, + CoreTestConfiguration{ + // client: certificate watcher provider + async external verifier + // server: certificate watcher provider + async external verifier + // extra: TLS 1.3 + "Chttp2CertWatcherProviderAsyncVerifierTls13", + kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + SecurityPrimitives::TlsVersion::V_13, + SecurityPrimitives::ProviderType::FILE_PROVIDER, + SecurityPrimitives::VerifierType::EXTERNAL_ASYNC_VERIFIER); + }, + }, + CoreTestConfiguration{ + // client: certificate watcher provider + hostname verifier + // server: certificate watcher provider + sync external verifier + // extra: TLS 1.2 + "Chttp2CertWatcherProviderSyncVerifierTls12", + kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + SecurityPrimitives::TlsVersion::V_12, + SecurityPrimitives::ProviderType::FILE_PROVIDER, + SecurityPrimitives::VerifierType::HOSTNAME_VERIFIER); + }, + }, + CoreTestConfiguration{ + // client: static data provider + sync external verifier + // server: static data provider + sync external verifier + // extra: TLS 1.2 + "Chttp2SimpleSslFullstack", + kH2TLSFeatureMask, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + SecurityPrimitives::TlsVersion::V_12, + SecurityPrimitives::ProviderType::STATIC_PROVIDER, + SecurityPrimitives::VerifierType::EXTERNAL_SYNC_VERIFIER); + }, + }, + CoreTestConfiguration{ + // client: static data provider + async external verifier + // server: static data provider + async external verifier + // extra: TLS 1.3 + "Chttp2StaticProviderAsyncVerifierTls13", + kH2TLSFeatureMask | FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + "foo.test.google.fr", + [](const ChannelArgs&, const ChannelArgs&) { + return std::make_unique( + SecurityPrimitives::TlsVersion::V_13, + SecurityPrimitives::ProviderType::STATIC_PROVIDER, + SecurityPrimitives::VerifierType::EXTERNAL_ASYNC_VERIFIER); + }, + }, #ifdef GPR_LINUX - CoreTestConfiguration{ - "Chttp2FullstackUdsAbstractNamespace", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); - return std::make_unique(absl::StrFormat( - "unix-abstract:grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 - ".%" PRId64, - getpid(), now.tv_sec, now.tv_nsec, - unique.fetch_add(1, std::memory_order_relaxed))); - }}, + CoreTestConfiguration{ + "Chttp2FullstackUdsAbstractNamespace", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); + return std::make_unique(absl::StrFormat( + "unix-abstract:grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 + ".%" PRId64, + getpid(), now.tv_sec, now.tv_nsec, + unique.fetch_add(1, std::memory_order_relaxed))); + }}, #endif #ifdef GRPC_HAVE_UNIX_SOCKET - CoreTestConfiguration{ - "Chttp2FullstackUds", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ, - nullptr, - [](const ChannelArgs&, const ChannelArgs&) { - gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); - return std::make_unique(absl::StrFormat( - "unix:%s" - "grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 ".%" PRId64 - ".%" PRId64, - temp_dir, getpid(), now.tv_sec, now.tv_nsec, - unique.fetch_add(1, std::memory_order_relaxed), Rand())); - }}, + CoreTestConfiguration{ + "Chttp2FullstackUds", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ, + nullptr, + [](const ChannelArgs&, const ChannelArgs&) { + gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME); + return std::make_unique(absl::StrFormat( + "unix:%s" + "grpc_fullstack_test.%d.%" PRId64 ".%" PRId32 ".%" PRId64 + ".%" PRId64, + temp_dir, getpid(), now.tv_sec, now.tv_nsec, + unique.fetch_add(1, std::memory_order_relaxed), Rand())); + }}, #endif // TODO(ctiller): these got inadvertently disabled when the project // switched to Bazel in 2016, and have not been re-enabled since and are now @@ -983,30 +972,27 @@ std::vector DefaultConfigs() { }}, #endif #ifdef GRPC_POSIX_WAKEUP_FD - CoreTestConfiguration{ - "Chttp2FullstackWithPipeWakeup", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | - FEATURE_MASK_DO_NOT_FUZZ | - FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, - nullptr, - [](const ChannelArgs& /*client_args*/, - const ChannelArgs& /*server_args*/) { - return std::make_unique(); - }}, -#endif - CoreTestConfiguration { - "ChaoticGoodFullStack", - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | - FEATURE_MASK_DOES_NOT_SUPPORT_RETRY | - FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING | - FEATURE_MASK_IS_CALL_V3, + CoreTestConfiguration{ + "Chttp2FullstackWithPipeWakeup", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | FEATURE_MASK_IS_HTTP2 | + FEATURE_MASK_DO_NOT_FUZZ | + FEATURE_MASK_EXCLUDE_FROM_EXPERIMENT_RUNS, nullptr, [](const ChannelArgs& /*client_args*/, const ChannelArgs& /*server_args*/) { - return std::make_unique(); - } - } - }; + return std::make_unique(); + }}, +#endif + CoreTestConfiguration{"ChaoticGoodFullStack", + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL | + FEATURE_MASK_DOES_NOT_SUPPORT_RETRY | + FEATURE_MASK_DOES_NOT_SUPPORT_WRITE_BUFFERING | + FEATURE_MASK_IS_CALL_V3, + nullptr, + [](const ChannelArgs& /*client_args*/, + const ChannelArgs& /*server_args*/) { + return std::make_unique(); + }}}; } std::vector AllConfigs() { diff --git a/test/core/end2end/h2_ssl_cert_test.cc b/test/core/end2end/h2_ssl_cert_test.cc index 1a674bde544..68173c02155 100644 --- a/test/core/end2end/h2_ssl_cert_test.cc +++ b/test/core/end2end/h2_ssl_cert_test.cc @@ -140,14 +140,12 @@ class TestFixture : public SecureFixture { typedef enum { SUCCESS, FAIL } test_result; -#define SSL_TEST(request_type, cert_type, result) \ - { \ - {TEST_NAME(request_type, cert_type, result), \ - FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | \ - FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL, \ - "foo.test.google.fr", TestFixture::MakeFactory(request_type, cert_type)}, \ - result \ - } +#define SSL_TEST(request_type, cert_type, result) \ + {{TEST_NAME(request_type, cert_type, result), \ + FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS | \ + FEATURE_MASK_SUPPORTS_CLIENT_CHANNEL, \ + "foo.test.google.fr", TestFixture::MakeFactory(request_type, cert_type)}, \ + result} // All test configurations struct CoreTestConfigWrapper { diff --git a/test/core/event_engine/default_engine_methods_test.cc b/test/core/event_engine/default_engine_methods_test.cc index cc110deb842..030be18a504 100644 --- a/test/core/event_engine/default_engine_methods_test.cc +++ b/test/core/event_engine/default_engine_methods_test.cc @@ -69,7 +69,7 @@ class DefaultEngineTest : public testing::Test { const DNSResolver::ResolverOptions& /* options */) override { return nullptr; }; - void Run(Closure* /* closure */) override{}; + void Run(Closure* /* closure */) override {}; void Run(absl::AnyInvocable /* closure */) override{}; TaskHandle RunAfter(Duration /* when */, Closure* /* closure */) override { return {-1, -1}; diff --git a/test/core/event_engine/posix/posix_engine_test_utils.h b/test/core/event_engine/posix/posix_engine_test_utils.h index 0db088b716d..33deec80818 100644 --- a/test/core/event_engine/posix/posix_engine_test_utils.h +++ b/test/core/event_engine/posix/posix_engine_test_utils.h @@ -30,7 +30,7 @@ class TestScheduler : public Scheduler { public: explicit TestScheduler(grpc_event_engine::experimental::EventEngine* engine) : engine_(engine) {} - TestScheduler() : engine_(nullptr){}; + TestScheduler() : engine_(nullptr) {}; void ChangeCurrentEventEngine( grpc_event_engine::experimental::EventEngine* engine) { engine_ = engine; diff --git a/test/core/gprpp/match_test.cc b/test/core/gprpp/match_test.cc index 370a6501564..8df0b69a173 100644 --- a/test/core/gprpp/match_test.cc +++ b/test/core/gprpp/match_test.cc @@ -54,8 +54,7 @@ TEST(MatchTest, TestVoidReturn) { TEST(MatchTest, TestMutable) { absl::variant v = 1.9; - MatchMutable( - &v, [](int*) { abort(); }, [](double* x) { *x = 0.0; }); + MatchMutable(&v, [](int*) { abort(); }, [](double* x) { *x = 0.0; }); EXPECT_EQ(v, (absl::variant(0.0))); } diff --git a/test/core/iomgr/pollset_windows_starvation_test.cc b/test/core/iomgr/pollset_windows_starvation_test.cc index c3e51f5c7cf..ef554e4c468 100644 --- a/test/core/iomgr/pollset_windows_starvation_test.cc +++ b/test/core/iomgr/pollset_windows_starvation_test.cc @@ -112,8 +112,7 @@ int main(int argc, char** argv) { gpr_mu_lock(¶ms.mu); while ( params.queuing != THREADS && - !gpr_cv_wait(¶ms.cv, ¶ms.mu, gpr_inf_future(GPR_CLOCK_REALTIME))) - ; + !gpr_cv_wait(¶ms.cv, ¶ms.mu, gpr_inf_future(GPR_CLOCK_REALTIME))); gpr_mu_unlock(¶ms.mu); // Wait for the mutexes to be released. This indicates that the threads have @@ -133,8 +132,7 @@ int main(int argc, char** argv) { gpr_mu_lock(¶ms.mu); while ( params.complete != THREADS && - !gpr_cv_wait(¶ms.cv, ¶ms.mu, gpr_inf_future(GPR_CLOCK_REALTIME))) - ; + !gpr_cv_wait(¶ms.cv, ¶ms.mu, gpr_inf_future(GPR_CLOCK_REALTIME))); gpr_mu_unlock(¶ms.mu); for (auto& t : threads) t.Join(); diff --git a/test/core/promise/bm_party.cc b/test/core/promise/bm_party.cc index 89ec68d4145..c271a4d240a 100644 --- a/test/core/promise/bm_party.cc +++ b/test/core/promise/bm_party.cc @@ -34,8 +34,7 @@ BENCHMARK(BM_PartyCreate); void BM_AddParticipant(benchmark::State& state) { auto party = Party::Make(SimpleArenaAllocator()->MakeArena()); for (auto _ : state) { - party->Spawn( - "participant", []() { return Success{}; }, [](StatusFlag) {}); + party->Spawn("participant", []() { return Success{}; }, [](StatusFlag) {}); } } BENCHMARK(BM_AddParticipant); diff --git a/test/core/promise/if_test.cc b/test/core/promise/if_test.cc index 9965fa0b893..fb06f23decb 100644 --- a/test/core/promise/if_test.cc +++ b/test/core/promise/if_test.cc @@ -51,15 +51,11 @@ TEST(IfTest, ChooseFailure) { } TEST(IfTest, ImmediateChooseTrue) { - EXPECT_EQ(If( - true, []() { return 1; }, []() { return 2; })(), - Poll(1)); + EXPECT_EQ(If(true, []() { return 1; }, []() { return 2; })(), Poll(1)); } TEST(IfTest, ImmediateChooseFalse) { - EXPECT_EQ(If( - false, []() { return 1; }, []() { return 2; })(), - Poll(2)); + EXPECT_EQ(If(false, []() { return 1; }, []() { return 2; })(), Poll(2)); } } // namespace grpc_core diff --git a/test/core/transport/chttp2/ping_callbacks_test.cc b/test/core/transport/chttp2/ping_callbacks_test.cc index cd75e9673b2..32b02fa0241 100644 --- a/test/core/transport/chttp2/ping_callbacks_test.cc +++ b/test/core/transport/chttp2/ping_callbacks_test.cc @@ -118,9 +118,7 @@ TEST(PingCallbacksTest, PingRoundtrips) { // request EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -198,9 +196,7 @@ TEST(PingCallbacksTest, DuplicatePingIdFlagsError) { EXPECT_FALSE(acked); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -240,9 +236,7 @@ TEST(PingCallbacksTest, OnPingAckCanPiggybackInflightPings) { EXPECT_FALSE(acked_second); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -281,9 +275,7 @@ TEST(PingCallbacksTest, PingAckRoundtrips) { EXPECT_FALSE(acked); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -321,9 +313,7 @@ TEST(PingCallbacksTest, MultiPingRoundtrips) { EXPECT_FALSE(acked2); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id1 = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -348,9 +338,7 @@ TEST(PingCallbacksTest, MultiPingRoundtrips) { EXPECT_FALSE(acked2); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 789}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 789}; }); auto id2 = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -402,9 +390,7 @@ TEST(PingCallbacksTest, MultiPingRoundtripsWithOutOfOrderAcks) { EXPECT_FALSE(acked2); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id1 = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -429,9 +415,7 @@ TEST(PingCallbacksTest, MultiPingRoundtripsWithOutOfOrderAcks) { EXPECT_FALSE(acked2); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 789}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 789}; }); auto id2 = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -492,9 +476,7 @@ TEST(PingCallbacksTest, CoalescedPingsRoundtrip) { EXPECT_FALSE(acked2); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -537,9 +519,7 @@ TEST(PingCallbacksTest, CancelAllCancelsCallbacks) { // Can still send a ping, no callback should be invoked EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); @@ -574,9 +554,7 @@ TEST(PingCallbacksTest, CancelAllCancelsInflightPings) { EXPECT_FALSE(acked); EXPECT_CALL(event_engine, RunAfter(EventEngine::Duration(Duration::Hours(24)), Matcher>(_))) - .WillOnce([]() { - return EventEngine::TaskHandle{123, 456}; - }); + .WillOnce([]() { return EventEngine::TaskHandle{123, 456}; }); auto id = callbacks.StartPing(bitgen); callbacks.OnPingTimeout(Duration::Hours(24), &event_engine, [] { Crash("should not reach here"); }); diff --git a/test/cpp/cocoapods/generic/generic.mm b/test/cpp/cocoapods/generic/generic.mm index e7baa8f4919..138bbe6604c 100644 --- a/test/cpp/cocoapods/generic/generic.mm +++ b/test/cpp/cocoapods/generic/generic.mm @@ -146,10 +146,8 @@ int byte_buffer_eq_string(ByteBuffer* bb, const char* str) { bool ignored_ok; cli_cq_.Shutdown(); srv_cq_->Shutdown(); - while (cli_cq_.Next(&ignored_tag, &ignored_ok)) - ; - while (srv_cq_->Next(&ignored_tag, &ignored_ok)) - ; + while (cli_cq_.Next(&ignored_tag, &ignored_ok)); + while (srv_cq_->Next(&ignored_tag, &ignored_ok)); [super tearDown]; } diff --git a/test/cpp/qps/interarrival.h b/test/cpp/qps/interarrival.h index cea2a731009..3d11b208cba 100644 --- a/test/cpp/qps/interarrival.h +++ b/test/cpp/qps/interarrival.h @@ -87,7 +87,7 @@ class InterarrivalTimer { thread_posns_.push_back(random_table_.begin() + (entries * i) / threads); } } - virtual ~InterarrivalTimer(){}; + virtual ~InterarrivalTimer() {}; int64_t next(int thread_num) { auto ret = *(thread_posns_[thread_num]++); diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc index 16bb01e8960..4d2017dd23e 100644 --- a/test/cpp/qps/server_async.cc +++ b/test/cpp/qps/server_async.cc @@ -238,7 +238,7 @@ class AsyncQpsServerTest final : public grpc::testing::Server { ServerRpcContext() {} void lock() { mu_.lock(); } void unlock() { mu_.unlock(); } - virtual ~ServerRpcContext(){}; + virtual ~ServerRpcContext() {}; virtual bool RunNextState(bool) = 0; // next state, return false if done virtual void Reset() = 0; // start this back at a clean state private: diff --git a/test/cpp/server/server_builder_with_socket_mutator_test.cc b/test/cpp/server/server_builder_with_socket_mutator_test.cc index 3c0bc11d675..e9e148c7793 100644 --- a/test/cpp/server/server_builder_with_socket_mutator_test.cc +++ b/test/cpp/server/server_builder_with_socket_mutator_test.cc @@ -84,7 +84,7 @@ class MockSocketMutatorServerBuilderOption : public grpc::ServerBuilderOption { } void UpdatePlugins( - std::vector>*) override{}; + std::vector>*) override {}; MockSocketMutator* mock_socket_mutator_; }; diff --git a/tools/bazelify_tests/dockerimage_current_versions.bzl b/tools/bazelify_tests/dockerimage_current_versions.bzl index 8954ea56699..bf2a9b9e55b 100644 --- a/tools/bazelify_tests/dockerimage_current_versions.bzl +++ b/tools/bazelify_tests/dockerimage_current_versions.bzl @@ -113,5 +113,5 @@ DOCKERIMAGE_CURRENT_VERSIONS = { "tools/dockerfile/test/rbe_ubuntu2004.current_version": "docker://us-docker.pkg.dev/grpc-testing/testing-images-public/rbe_ubuntu2004@sha256:b3eb1a17b7b091e3c5648a803076b2c40601242ff91c04d55997af6641305f68", "tools/dockerfile/test/ruby_debian11_arm64.current_version": "docker://us-docker.pkg.dev/grpc-testing/testing-images-public/ruby_debian11_arm64@sha256:d2e79919b2e2d4cc36a29682ecb5170641df4fb506cfb453978ffdeb8a841bd9", "tools/dockerfile/test/ruby_debian11_x64.current_version": "docker://us-docker.pkg.dev/grpc-testing/testing-images-public/ruby_debian11_x64@sha256:6e8b4696ba0661f11a31ed0992a94d2efcd889a018f57160f0e2fb62963f3593", - "tools/dockerfile/test/sanity.current_version": "docker://us-docker.pkg.dev/grpc-testing/testing-images-public/sanity@sha256:966aa97475368b6fc308a7e9e584ab471e8c6a47b4a6c9e709c0b1b7d4e2d800", + "tools/dockerfile/test/sanity.current_version": "docker://us-docker.pkg.dev/grpc-testing/testing-images-public/sanity@sha256:4fb77e7130e10934e65ec0657e286a8ca5850e9a25441dabe2174b3cb6a56180", } diff --git a/tools/dockerfile/grpc_clang_format/Dockerfile b/tools/dockerfile/grpc_clang_format/Dockerfile index 736a0ee6deb..70a1bbea16a 100644 --- a/tools/dockerfile/grpc_clang_format/Dockerfile +++ b/tools/dockerfile/grpc_clang_format/Dockerfile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -FROM silkeh/clang:17-bookworm +FROM silkeh/clang:18-bookworm ADD clang_format_all_the_things.sh / diff --git a/tools/dockerfile/grpc_clang_tidy/Dockerfile b/tools/dockerfile/grpc_clang_tidy/Dockerfile index 11e123f6feb..e6121d0c52a 100644 --- a/tools/dockerfile/grpc_clang_tidy/Dockerfile +++ b/tools/dockerfile/grpc_clang_tidy/Dockerfile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -FROM silkeh/clang:17-bookworm +FROM silkeh/clang:18-bookworm # Install prerequisites for the clang-tidy script RUN apt-get update && apt-get install -y python3 jq git && apt-get clean diff --git a/tools/dockerfile/test/sanity.current_version b/tools/dockerfile/test/sanity.current_version index db46fffa969..961e2f353fa 100644 --- a/tools/dockerfile/test/sanity.current_version +++ b/tools/dockerfile/test/sanity.current_version @@ -1 +1 @@ -us-docker.pkg.dev/grpc-testing/testing-images-public/sanity:f21b7692698957bebcd72e8ab5d24c485cb4cbaf@sha256:966aa97475368b6fc308a7e9e584ab471e8c6a47b4a6c9e709c0b1b7d4e2d800 \ No newline at end of file +us-docker.pkg.dev/grpc-testing/testing-images-public/sanity:0006a2ed3aca736f842b3e1bf758cb6ab621922d@sha256:4fb77e7130e10934e65ec0657e286a8ca5850e9a25441dabe2174b3cb6a56180 \ No newline at end of file diff --git a/tools/dockerfile/test/sanity/Dockerfile b/tools/dockerfile/test/sanity/Dockerfile index 0955b9c9df9..841be026ca7 100644 --- a/tools/dockerfile/test/sanity/Dockerfile +++ b/tools/dockerfile/test/sanity/Dockerfile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -FROM silkeh/clang:17-bookworm +FROM silkeh/clang:18-bookworm #================= # Basic C core dependencies @@ -67,13 +67,13 @@ RUN git config --global protocol.file.allow always # (Bullseye comes with Python 3.9 which isn't supported by pytype yet) RUN apt update && apt install -y build-essential zlib1g-dev libncurses5-dev libgdbm-dev \ libnss3-dev libssl-dev libreadline-dev libffi-dev libbz2-dev -RUN curl -O https://www.python.org/ftp/python/3.7.9/Python-3.7.9.tar.xz && \ -tar -xf Python-3.7.9.tar.xz && \ -cd Python-3.7.9 && \ +RUN curl -O https://www.python.org/ftp/python/3.7.17/Python-3.7.17.tar.xz && \ +tar -xf Python-3.7.17.tar.xz && \ +cd Python-3.7.17 && \ ./configure && \ make -j 4 && \ make install -RUN curl https://bootstrap.pypa.io/get-pip.py | python3 +RUN curl https://bootstrap.pypa.io/pip/3.7/get-pip.py | python3 # Google Cloud Platform API libraries # These are needed for uploading test results to BigQuery (e.g. by tools/run_tests scripts)