mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
176 lines
5.8 KiB
176 lines
5.8 KiB
// |
|
// |
|
// Copyright 2015 gRPC authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// http://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
// |
|
// |
|
|
|
#ifndef GRPC_TEST_CORE_END2END_CQ_VERIFIER_H |
|
#define GRPC_TEST_CORE_END2END_CQ_VERIFIER_H |
|
|
|
#include <stdint.h> |
|
|
|
#include <functional> |
|
#include <string> |
|
#include <vector> |
|
|
|
#include "absl/container/flat_hash_map.h" |
|
#include "absl/functional/any_invocable.h" |
|
#include "absl/types/variant.h" |
|
|
|
#include <grpc/event_engine/event_engine.h> |
|
#include <grpc/grpc.h> |
|
#include <grpc/slice.h> |
|
#include <grpc/support/time.h> |
|
|
|
#include "src/core/lib/gprpp/debug_location.h" |
|
#include "src/core/lib/gprpp/time.h" |
|
|
|
namespace grpc_core { |
|
|
|
// A CqVerifier can verify that expected events arrive in a timely fashion |
|
// on a single completion queue |
|
class CqVerifier { |
|
public: |
|
// ExpectedResult - if the tag is received, set *seen to true (if seen is |
|
// non-null). |
|
struct Maybe { |
|
bool* seen = nullptr; |
|
}; |
|
// ExpectedResult - expect the tag, but its result may be true or false. |
|
// Store the result in result (if result is non-null). |
|
struct AnyStatus { |
|
bool* result = nullptr; |
|
}; |
|
// PerformAction - expect the tag, and run a function based on the result |
|
struct PerformAction { |
|
std::function<void(bool success)> action; |
|
}; |
|
// MaybePerformAction - run a function if a tag is seen |
|
struct MaybePerformAction { |
|
std::function<void(bool success)> action; |
|
}; |
|
|
|
using ExpectedResult = |
|
absl::variant<bool, Maybe, AnyStatus, PerformAction, MaybePerformAction>; |
|
|
|
// Captures information about one failure |
|
struct Failure { |
|
SourceLocation location; |
|
std::string message; |
|
std::vector<std::string> expected; |
|
std::vector<std::string> message_details; |
|
}; |
|
|
|
// Produces a string upon the successful (but unexpected) completion of an |
|
// expectation. |
|
class SuccessfulStateString { |
|
public: |
|
virtual std::string GetSuccessfulStateString() = 0; |
|
|
|
protected: |
|
~SuccessfulStateString() = default; |
|
}; |
|
|
|
static void FailUsingGprCrash(const Failure& failure); |
|
static void FailUsingGprCrashWithStdio(const Failure& failure); |
|
static void FailUsingGtestFail(const Failure& failure); |
|
|
|
// Allow customizing the failure handler |
|
// For legacy tests we should use FailUsingGprCrash (the default) |
|
// For gtest based tests we should start migrating to FailUsingGtestFail which |
|
// will produce nicer failure messages. |
|
explicit CqVerifier( |
|
grpc_completion_queue* cq, |
|
absl::AnyInvocable<void(Failure) const> fail = FailUsingGprCrash, |
|
absl::AnyInvocable< |
|
void(grpc_event_engine::experimental::EventEngine::Duration) const> |
|
step_fn = nullptr); |
|
~CqVerifier(); |
|
|
|
CqVerifier(const CqVerifier&) = delete; |
|
CqVerifier& operator=(const CqVerifier&) = delete; |
|
|
|
// Ensure all expected events (and only those events) are present on the |
|
// bound completion queue within \a timeout. |
|
void Verify(Duration timeout = Duration::Seconds(10), |
|
SourceLocation location = SourceLocation()); |
|
|
|
// Ensure that the completion queue is empty, waiting up to \a timeout. |
|
void VerifyEmpty(Duration timeout = Duration::Seconds(1), |
|
SourceLocation location = SourceLocation()); |
|
|
|
void ClearSuccessfulStateStrings(void* tag); |
|
void AddSuccessfulStateString(void* tag, |
|
SuccessfulStateString* successful_state_string); |
|
|
|
// Match an expectation about a status. |
|
// location must be DEBUG_LOCATION. |
|
// result can be any of the types in ExpectedResult - a plain bool means |
|
// 'expect success to be true/false'. |
|
void Expect(void* tag, ExpectedResult result, |
|
SourceLocation location = SourceLocation()); |
|
|
|
std::string ToString() const; |
|
std::vector<std::string> ToStrings() const; |
|
std::string ToShortString() const; |
|
std::vector<std::string> ToShortStrings() const; |
|
|
|
// Logging verifications helps debug CI problems a lot. |
|
// Only disable if the logging prevents a stress test like scenario from |
|
// passing. |
|
void SetLogVerifications(bool log_verifications) { |
|
log_verifications_ = log_verifications; |
|
} |
|
|
|
static void* tag(intptr_t t) { return reinterpret_cast<void*>(t); } |
|
|
|
private: |
|
struct Expectation { |
|
SourceLocation location; |
|
void* tag; |
|
ExpectedResult result; |
|
|
|
std::string ToString() const; |
|
std::string ToShortString() const; |
|
}; |
|
|
|
void FailNoEventReceived(const SourceLocation& location) const; |
|
void FailUnexpectedEvent(grpc_event* ev, |
|
const SourceLocation& location) const; |
|
bool AllMaybes() const; |
|
grpc_event Step(gpr_timespec deadline); |
|
|
|
grpc_completion_queue* const cq_; |
|
std::vector<Expectation> expectations_; |
|
absl::AnyInvocable<void(Failure) const> fail_; |
|
absl::AnyInvocable<void( |
|
grpc_event_engine::experimental::EventEngine::Duration) const> |
|
step_fn_; |
|
absl::flat_hash_map<void*, std::vector<SuccessfulStateString*>> |
|
successful_state_strings_; |
|
bool log_verifications_ = true; |
|
bool added_expectations_ = false; |
|
}; |
|
|
|
} // namespace grpc_core |
|
|
|
int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b); |
|
int byte_buffer_eq_string(grpc_byte_buffer* bb, const char* str); |
|
int contains_metadata(grpc_metadata_array* array, const char* key, |
|
const char* value); |
|
int contains_metadata_slices(grpc_metadata_array* array, grpc_slice key, |
|
grpc_slice value); |
|
|
|
#endif // GRPC_TEST_CORE_END2END_CQ_VERIFIER_H
|
|
|