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.
453 lines
14 KiB
453 lines
14 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. |
|
// |
|
// |
|
|
|
#include "test/core/end2end/cq_verifier.h" |
|
|
|
#include <inttypes.h> |
|
#include <stdio.h> |
|
#include <string.h> |
|
|
|
#include <algorithm> |
|
#include <limits> |
|
#include <string> |
|
#include <utility> |
|
#include <vector> |
|
|
|
#include "absl/log/check.h" |
|
#include "absl/strings/escaping.h" |
|
#include "absl/strings/str_cat.h" |
|
#include "absl/strings/str_format.h" |
|
#include "absl/strings/str_join.h" |
|
#include "absl/strings/string_view.h" |
|
#include "gtest/gtest.h" |
|
|
|
#include <grpc/byte_buffer.h> |
|
#include <grpc/compression.h> |
|
#include <grpc/grpc.h> |
|
#include <grpc/slice.h> |
|
#include <grpc/slice_buffer.h> |
|
#include <grpc/support/log.h> |
|
#include <grpc/support/time.h> |
|
|
|
#include "src/core/lib/compression/message_compress.h" |
|
#include "src/core/lib/gprpp/crash.h" |
|
#include "src/core/lib/gprpp/debug_location.h" |
|
#include "src/core/lib/gprpp/match.h" |
|
#include "src/core/lib/surface/event_string.h" |
|
#include "test/core/test_util/test_config.h" |
|
|
|
// a set of metadata we expect to find on an event |
|
typedef struct metadata { |
|
size_t count; |
|
size_t cap; |
|
char** keys; |
|
char** values; |
|
} metadata; |
|
|
|
static int has_metadata(const grpc_metadata* md, size_t count, const char* key, |
|
const char* value) { |
|
size_t i; |
|
for (i = 0; i < count; i++) { |
|
if (0 == grpc_slice_str_cmp(md[i].key, key) && |
|
0 == grpc_slice_str_cmp(md[i].value, value)) { |
|
return 1; |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
int contains_metadata(grpc_metadata_array* array, const char* key, |
|
const char* value) { |
|
return has_metadata(array->metadata, array->count, key, value); |
|
} |
|
|
|
static int has_metadata_slices(const grpc_metadata* md, size_t count, |
|
grpc_slice key, grpc_slice value) { |
|
size_t i; |
|
for (i = 0; i < count; i++) { |
|
if (grpc_slice_eq(md[i].key, key) && grpc_slice_eq(md[i].value, value)) { |
|
return 1; |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
int contains_metadata_slices(grpc_metadata_array* array, grpc_slice key, |
|
grpc_slice value) { |
|
return has_metadata_slices(array->metadata, array->count, key, value); |
|
} |
|
|
|
static grpc_slice merge_slices(grpc_slice* slices, size_t nslices) { |
|
size_t i; |
|
size_t len = 0; |
|
uint8_t* cursor; |
|
grpc_slice out; |
|
|
|
for (i = 0; i < nslices; i++) { |
|
len += GRPC_SLICE_LENGTH(slices[i]); |
|
} |
|
|
|
out = grpc_slice_malloc(len); |
|
cursor = GRPC_SLICE_START_PTR(out); |
|
|
|
for (i = 0; i < nslices; i++) { |
|
memcpy(cursor, GRPC_SLICE_START_PTR(slices[i]), |
|
GRPC_SLICE_LENGTH(slices[i])); |
|
cursor += GRPC_SLICE_LENGTH(slices[i]); |
|
} |
|
|
|
return out; |
|
} |
|
|
|
int raw_byte_buffer_eq_slice(grpc_byte_buffer* rbb, grpc_slice b) { |
|
grpc_slice a; |
|
int ok; |
|
|
|
if (!rbb) return 0; |
|
|
|
a = merge_slices(rbb->data.raw.slice_buffer.slices, |
|
rbb->data.raw.slice_buffer.count); |
|
ok = GRPC_SLICE_LENGTH(a) == GRPC_SLICE_LENGTH(b) && |
|
0 == memcmp(GRPC_SLICE_START_PTR(a), GRPC_SLICE_START_PTR(b), |
|
GRPC_SLICE_LENGTH(a)); |
|
if (!ok) { |
|
gpr_log(GPR_ERROR, |
|
"SLICE MISMATCH: left_length=%" PRIuPTR " right_length=%" PRIuPTR, |
|
GRPC_SLICE_LENGTH(a), GRPC_SLICE_LENGTH(b)); |
|
std::string out; |
|
const char* a_str = reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(a)); |
|
const char* b_str = reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(b)); |
|
for (size_t i = 0; i < std::max(GRPC_SLICE_LENGTH(a), GRPC_SLICE_LENGTH(b)); |
|
i++) { |
|
if (i >= GRPC_SLICE_LENGTH(a)) { |
|
absl::StrAppend(&out, "\u001b[36m", // cyan |
|
absl::CEscape(absl::string_view(&b_str[i], 1)), |
|
"\u001b[0m"); |
|
} else if (i >= GRPC_SLICE_LENGTH(b)) { |
|
absl::StrAppend(&out, "\u001b[35m", // magenta |
|
absl::CEscape(absl::string_view(&a_str[i], 1)), |
|
"\u001b[0m"); |
|
} else if (a_str[i] == b_str[i]) { |
|
absl::StrAppend(&out, absl::CEscape(absl::string_view(&a_str[i], 1))); |
|
} else { |
|
absl::StrAppend(&out, "\u001b[31m", // red |
|
absl::CEscape(absl::string_view(&a_str[i], 1)), |
|
"\u001b[33m", // yellow |
|
absl::CEscape(absl::string_view(&b_str[i], 1)), |
|
"\u001b[0m"); |
|
} |
|
gpr_log(GPR_ERROR, "%s", out.c_str()); |
|
} |
|
} |
|
grpc_slice_unref(a); |
|
grpc_slice_unref(b); |
|
return ok; |
|
} |
|
|
|
int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b) { |
|
if (bb == nullptr) return 0; |
|
if (bb->data.raw.compression > GRPC_COMPRESS_NONE) { |
|
grpc_slice_buffer decompressed_buffer; |
|
grpc_slice_buffer_init(&decompressed_buffer); |
|
CHECK(grpc_msg_decompress(bb->data.raw.compression, |
|
&bb->data.raw.slice_buffer, |
|
&decompressed_buffer)); |
|
grpc_byte_buffer* rbb = grpc_raw_byte_buffer_create( |
|
decompressed_buffer.slices, decompressed_buffer.count); |
|
int ret_val = raw_byte_buffer_eq_slice(rbb, b); |
|
grpc_byte_buffer_destroy(rbb); |
|
grpc_slice_buffer_destroy(&decompressed_buffer); |
|
return ret_val; |
|
} |
|
return raw_byte_buffer_eq_slice(bb, b); |
|
} |
|
|
|
int byte_buffer_eq_string(grpc_byte_buffer* bb, const char* str) { |
|
return byte_buffer_eq_slice(bb, grpc_slice_from_copied_string(str)); |
|
} |
|
|
|
namespace { |
|
bool IsProbablyInteger(void* p) { |
|
return reinterpret_cast<uintptr_t>(p) < 1000000 || |
|
(reinterpret_cast<uintptr_t>(p) > |
|
std::numeric_limits<uintptr_t>::max() - 10); |
|
} |
|
|
|
std::string TagStr(void* tag) { |
|
if (IsProbablyInteger(tag)) { |
|
return absl::StrFormat("tag(%" PRIdPTR ")", |
|
reinterpret_cast<intptr_t>(tag)); |
|
} else { |
|
return absl::StrFormat("%p", tag); |
|
} |
|
} |
|
} // namespace |
|
|
|
namespace grpc_core { |
|
|
|
CqVerifier::CqVerifier( |
|
grpc_completion_queue* cq, absl::AnyInvocable<void(Failure) const> fail, |
|
absl::AnyInvocable< |
|
void(grpc_event_engine::experimental::EventEngine::Duration) const> |
|
step_fn) |
|
: cq_(cq), fail_(std::move(fail)), step_fn_(std::move(step_fn)) {} |
|
|
|
CqVerifier::~CqVerifier() { Verify(); } |
|
|
|
std::string CqVerifier::Expectation::ToString() const { |
|
return absl::StrCat( |
|
location.file(), ":", location.line(), ": ", TagStr(tag), " ", |
|
Match( |
|
result, |
|
[](bool success) { |
|
return absl::StrCat("success=", success ? "true" : "false"); |
|
}, |
|
[](Maybe) { return std::string("maybe"); }, |
|
[](AnyStatus) { return std::string("any success value"); }, |
|
[](const PerformAction&) { |
|
return std::string("perform some action"); |
|
}, |
|
[](const MaybePerformAction&) { |
|
return std::string("maybe perform action"); |
|
})); |
|
} |
|
|
|
std::string CqVerifier::Expectation::ToShortString() const { |
|
return absl::StrCat( |
|
TagStr(tag), |
|
Match( |
|
result, |
|
[](bool success) -> std::string { |
|
if (!success) return "-❌"; |
|
return "-✅"; |
|
}, |
|
[](Maybe) { return std::string("-❓"); }, |
|
[](AnyStatus) { return std::string("-🤷"); }, |
|
[](const PerformAction&) { return std::string("-🎬"); }, |
|
[](const MaybePerformAction&) { return std::string("-🎬❓"); })); |
|
} |
|
|
|
std::vector<std::string> CqVerifier::ToStrings() const { |
|
std::vector<std::string> expectations; |
|
expectations.reserve(expectations_.size()); |
|
for (const auto& e : expectations_) { |
|
expectations.push_back(e.ToString()); |
|
} |
|
return expectations; |
|
} |
|
|
|
std::string CqVerifier::ToString() const { |
|
return absl::StrJoin(ToStrings(), "\n"); |
|
} |
|
|
|
std::vector<std::string> CqVerifier::ToShortStrings() const { |
|
std::vector<std::string> expectations; |
|
expectations.reserve(expectations_.size()); |
|
for (const auto& e : expectations_) { |
|
expectations.push_back(e.ToShortString()); |
|
} |
|
return expectations; |
|
} |
|
|
|
std::string CqVerifier::ToShortString() const { |
|
return absl::StrJoin(ToShortStrings(), " "); |
|
} |
|
|
|
void CqVerifier::FailNoEventReceived(const SourceLocation& location) const { |
|
fail_(Failure{location, "No event received", ToStrings(), {}}); |
|
} |
|
|
|
void CqVerifier::FailUnexpectedEvent(grpc_event* ev, |
|
const SourceLocation& location) const { |
|
std::vector<std::string> message_details; |
|
if (ev->type == GRPC_OP_COMPLETE && ev->success) { |
|
auto successful_state_strings = successful_state_strings_.find(ev->tag); |
|
if (successful_state_strings != successful_state_strings_.end()) { |
|
for (SuccessfulStateString* sss : successful_state_strings->second) { |
|
message_details.push_back(sss->GetSuccessfulStateString()); |
|
} |
|
} |
|
} |
|
fail_(Failure{location, |
|
absl::StrCat("Unexpected event: ", grpc_event_string(ev)), |
|
ToStrings(), std::move(message_details)}); |
|
} |
|
|
|
namespace { |
|
std::string CrashMessage(const CqVerifier::Failure& failure) { |
|
std::string message = failure.message; |
|
if (!failure.message_details.empty()) { |
|
absl::StrAppend(&message, "\nwith:"); |
|
for (const auto& detail : failure.message_details) { |
|
absl::StrAppend(&message, "\n ", detail); |
|
} |
|
} |
|
absl::StrAppend(&message, "\nchecked @ ", failure.location.file(), ":", |
|
failure.location.line()); |
|
if (!failure.expected.empty()) { |
|
absl::StrAppend(&message, "\nexpected:\n"); |
|
for (const auto& line : failure.expected) { |
|
absl::StrAppend(&message, " ", line, "\n"); |
|
} |
|
} else { |
|
absl::StrAppend(&message, "\nexpected nothing"); |
|
} |
|
return message; |
|
} |
|
} // namespace |
|
|
|
void CqVerifier::FailUsingGprCrashWithStdio(const Failure& failure) { |
|
CrashWithStdio(CrashMessage(failure)); |
|
} |
|
|
|
void CqVerifier::FailUsingGprCrash(const Failure& failure) { |
|
Crash(CrashMessage(failure)); |
|
} |
|
|
|
void CqVerifier::FailUsingGtestFail(const Failure& failure) { |
|
std::string message = absl::StrCat(" ", failure.message); |
|
if (!failure.expected.empty()) { |
|
absl::StrAppend(&message, "\n expected:\n"); |
|
for (const auto& line : failure.expected) { |
|
absl::StrAppend(&message, " ", line, "\n"); |
|
} |
|
} else { |
|
absl::StrAppend(&message, "\n expected nothing"); |
|
} |
|
ADD_FAILURE_AT(failure.location.file(), failure.location.line()) << message; |
|
} |
|
|
|
namespace { |
|
bool IsMaybe(const CqVerifier::ExpectedResult& r) { |
|
return Match( |
|
r, [](bool) { return false; }, [](CqVerifier::Maybe) { return true; }, |
|
[](CqVerifier::AnyStatus) { return false; }, |
|
[](const CqVerifier::PerformAction&) { return false; }, |
|
[](const CqVerifier::MaybePerformAction&) { return true; }); |
|
} |
|
} // namespace |
|
|
|
grpc_event CqVerifier::Step(gpr_timespec deadline) { |
|
if (step_fn_ != nullptr) { |
|
while (true) { |
|
grpc_event r = grpc_completion_queue_next( |
|
cq_, gpr_inf_past(deadline.clock_type), nullptr); |
|
if (r.type != GRPC_QUEUE_TIMEOUT) return r; |
|
auto now = gpr_now(deadline.clock_type); |
|
if (gpr_time_cmp(deadline, now) < 0) break; |
|
step_fn_(Timestamp::FromTimespecRoundDown(deadline) - Timestamp::Now()); |
|
} |
|
return grpc_event{GRPC_QUEUE_TIMEOUT, 0, nullptr}; |
|
} |
|
return grpc_completion_queue_next(cq_, deadline, nullptr); |
|
} |
|
|
|
void CqVerifier::Verify(Duration timeout, SourceLocation location) { |
|
if (expectations_.empty()) return; |
|
bool must_log = true; |
|
const gpr_timespec deadline = |
|
grpc_timeout_milliseconds_to_deadline(timeout.millis()); |
|
while (!expectations_.empty()) { |
|
must_log = std::exchange(added_expectations_, false) || must_log; |
|
if (log_verifications_ && must_log) { |
|
gpr_log(GPR_ERROR, "Verify %s for %s", ToShortString().c_str(), |
|
timeout.ToString().c_str()); |
|
} |
|
must_log = false; |
|
grpc_event ev = Step(deadline); |
|
if (ev.type == GRPC_QUEUE_TIMEOUT) break; |
|
if (ev.type != GRPC_OP_COMPLETE) { |
|
FailUnexpectedEvent(&ev, location); |
|
} |
|
bool found = false; |
|
for (auto it = expectations_.begin(); it != expectations_.end(); ++it) { |
|
if (it->tag != ev.tag) continue; |
|
auto expectation = std::move(*it); |
|
expectations_.erase(it); |
|
const bool expected = Match( |
|
expectation.result, |
|
[ev](bool success) { return ev.success == success; }, |
|
[ev](Maybe m) { |
|
if (m.seen != nullptr) *m.seen = true; |
|
return ev.success != 0; |
|
}, |
|
[ev](AnyStatus a) { |
|
if (a.result != nullptr) *a.result = ev.success; |
|
return true; |
|
}, |
|
[ev](const PerformAction& action) { |
|
action.action(ev.success); |
|
return true; |
|
}, |
|
[ev](const MaybePerformAction& action) { |
|
action.action(ev.success); |
|
return true; |
|
}); |
|
if (!expected) { |
|
FailUnexpectedEvent(&ev, location); |
|
} |
|
found = true; |
|
break; |
|
} |
|
if (!found) FailUnexpectedEvent(&ev, location); |
|
if (AllMaybes()) break; |
|
} |
|
expectations_.erase( |
|
std::remove_if(expectations_.begin(), expectations_.end(), |
|
[](const Expectation& e) { return IsMaybe(e.result); }), |
|
expectations_.end()); |
|
if (!expectations_.empty()) FailNoEventReceived(location); |
|
} |
|
|
|
bool CqVerifier::AllMaybes() const { |
|
for (const auto& e : expectations_) { |
|
if (!IsMaybe(e.result)) return false; |
|
} |
|
return true; |
|
} |
|
|
|
void CqVerifier::VerifyEmpty(Duration timeout, SourceLocation location) { |
|
if (log_verifications_) { |
|
gpr_log(GPR_ERROR, "Verify empty completion queue for %s", |
|
timeout.ToString().c_str()); |
|
} |
|
const gpr_timespec deadline = |
|
gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), timeout.as_timespec()); |
|
CHECK(expectations_.empty()); |
|
grpc_event ev = Step(deadline); |
|
if (ev.type != GRPC_QUEUE_TIMEOUT) { |
|
FailUnexpectedEvent(&ev, location); |
|
} |
|
} |
|
|
|
void CqVerifier::Expect(void* tag, ExpectedResult result, |
|
SourceLocation location) { |
|
added_expectations_ = true; |
|
expectations_.push_back(Expectation{location, tag, std::move(result)}); |
|
} |
|
|
|
void CqVerifier::AddSuccessfulStateString( |
|
void* tag, SuccessfulStateString* successful_state_string) { |
|
successful_state_strings_[tag].push_back(successful_state_string); |
|
} |
|
|
|
void CqVerifier::ClearSuccessfulStateStrings(void* tag) { |
|
successful_state_strings_.erase(tag); |
|
} |
|
|
|
} // namespace grpc_core
|
|
|