diff options
79 files changed, 870 insertions, 726 deletions
diff --git a/pw_file/flat_file_system.cc b/pw_file/flat_file_system.cc index b185b73f2..ce0b8790f 100644 --- a/pw_file/flat_file_system.cc +++ b/pw_file/flat_file_system.cc @@ -37,13 +37,13 @@ namespace pw::file { using Entry = FlatFileSystemService::Entry; Status FlatFileSystemService::EnumerateFile( - Entry& entry, pw::file::ListResponse::StreamEncoder& output_encoder) { + Entry& entry, pwpb::ListResponse::StreamEncoder& output_encoder) { StatusWithSize sws = entry.Name(file_name_buffer_); if (!sws.ok()) { return sws.status(); } { - pw::file::Path::StreamEncoder encoder = output_encoder.GetPathsEncoder(); + pwpb::Path::StreamEncoder encoder = output_encoder.GetPathsEncoder(); encoder .WritePath(reinterpret_cast<const char*>(file_name_buffer_.data()), @@ -60,7 +60,7 @@ void FlatFileSystemService::EnumerateAllFiles(RawServerWriter& writer) { for (Entry* entry : entries_) { PW_DCHECK_NOTNULL(entry); // For now, don't try to pack entries. - pw::file::ListResponse::MemoryEncoder encoder(encoding_buffer_); + pwpb::ListResponse::MemoryEncoder encoder(encoding_buffer_); if (Status status = EnumerateFile(*entry, encoder); !status.ok()) { if (status != Status::NotFound()) { PW_LOG_ERROR("Failed to enumerate file (id: %u) with status %d", @@ -87,7 +87,7 @@ void FlatFileSystemService::List(ConstByteSpan request, // If a file name was provided, try and find and enumerate the file. while (decoder.Next().ok()) { if (decoder.FieldNumber() != - static_cast<uint32_t>(pw::file::ListRequest::Fields::PATH)) { + static_cast<uint32_t>(pwpb::ListRequest::Fields::PATH)) { continue; } @@ -107,7 +107,7 @@ void FlatFileSystemService::List(ConstByteSpan request, return; } - pw::file::ListResponse::MemoryEncoder encoder(encoding_buffer_); + pwpb::ListResponse::MemoryEncoder encoder(encoding_buffer_); Status proto_encode_status = EnumerateFile(*result.value(), encoder); if (!proto_encode_status.ok()) { writer.Finish(proto_encode_status) @@ -129,7 +129,7 @@ void FlatFileSystemService::Delete(ConstByteSpan request, protobuf::Decoder decoder(request); while (decoder.Next().ok()) { if (decoder.FieldNumber() != - static_cast<uint32_t>(pw::file::DeleteRequest::Fields::PATH)) { + static_cast<uint32_t>(pwpb::DeleteRequest::Fields::PATH)) { continue; } diff --git a/pw_file/flat_file_system_test.cc b/pw_file/flat_file_system_test.cc index 470972312..4dc63351b 100644 --- a/pw_file/flat_file_system_test.cc +++ b/pw_file/flat_file_system_test.cc @@ -84,7 +84,7 @@ void ComparePathToEntry(ConstByteSpan serialized_path, protobuf::Decoder decoder(serialized_path); while (decoder.Next().ok()) { switch (decoder.FieldNumber()) { - case static_cast<uint32_t>(pw::file::Path::Fields::PATH): { + case static_cast<uint32_t>(pw::file::pwpb::Path::Fields::PATH): { std::string_view serialized_name; EXPECT_EQ(OkStatus(), decoder.ReadString(&serialized_name)); size_t name_bytes_to_read = @@ -96,7 +96,7 @@ void ComparePathToEntry(ConstByteSpan serialized_path, break; } - case static_cast<uint32_t>(pw::file::Path::Fields::PERMISSIONS): { + case static_cast<uint32_t>(pw::file::pwpb::Path::Fields::PERMISSIONS): { uint32_t seralized_permissions; EXPECT_EQ(OkStatus(), decoder.ReadUint32(&seralized_permissions)); EXPECT_EQ(static_cast<uint32_t>(entry->Permissions()), @@ -104,7 +104,7 @@ void ComparePathToEntry(ConstByteSpan serialized_path, break; } - case static_cast<uint32_t>(pw::file::Path::Fields::SIZE_BYTES): { + case static_cast<uint32_t>(pw::file::pwpb::Path::Fields::SIZE_BYTES): { uint32_t serialized_file_size; EXPECT_EQ(OkStatus(), decoder.ReadUint32(&serialized_file_size)); EXPECT_EQ(static_cast<uint32_t>(entry->SizeBytes()), @@ -112,7 +112,7 @@ void ComparePathToEntry(ConstByteSpan serialized_path, break; } - case static_cast<uint32_t>(pw::file::Path::Fields::FILE_ID): { + case static_cast<uint32_t>(pw::file::pwpb::Path::Fields::FILE_ID): { uint32_t serialized_file_id; EXPECT_EQ(OkStatus(), decoder.ReadUint32(&serialized_file_id)); EXPECT_EQ(static_cast<uint32_t>(entry->FileId()), serialized_file_id); @@ -136,7 +136,7 @@ size_t ValidateExpectedPaths( protobuf::Decoder decoder(response); while (decoder.Next().ok()) { constexpr uint32_t kListResponsePathsFieldNumber = - static_cast<uint32_t>(pw::file::ListResponse::Fields::PATHS); + static_cast<uint32_t>(pw::file::pwpb::ListResponse::Fields::PATHS); EXPECT_EQ(decoder.FieldNumber(), kListResponsePathsFieldNumber); if (decoder.FieldNumber() != kListResponsePathsFieldNumber) { return 0; diff --git a/pw_file/public/pw_file/flat_file_system.h b/pw_file/public/pw_file/flat_file_system.h index c0152a833..88d2f3ac5 100644 --- a/pw_file/public/pw_file/flat_file_system.h +++ b/pw_file/public/pw_file/flat_file_system.h @@ -38,7 +38,7 @@ class FlatFileSystemService public: class Entry { public: - using FilePermissions = pw::file::Path::Permissions; + using FilePermissions = ::pw::file::pwpb::Path::Permissions; using Id = uint32_t; Entry() = default; @@ -79,7 +79,7 @@ class FlatFileSystemService size_t minimum_entries = 1) { return minimum_entries * protobuf::SizeOfDelimitedField( - ListResponse::Fields::PATHS, + pwpb::ListResponse::Fields::PATHS, EncodedPathProtoSizeBytes(max_file_name_length)); } @@ -113,19 +113,19 @@ class FlatFileSystemService // Returns the maximum size of a single encoded Path proto. static constexpr size_t EncodedPathProtoSizeBytes( size_t max_file_name_length) { - return protobuf::SizeOfFieldString(Path::Fields::PATH, + return protobuf::SizeOfFieldString(pwpb::Path::Fields::PATH, max_file_name_length) + - protobuf::SizeOfFieldEnum(Path::Fields::PERMISSIONS, - Path::Permissions::READ_AND_WRITE) + - protobuf::SizeOfFieldUint32(Path::Fields::SIZE_BYTES) + - protobuf::SizeOfFieldUint32(Path::Fields::FILE_ID); + protobuf::SizeOfFieldEnum(pwpb::Path::Fields::PERMISSIONS, + pwpb::Path::Permissions::READ_AND_WRITE) + + protobuf::SizeOfFieldUint32(pwpb::Path::Fields::SIZE_BYTES) + + protobuf::SizeOfFieldUint32(pwpb::Path::Fields::FILE_ID); } Result<Entry*> FindFile(std::string_view file_name); Status FindAndDeleteFile(std::string_view file_name); Status EnumerateFile(Entry& entry, - pw::file::ListResponse::StreamEncoder& output_encoder); + pwpb::ListResponse::StreamEncoder& output_encoder); void EnumerateAllFiles(RawServerWriter& writer); const span<std::byte> encoding_buffer_; diff --git a/pw_log/proto_utils.cc b/pw_log/proto_utils.cc index 6ca31fbc5..55c77e22d 100644 --- a/pw_log/proto_utils.cc +++ b/pw_log/proto_utils.cc @@ -34,7 +34,7 @@ Result<ConstByteSpan> EncodeLog(int level, std::string_view message, ByteSpan encode_buffer) { // Encode message to the LogEntry protobuf. - LogEntry::MemoryEncoder encoder(encode_buffer); + pwpb::LogEntry::MemoryEncoder encoder(encode_buffer); if (message.empty()) { return Status::InvalidArgument(); @@ -62,13 +62,13 @@ Result<ConstByteSpan> EncodeLog(int level, return ConstByteSpan(encoder); } -LogEntry::MemoryEncoder CreateEncoderAndEncodeTokenizedLog( +pwpb::LogEntry::MemoryEncoder CreateEncoderAndEncodeTokenizedLog( pw::log_tokenized::Metadata metadata, ConstByteSpan tokenized_data, int64_t ticks_since_epoch, ByteSpan encode_buffer) { // Encode message to the LogEntry protobuf. - LogEntry::MemoryEncoder encoder(encode_buffer); + pwpb::LogEntry::MemoryEncoder encoder(encode_buffer); // Defer status checks until the end. Status status = encoder.WriteMessage(tokenized_data); diff --git a/pw_log/proto_utils_test.cc b/pw_log/proto_utils_test.cc index b928c4555..6b6fa8b10 100644 --- a/pw_log/proto_utils_test.cc +++ b/pw_log/proto_utils_test.cc @@ -32,7 +32,7 @@ void VerifyTokenizedLogEntry(pw::protobuf::Decoder& entry_decoder, ConstByteSpan tokenized_data; EXPECT_TRUE(entry_decoder.Next().ok()); // message [tokenized] EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::MESSAGE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::MESSAGE)); EXPECT_TRUE(entry_decoder.ReadBytes(&tokenized_data).ok()); EXPECT_TRUE(std::memcmp(tokenized_data.data(), expected_tokenized_data.data(), @@ -41,7 +41,7 @@ void VerifyTokenizedLogEntry(pw::protobuf::Decoder& entry_decoder, uint32_t line_level; EXPECT_TRUE(entry_decoder.Next().ok()); // line_level EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::LINE_LEVEL)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::LINE_LEVEL)); EXPECT_TRUE(entry_decoder.ReadUint32(&line_level).ok()); uint32_t line_number; @@ -54,7 +54,7 @@ void VerifyTokenizedLogEntry(pw::protobuf::Decoder& entry_decoder, uint32_t flags; EXPECT_TRUE(entry_decoder.Next().ok()); // flags EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::FLAGS)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::FLAGS)); EXPECT_TRUE(entry_decoder.ReadUint32(&flags).ok()); EXPECT_EQ(expected_metadata.flags(), flags); } @@ -63,16 +63,17 @@ void VerifyTokenizedLogEntry(pw::protobuf::Decoder& entry_decoder, EXPECT_TRUE(entry_decoder.Next().ok()); // timestamp EXPECT_TRUE( entry_decoder.FieldNumber() == - static_cast<uint32_t>(log::LogEntry::Fields::TIMESTAMP) || + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::TIMESTAMP) || entry_decoder.FieldNumber() == - static_cast<uint32_t>(log::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); + static_cast<uint32_t>( + log::pwpb::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); EXPECT_TRUE(entry_decoder.ReadInt64(×tamp).ok()); EXPECT_EQ(expected_timestamp, timestamp); if (expected_metadata.module() != 0) { EXPECT_TRUE(entry_decoder.Next().ok()); // module name EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::MODULE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::MODULE)); const Result<uint32_t> module = protobuf::DecodeBytesToUint32(entry_decoder); ASSERT_TRUE(module.ok()); @@ -83,7 +84,7 @@ void VerifyTokenizedLogEntry(pw::protobuf::Decoder& entry_decoder, ConstByteSpan tokenized_thread_name; EXPECT_TRUE(entry_decoder.Next().ok()); // thread [tokenized] EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::THREAD)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::THREAD)); EXPECT_TRUE(entry_decoder.ReadBytes(&tokenized_thread_name).ok()); EXPECT_TRUE(std::memcmp(tokenized_thread_name.data(), expected_thread_name.data(), @@ -103,14 +104,14 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, std::string_view message; EXPECT_TRUE(entry_decoder.Next().ok()); // message EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::MESSAGE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::MESSAGE)); EXPECT_TRUE(entry_decoder.ReadString(&message).ok()); EXPECT_TRUE(pw::containers::Equal(message, expected_message)); uint32_t line_level; EXPECT_TRUE(entry_decoder.Next().ok()); // line_level EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::LINE_LEVEL)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::LINE_LEVEL)); EXPECT_TRUE(entry_decoder.ReadUint32(&line_level).ok()); uint32_t line_number; uint8_t level; @@ -122,7 +123,7 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, uint32_t flags; EXPECT_TRUE(entry_decoder.Next().ok()); // flags EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::FLAGS)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::FLAGS)); EXPECT_TRUE(entry_decoder.ReadUint32(&flags).ok()); EXPECT_EQ(expected_flags, flags); } @@ -131,9 +132,10 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, EXPECT_TRUE(entry_decoder.Next().ok()); // timestamp EXPECT_TRUE( entry_decoder.FieldNumber() == - static_cast<uint32_t>(log::LogEntry::Fields::TIMESTAMP) || + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::TIMESTAMP) || entry_decoder.FieldNumber() == - static_cast<uint32_t>(log::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); + static_cast<uint32_t>( + log::pwpb::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); EXPECT_TRUE(entry_decoder.ReadInt64(×tamp).ok()); EXPECT_EQ(expected_ticks_since_epoch, timestamp); @@ -141,7 +143,7 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, std::string_view module_name; EXPECT_TRUE(entry_decoder.Next().ok()); // module EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::MODULE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::MODULE)); EXPECT_TRUE(entry_decoder.ReadString(&module_name).ok()); EXPECT_TRUE(pw::containers::Equal(module_name, expected_module)); } @@ -150,7 +152,7 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, std::string_view file_name; EXPECT_TRUE(entry_decoder.Next().ok()); // file EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::FILE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::FILE)); EXPECT_TRUE(entry_decoder.ReadString(&file_name).ok()); EXPECT_TRUE(pw::containers::Equal(file_name, expected_file_name)); } @@ -159,7 +161,7 @@ void VerifyLogEntry(pw::protobuf::Decoder& entry_decoder, std::string_view thread_name; EXPECT_TRUE(entry_decoder.Next().ok()); // file EXPECT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::THREAD)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::THREAD)); EXPECT_TRUE(entry_decoder.ReadString(&thread_name).ok()); EXPECT_TRUE(pw::containers::Equal(thread_name, expected_thread_name)); } diff --git a/pw_log/public/pw_log/proto_utils.h b/pw_log/public/pw_log/proto_utils.h index c6d3e34c5..e6d390d58 100644 --- a/pw_log/public/pw_log/proto_utils.h +++ b/pw_log/public/pw_log/proto_utils.h @@ -65,7 +65,7 @@ Result<ConstByteSpan> EncodeLog(int level, // Encodes tokenized message and metadata, with a timestamp as a log proto. // Extra fields can be encoded into the returned encoder. The caller must check // the encoder status. -LogEntry::MemoryEncoder CreateEncoderAndEncodeTokenizedLog( +pwpb::LogEntry::MemoryEncoder CreateEncoderAndEncodeTokenizedLog( log_tokenized::Metadata metadata, ConstByteSpan tokenized_data, int64_t ticks_since_epoch, @@ -83,7 +83,7 @@ inline Result<ConstByteSpan> EncodeTokenizedLog( ConstByteSpan tokenized_data, int64_t ticks_since_epoch, ByteSpan encode_buffer) { - LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( + pwpb::LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( metadata, tokenized_data, ticks_since_epoch, encode_buffer); PW_TRY(encoder.status()); return ConstByteSpan(encoder); @@ -115,7 +115,7 @@ inline Result<ConstByteSpan> EncodeTokenizedLog( int64_t ticks_since_epoch, ConstByteSpan thread_name, ByteSpan encode_buffer) { - LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( + pwpb::LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( metadata, as_bytes(span(tokenized_data, tokenized_data_size)), ticks_since_epoch, @@ -140,7 +140,7 @@ inline Result<ConstByteSpan> EncodeTokenizedLog( int64_t ticks_since_epoch, ConstByteSpan thread_name, ByteSpan encode_buffer) { - LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( + pwpb::LogEntry::MemoryEncoder encoder = CreateEncoderAndEncodeTokenizedLog( metadata, tokenized_data, ticks_since_epoch, encode_buffer); if (!thread_name.empty()) { encoder.WriteThread(thread_name).IgnoreError(); diff --git a/pw_log_rpc/log_filter.cc b/pw_log_rpc/log_filter.cc index 95fc1e5e2..bef10b13b 100644 --- a/pw_log_rpc/log_filter.cc +++ b/pw_log_rpc/log_filter.cc @@ -21,6 +21,9 @@ namespace pw::log_rpc { namespace { +namespace FilterRule = ::pw::log::pwpb::FilterRule; +namespace LogEntry = ::pw::log::pwpb::LogEntry; + // Returns true if the provided log parameters match the given filter rule. bool IsRuleMet(const Filter::Rule& rule, uint32_t level, @@ -68,13 +71,12 @@ Status Filter::UpdateRulesFromProto(ConstByteSpan buffer) { PW_TRY(decoder.ReadBytes(&rule_buffer)); protobuf::Decoder rule_decoder(rule_buffer); while ((status = rule_decoder.Next()).ok()) { - switch ( - static_cast<log::FilterRule::Fields>(rule_decoder.FieldNumber())) { - case log::FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL: + switch (static_cast<FilterRule::Fields>(rule_decoder.FieldNumber())) { + case FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL: PW_TRY(rule_decoder.ReadUint32(reinterpret_cast<uint32_t*>( &rules_[i].level_greater_than_or_equal))); break; - case log::FilterRule::Fields::MODULE_EQUALS: { + case FilterRule::Fields::MODULE_EQUALS: { ConstByteSpan module; PW_TRY(rule_decoder.ReadBytes(&module)); if (module.size() > rules_[i].module_equals.max_size()) { @@ -82,14 +84,14 @@ Status Filter::UpdateRulesFromProto(ConstByteSpan buffer) { } rules_[i].module_equals.assign(module.begin(), module.end()); } break; - case log::FilterRule::Fields::ANY_FLAGS_SET: + case FilterRule::Fields::ANY_FLAGS_SET: PW_TRY(rule_decoder.ReadUint32(&rules_[i].any_flags_set)); break; - case log::FilterRule::Fields::ACTION: + case FilterRule::Fields::ACTION: PW_TRY(rule_decoder.ReadUint32( reinterpret_cast<uint32_t*>(&rules_[i].action))); break; - case log::FilterRule::Fields::THREAD_EQUALS: { + case FilterRule::Fields::THREAD_EQUALS: { ConstByteSpan thread; PW_TRY(rule_decoder.ReadBytes(&thread)); if (thread.size() > rules_[i].thread_equals.max_size()) { @@ -114,21 +116,20 @@ bool Filter::ShouldDropLog(ConstByteSpan entry) const { uint32_t log_flags = 0; protobuf::Decoder decoder(entry); while (decoder.Next().ok()) { - const auto field_num = - static_cast<log::LogEntry::Fields>(decoder.FieldNumber()); + const auto field_num = static_cast<LogEntry::Fields>(decoder.FieldNumber()); - if (field_num == log::LogEntry::Fields::LINE_LEVEL) { + if (field_num == LogEntry::Fields::LINE_LEVEL) { if (decoder.ReadUint32(&log_level).ok()) { log_level &= PW_LOG_LEVEL_BITMASK; } - } else if (field_num == log::LogEntry::Fields::MODULE) { + } else if (field_num == LogEntry::Fields::MODULE) { decoder.ReadBytes(&log_module).IgnoreError(); - } else if (field_num == log::LogEntry::Fields::FLAGS) { + } else if (field_num == LogEntry::Fields::FLAGS) { decoder.ReadUint32(&log_flags).IgnoreError(); - } else if (field_num == log::LogEntry::Fields::THREAD) { + } else if (field_num == LogEntry::Fields::THREAD) { decoder.ReadBytes(&log_thread).IgnoreError(); } } diff --git a/pw_log_rpc/log_filter_service.cc b/pw_log_rpc/log_filter_service.cc index 2d8b63c7b..770042760 100644 --- a/pw_log_rpc/log_filter_service.cc +++ b/pw_log_rpc/log_filter_service.cc @@ -20,11 +20,15 @@ namespace pw::log_rpc { +namespace GetFilterRequest = ::pw::log::pwpb::GetFilterRequest; +namespace SetFilterRequest = ::pw::log::pwpb::SetFilterRequest; +namespace FilterRule = ::pw::log::pwpb::FilterRule; + Status FilterService::SetFilterImpl(ConstByteSpan request) { protobuf::Decoder decoder(request); PW_TRY(decoder.Next()); - if (static_cast<log::SetFilterRequest::Fields>(decoder.FieldNumber()) != - log::SetFilterRequest::Fields::FILTER_ID) { + if (static_cast<SetFilterRequest::Fields>(decoder.FieldNumber()) != + SetFilterRequest::Fields::FILTER_ID) { return Status::InvalidArgument(); } ConstByteSpan filter_id; @@ -36,8 +40,8 @@ Status FilterService::SetFilterImpl(ConstByteSpan request) { PW_TRY(decoder.Next()); ConstByteSpan filter_buffer; - if (static_cast<log::SetFilterRequest::Fields>(decoder.FieldNumber()) != - log::SetFilterRequest::Fields::FILTER) { + if (static_cast<SetFilterRequest::Fields>(decoder.FieldNumber()) != + SetFilterRequest::Fields::FILTER) { return Status::InvalidArgument(); } PW_TRY(decoder.ReadBytes(&filter_buffer)); @@ -49,8 +53,8 @@ StatusWithSize FilterService::GetFilterImpl(ConstByteSpan request, ByteSpan response) { protobuf::Decoder decoder(request); PW_TRY_WITH_SIZE(decoder.Next()); - if (static_cast<log::GetFilterRequest::Fields>(decoder.FieldNumber()) != - log::GetFilterRequest::Fields::FILTER_ID) { + if (static_cast<GetFilterRequest::Fields>(decoder.FieldNumber()) != + GetFilterRequest::Fields::FILTER_ID) { return StatusWithSize::InvalidArgument(); } ConstByteSpan filter_id; @@ -60,14 +64,14 @@ StatusWithSize FilterService::GetFilterImpl(ConstByteSpan request, return StatusWithSize::NotFound(); } - log::Filter::MemoryEncoder encoder(response); + log::pwpb::Filter::MemoryEncoder encoder(response); for (auto& rule : (*filter)->rules()) { - log::FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); + FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); rule_encoder.WriteLevelGreaterThanOrEqual(rule.level_greater_than_or_equal) .IgnoreError(); rule_encoder.WriteModuleEquals(rule.module_equals).IgnoreError(); rule_encoder.WriteAnyFlagsSet(rule.any_flags_set).IgnoreError(); - rule_encoder.WriteAction(static_cast<log::FilterRule::Action>(rule.action)) + rule_encoder.WriteAction(static_cast<FilterRule::Action>(rule.action)) .IgnoreError(); rule_encoder.WriteThreadEquals(rule.thread_equals).IgnoreError(); PW_TRY_WITH_SIZE(rule_encoder.status()); @@ -78,7 +82,7 @@ StatusWithSize FilterService::GetFilterImpl(ConstByteSpan request, } StatusWithSize FilterService::ListFilterIdsImpl(ByteSpan response) { - log::FilterIdListResponse::MemoryEncoder encoder(response); + log::pwpb::FilterIdListResponse::MemoryEncoder encoder(response); for (auto& filter : filter_map_.filters()) { PW_TRY_WITH_SIZE(encoder.WriteFilterId(filter.id())); } diff --git a/pw_log_rpc/log_filter_service_test.cc b/pw_log_rpc/log_filter_service_test.cc index 8e30d5c78..8a3d0a2bb 100644 --- a/pw_log_rpc/log_filter_service_test.cc +++ b/pw_log_rpc/log_filter_service_test.cc @@ -32,6 +32,10 @@ namespace pw::log_rpc { namespace { +namespace FilterRule = ::pw::log::pwpb::FilterRule; +namespace GetFilterRequest = ::pw::log::pwpb::GetFilterRequest; +namespace SetFilterRequest = ::pw::log::pwpb::SetFilterRequest; + class FilterServiceTest : public ::testing::Test { public: FilterServiceTest() : filter_map_(filters_) {} @@ -94,18 +98,19 @@ TEST_F(FilterServiceTest, GetFilterIds) { } Status EncodeFilterRule(const Filter::Rule& rule, - log::FilterRule::StreamEncoder& encoder) { + FilterRule::StreamEncoder& encoder) { PW_TRY( encoder.WriteLevelGreaterThanOrEqual(rule.level_greater_than_or_equal)); PW_TRY(encoder.WriteModuleEquals(rule.module_equals)); PW_TRY(encoder.WriteAnyFlagsSet(rule.any_flags_set)); PW_TRY(encoder.WriteThreadEquals(rule.thread_equals)); - return encoder.WriteAction(static_cast<log::FilterRule::Action>(rule.action)); + return encoder.WriteAction(static_cast<FilterRule::Action>(rule.action)); } -Status EncodeFilter(const Filter& filter, log::Filter::StreamEncoder& encoder) { +Status EncodeFilter(const Filter& filter, + log::pwpb::Filter::StreamEncoder& encoder) { for (auto& rule : filter.rules()) { - log::FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); + FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); PW_TRY(EncodeFilterRule(rule, rule_encoder)); } return OkStatus(); @@ -117,11 +122,10 @@ Result<ConstByteSpan> EncodeFilterRequest(const Filter& filter, std::byte encode_buffer[256]; protobuf::StreamEncoder encoder(writer, encode_buffer); PW_TRY(encoder.WriteBytes( - static_cast<uint32_t>(log::SetFilterRequest::Fields::FILTER_ID), - filter.id())); + static_cast<uint32_t>(SetFilterRequest::Fields::FILTER_ID), filter.id())); { - log::Filter::StreamEncoder filter_encoder = encoder.GetNestedEncoder( - static_cast<uint32_t>(log::SetFilterRequest::Fields::FILTER)); + log::pwpb::Filter::StreamEncoder filter_encoder = encoder.GetNestedEncoder( + static_cast<uint32_t>(SetFilterRequest::Fields::FILTER)); PW_TRY(EncodeFilter(filter, filter_encoder)); } // Let the StreamEncoder destructor finalize the data. return ConstByteSpan(writer.data(), writer.bytes_written()); @@ -140,21 +144,21 @@ TEST_F(FilterServiceTest, SetFilterRules) { const std::array<Filter::Rule, kMaxFilterRules> new_rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL, .any_flags_set = 0x0f, .module_equals{std::byte(123)}, .thread_equals{std::byte('L'), std::byte('O'), std::byte('G')}, }, { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0x1234, .module_equals{std::byte(99)}, .thread_equals{std::byte('P'), @@ -165,7 +169,7 @@ TEST_F(FilterServiceTest, SetFilterRules) { }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals{std::byte(4)}, .thread_equals{std::byte('P'), @@ -198,7 +202,7 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) { const std::array<Filter::Rule, kMaxFilterRules> new_filter_rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::CRITICAL_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::CRITICAL_LEVEL, .any_flags_set = 0xfd, .module_equals{std::byte(543)}, .thread_equals{std::byte('M'), @@ -209,14 +213,14 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) { }, { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xca, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0xabcd, .module_equals{std::byte(9000)}, .thread_equals{std::byte('P'), @@ -227,7 +231,7 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) { }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals{std::byte(123)}, .thread_equals{std::byte('P'), @@ -271,28 +275,28 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) { const std::array<Filter::Rule, kMaxFilterRules> second_filter_rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL, .any_flags_set = 0xab, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0x11, .module_equals{std::byte(34)}, .thread_equals{std::byte('L'), std::byte('O'), std::byte('G')}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{std::byte(23)}, .thread_equals{std::byte('R'), std::byte('P'), std::byte('C')}, }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0x0f, .module_equals{}, .thread_equals{std::byte('R'), std::byte('P'), std::byte('C')}, @@ -321,10 +325,10 @@ TEST_F(FilterServiceTest, SetFilterRulesWhenUsedByDrain) { void VerifyFilterRule(protobuf::Decoder& decoder, const Filter::Rule& expected_rule) { ASSERT_TRUE(decoder.Next().ok()); - ASSERT_EQ(decoder.FieldNumber(), - static_cast<uint32_t>( - log::FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL)); - log::FilterRule::Level level_greater_than_or_equal; + ASSERT_EQ( + decoder.FieldNumber(), + static_cast<uint32_t>(FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL)); + FilterRule::Level level_greater_than_or_equal; ASSERT_EQ(decoder.ReadUint32( reinterpret_cast<uint32_t*>(&level_greater_than_or_equal)), OkStatus()); @@ -333,7 +337,7 @@ void VerifyFilterRule(protobuf::Decoder& decoder, ASSERT_TRUE(decoder.Next().ok()); ASSERT_EQ(decoder.FieldNumber(), - static_cast<uint32_t>(log::FilterRule::Fields::MODULE_EQUALS)); + static_cast<uint32_t>(FilterRule::Fields::MODULE_EQUALS)); ConstByteSpan module_equals; ASSERT_EQ(decoder.ReadBytes(&module_equals), OkStatus()); ASSERT_EQ(module_equals.size(), expected_rule.module_equals.size()); @@ -344,14 +348,14 @@ void VerifyFilterRule(protobuf::Decoder& decoder, ASSERT_TRUE(decoder.Next().ok()); ASSERT_EQ(decoder.FieldNumber(), - static_cast<uint32_t>(log::FilterRule::Fields::ANY_FLAGS_SET)); + static_cast<uint32_t>(FilterRule::Fields::ANY_FLAGS_SET)); uint32_t any_flags_set; ASSERT_EQ(decoder.ReadUint32(&any_flags_set), OkStatus()); EXPECT_EQ(any_flags_set, expected_rule.any_flags_set); ASSERT_TRUE(decoder.Next().ok()); ASSERT_EQ(decoder.FieldNumber(), - static_cast<uint32_t>(log::FilterRule::Fields::ACTION)); + static_cast<uint32_t>(FilterRule::Fields::ACTION)); Filter::Rule::Action action; ASSERT_EQ(decoder.ReadUint32(reinterpret_cast<uint32_t*>(&action)), OkStatus()); @@ -359,7 +363,7 @@ void VerifyFilterRule(protobuf::Decoder& decoder, ASSERT_TRUE(decoder.Next().ok()); ASSERT_EQ(decoder.FieldNumber(), - static_cast<uint32_t>(log::FilterRule::Fields::THREAD_EQUALS)); + static_cast<uint32_t>(FilterRule::Fields::THREAD_EQUALS)); ConstByteSpan thread; ASSERT_EQ(decoder.ReadBytes(&thread), OkStatus()); ASSERT_EQ(thread.size(), expected_rule.thread_equals.size()); @@ -390,7 +394,7 @@ TEST_F(FilterServiceTest, GetFilterRules) { context(filter_map_); std::byte request_buffer[64]; - log::GetFilterRequest::MemoryEncoder encoder(request_buffer); + GetFilterRequest::MemoryEncoder encoder(request_buffer); ASSERT_EQ(OkStatus(), encoder.WriteFilterId(filter_id1_)); const auto request = ConstByteSpan(encoder); context.call(request); @@ -404,7 +408,7 @@ TEST_F(FilterServiceTest, GetFilterRules) { // Partially populate rules. rules1_[0].action = Filter::Rule::Action::kKeep; - rules1_[0].level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL; + rules1_[0].level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL; rules1_[0].any_flags_set = 0xab; const std::array<std::byte, 2> module1{std::byte(123), std::byte(0xab)}; rules1_[0].module_equals.assign(module1.begin(), module1.end()); @@ -412,7 +416,7 @@ TEST_F(FilterServiceTest, GetFilterRules) { std::byte('H'), std::byte('O'), std::byte('S'), std::byte('T')}; rules1_[0].thread_equals.assign(thread1.begin(), thread1.end()); rules1_[1].action = Filter::Rule::Action::kDrop; - rules1_[1].level_greater_than_or_equal = log::FilterRule::Level::ERROR_LEVEL; + rules1_[1].level_greater_than_or_equal = FilterRule::Level::ERROR_LEVEL; rules1_[1].any_flags_set = 0; PW_RAW_TEST_METHOD_CONTEXT(FilterService, GetFilter, 1) @@ -425,7 +429,7 @@ TEST_F(FilterServiceTest, GetFilterRules) { // Modify the rest of the filter rules. rules1_[2].action = Filter::Rule::Action::kKeep; - rules1_[2].level_greater_than_or_equal = log::FilterRule::Level::FATAL_LEVEL; + rules1_[2].level_greater_than_or_equal = FilterRule::Level::FATAL_LEVEL; rules1_[2].any_flags_set = 0xcd; const std::array<std::byte, 2> module2{std::byte(1), std::byte(2)}; rules1_[2].module_equals.assign(module2.begin(), module2.end()); diff --git a/pw_log_rpc/log_filter_test.cc b/pw_log_rpc/log_filter_test.cc index f43a35aef..fea7ce08f 100644 --- a/pw_log_rpc/log_filter_test.cc +++ b/pw_log_rpc/log_filter_test.cc @@ -33,6 +33,8 @@ namespace pw::log_rpc { namespace { +namespace FilterRule = ::pw::log::pwpb::FilterRule; + constexpr uint32_t kSampleModule = 0x1234; constexpr uint32_t kSampleFlags = 0x3; const std::array<std::byte, cfg::kMaxThreadNameBytes - 7> kSampleThread = { @@ -55,19 +57,19 @@ Result<ConstByteSpan> EncodeLogEntry(std::string_view message, } Status EncodeFilterRule(const Filter::Rule& rule, - log::FilterRule::StreamEncoder& encoder) { + FilterRule::StreamEncoder& encoder) { PW_TRY( encoder.WriteLevelGreaterThanOrEqual(rule.level_greater_than_or_equal)); PW_TRY(encoder.WriteModuleEquals(rule.module_equals)); PW_TRY(encoder.WriteAnyFlagsSet(rule.any_flags_set)); PW_TRY(encoder.WriteThreadEquals(rule.thread_equals)); - return encoder.WriteAction(static_cast<log::FilterRule::Action>(rule.action)); + return encoder.WriteAction(static_cast<FilterRule::Action>(rule.action)); } Result<ConstByteSpan> EncodeFilter(const Filter& filter, ByteSpan buffer) { - log::Filter::MemoryEncoder encoder(buffer); + log::pwpb::Filter::MemoryEncoder encoder(buffer); for (auto& rule : filter.rules()) { - log::FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); + FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); PW_TRY(EncodeFilterRule(rule, rule_encoder)); } return ConstByteSpan(encoder); @@ -130,28 +132,28 @@ TEST(Filter, UpdateFilterRules) { const std::array<Filter::Rule, 4> new_rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL, .any_flags_set = 0x0f, .module_equals{std::byte(123)}, .thread_equals{}, }, { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{}, .thread_equals{std::byte('L'), std::byte('O'), std::byte('G')}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0x1234, .module_equals{std::byte(99)}, .thread_equals{}, }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals{std::byte(4)}, .thread_equals{std::byte('P'), @@ -183,7 +185,7 @@ TEST(Filter, UpdateFilterRules) { EXPECT_EQ(filter.UpdateRulesFromProto(encode_result.value()), OkStatus()); const Filter::Rule empty_rule{ .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals{}, .thread_equals{}, @@ -197,14 +199,14 @@ TEST(Filter, UpdateFilterRules) { const std::array<Filter::Rule, 2> few_rules{{ { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0x1234, .module_equals{std::byte(99)}, .thread_equals{std::byte('P'), @@ -233,7 +235,7 @@ TEST(Filter, UpdateFilterRules) { const std::array<Filter::Rule, 6> extra_rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL, .any_flags_set = 0x0f, .module_equals{std::byte(123)}, .thread_equals{std::byte('P'), @@ -244,35 +246,35 @@ TEST(Filter, UpdateFilterRules) { }, { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kInactive, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0xef, .module_equals{}, .thread_equals{}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0x1234, .module_equals{std::byte(99)}, .thread_equals{std::byte('L'), std::byte('O'), std::byte('G')}, }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals{std::byte(4)}, .thread_equals{std::byte('L'), std::byte('O'), std::byte('G')}, }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = 0x1234, .module_equals{std::byte('M'), std::byte('0'), @@ -303,7 +305,7 @@ TEST(FilterTest, FilterLogsRuleDefaultDrop) { const std::array<Filter::Rule, 2> rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals{kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -312,7 +314,7 @@ TEST(FilterTest, FilterLogsRuleDefaultDrop) { // This rule catches all logs. { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, .any_flags_set = 0, .module_equals = {}, .thread_equals{}, @@ -387,7 +389,7 @@ TEST(FilterTest, FilterLogsKeepLogsWhenNoRuleMatches) { const std::array<Filter::Rule, 1> rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -519,7 +521,7 @@ TEST(FilterTest, FilterLogsFirstRuleWins) { const std::array<Filter::Rule, 2> rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -527,7 +529,7 @@ TEST(FilterTest, FilterLogsFirstRuleWins) { }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -537,7 +539,7 @@ TEST(FilterTest, FilterLogsFirstRuleWins) { const std::array<Filter::Rule, 2> rules_reversed{{ { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -545,7 +547,7 @@ TEST(FilterTest, FilterLogsFirstRuleWins) { }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -576,7 +578,7 @@ TEST(FilterTest, DropFilterRuleDueToThreadName) { const std::array<Filter::Rule, 2> rules{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -584,7 +586,7 @@ TEST(FilterTest, DropFilterRuleDueToThreadName) { }, { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -595,7 +597,7 @@ TEST(FilterTest, DropFilterRuleDueToThreadName) { const std::array<Filter::Rule, 2> drop_rule{{ { .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -647,7 +649,7 @@ TEST(FilterTest, UpdateFilterWithLargeThreadNamePasses) { const std::array<Filter::Rule, 2> rule{{ { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -656,7 +658,7 @@ TEST(FilterTest, UpdateFilterWithLargeThreadNamePasses) { }, { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -680,7 +682,7 @@ TEST(FilterTest, UpdateFilterWithLargeThreadNamePasses) { TEST(FilterTest, UpdateFilterWithLargeThreadNameFails) { const std::array<Filter::Rule, 1> rule_with_more_than_ten_bytes{{{ .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = kSampleFlags, .module_equals = {kSampleModuleLittleEndian.begin(), kSampleModuleLittleEndian.end()}, @@ -692,7 +694,7 @@ TEST(FilterTest, UpdateFilterWithLargeThreadNameFails) { filter_id, const_cast<std::array<Filter::Rule, 1>&>(rule_with_more_than_ten_bytes)); std::byte buffer[256]; - log::Filter::MemoryEncoder encoder(buffer); + log::pwpb::Filter::MemoryEncoder encoder(buffer); { std::array<const std::byte, cfg::kMaxThreadNameBytes + 1> kThreadNameLongerThanAllowed = { @@ -709,7 +711,7 @@ TEST(FilterTest, UpdateFilterWithLargeThreadNameFails) { std::byte('S'), }; // Stream encoder writes to the buffer when it goes out of scope. - log::FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); + FilterRule::StreamEncoder rule_encoder = encoder.GetRuleEncoder(); ASSERT_EQ(rule_encoder.WriteThreadEquals(kThreadNameLongerThanAllowed), OkStatus()); } diff --git a/pw_log_rpc/log_service_test.cc b/pw_log_rpc/log_service_test.cc index f7eee9ce8..e201e2382 100644 --- a/pw_log_rpc/log_service_test.cc +++ b/pw_log_rpc/log_service_test.cc @@ -41,6 +41,8 @@ namespace { using log::pw_rpc::raw::Logs; +namespace FilterRule = log::pwpb::FilterRule; + #define LOG_SERVICE_METHOD_CONTEXT \ PW_RAW_TEST_METHOD_CONTEXT(LogService, Listen, 10) @@ -325,7 +327,7 @@ TEST_F(LogServiceTest, HandleDroppedBetweenFilteredOutLogs) { context.set_channel_id(drain_channel_id); // Set filter to drop INFO+ and keep DEBUG logs rules1_[0].action = Filter::Rule::Action::kDrop; - rules1_[0].level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL; + rules1_[0].level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL; // Add log entries. const size_t total_entries = 5; @@ -472,7 +474,7 @@ TEST_F(LogServiceTest, LargeLogEntry) { }; // Add entry to multisink. - log::LogEntry::MemoryEncoder encoder(entry_encode_buffer_); + log::pwpb::LogEntry::MemoryEncoder encoder(entry_encode_buffer_); ASSERT_EQ(encoder.WriteMessage(expected_entry.tokenized_data), OkStatus()); ASSERT_EQ(encoder.WriteLineLevel( (expected_entry.metadata.level() & PW_LOG_LEVEL_BITMASK) | @@ -801,25 +803,24 @@ TEST_F(LogServiceTest, FilterLogs) { bytes::CopyInOrder<uint32_t>(endian::little, module); rules2_[0] = { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = flags, .module_equals{module_little_endian.begin(), module_little_endian.end()}, .thread_equals{kSampleThread.begin(), kSampleThread.end()}}; rules2_[1] = { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::DEBUG_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::DEBUG_LEVEL, .any_flags_set = flags, .module_equals{module_little_endian.begin(), module_little_endian.end()}, .thread_equals{kNewThread.begin(), kNewThread.end()}}; - rules2_[2] = { - .action = Filter::Rule::Action::kDrop, - .level_greater_than_or_equal = log::FilterRule::Level::ANY_LEVEL, - .any_flags_set = 0, - .module_equals{}, - .thread_equals{}}; + rules2_[2] = {.action = Filter::Rule::Action::kDrop, + .level_greater_than_or_equal = FilterRule::Level::ANY_LEVEL, + .any_flags_set = 0, + .module_equals{}, + .thread_equals{}}; rules2_[3] = { .action = Filter::Rule::Action::kKeep, - .level_greater_than_or_equal = log::FilterRule::Level::INFO_LEVEL, + .level_greater_than_or_equal = FilterRule::Level::INFO_LEVEL, .any_flags_set = flags, .module_equals{module_little_endian.begin(), module_little_endian.end()}, .thread_equals{kNewThread.begin(), kNewThread.end()}}; diff --git a/pw_log_rpc/public/pw_log_rpc/log_filter.h b/pw_log_rpc/public/pw_log_rpc/log_filter.h index d9fc91c23..dc0a7daf2 100644 --- a/pw_log_rpc/public/pw_log_rpc/log_filter.h +++ b/pw_log_rpc/public/pw_log_rpc/log_filter.h @@ -42,8 +42,8 @@ class Filter { // Checks if the log level is greater or equal to this value when it // does not equal NOT_SET. - log::FilterRule::Level level_greater_than_or_equal = - log::FilterRule::Level::ANY_LEVEL; + log::pwpb::FilterRule::Level level_greater_than_or_equal = + log::pwpb::FilterRule::Level::ANY_LEVEL; // Checks if the log entry has any flag is set when it doesn't equal 0. uint32_t any_flags_set = 0; diff --git a/pw_log_rpc/public/pw_log_rpc/log_filter_service.h b/pw_log_rpc/public/pw_log_rpc/log_filter_service.h index 9ebec1d0b..b47355edd 100644 --- a/pw_log_rpc/public/pw_log_rpc/log_filter_service.h +++ b/pw_log_rpc/public/pw_log_rpc/log_filter_service.h @@ -52,23 +52,25 @@ class FilterService final static constexpr size_t kMinSupportedFilters = 4; static constexpr size_t kFilterResponseBufferSize = - protobuf::TagSizeBytes(log::Filter::Fields::RULE) + + protobuf::TagSizeBytes(log::pwpb::Filter::Fields::RULE) + protobuf::kMaxSizeOfLength + kMinSupportedFilters * (protobuf::SizeOfFieldEnum( - log::FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL, 7) + - protobuf::SizeOfFieldBytes(log::FilterRule::Fields::MODULE_EQUALS, - cfg::kMaxModuleNameBytes) + - protobuf::SizeOfFieldUint32(log::FilterRule::Fields::ANY_FLAGS_SET, - 1) + - protobuf::SizeOfFieldEnum(log::FilterRule::Fields::ACTION, 2) + - protobuf::SizeOfFieldBytes(log::FilterRule::Fields::THREAD_EQUALS, - cfg::kMaxThreadNameBytes)); + log::pwpb::FilterRule::Fields::LEVEL_GREATER_THAN_OR_EQUAL, 7) + + protobuf::SizeOfFieldBytes( + log::pwpb::FilterRule::Fields::MODULE_EQUALS, + cfg::kMaxModuleNameBytes) + + protobuf::SizeOfFieldUint32( + log::pwpb::FilterRule::Fields::ANY_FLAGS_SET, 1) + + protobuf::SizeOfFieldEnum(log::pwpb::FilterRule::Fields::ACTION, 2) + + protobuf::SizeOfFieldBytes( + log::pwpb::FilterRule::Fields::THREAD_EQUALS, + cfg::kMaxThreadNameBytes)); static constexpr size_t kFilterIdsResponseBufferSize = kMinSupportedFilters * - protobuf::SizeOfFieldBytes(log::FilterIdListResponse::Fields::FILTER_ID, - 4); + protobuf::SizeOfFieldBytes( + log::pwpb::FilterIdListResponse::Fields::FILTER_ID, 4); Status SetFilterImpl(ConstByteSpan request); StatusWithSize GetFilterImpl(ConstByteSpan request, ByteSpan response); diff --git a/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h b/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h index a35dd79ff..c62a17987 100644 --- a/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h +++ b/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h @@ -40,15 +40,16 @@ namespace pw::log_rpc { // RpcLogDrain matches a MultiSink::Drain with with an RPC channel's writer. A // RPC channel ID identifies this drain. The user must attach this drain -// to a MultiSink that returns a log::LogEntry, and provide a buffer large -// enough to hold the largest log::LogEntry transmittable. The user must call -// Flush(), which, on every call, packs as many log::LogEntry items as possible -// into a log::LogEntries message, writes the message to the provided writer, -// then repeats the process until there are no more entries in the MultiSink or -// the writer failed to write the outgoing package and error_handling is set to -// `kCloseStreamOnWriterError`. When error_handling is `kIgnoreWriterErrors` the -// drain will continue to retrieve log entries out of the MultiSink and attempt -// to send them out ignoring the writer errors without sending a drop count. +// to a MultiSink that returns a log::pwpb::LogEntry, and provide a buffer large +// enough to hold the largest log::pwpb::LogEntry transmittable. The user must +// call Flush(), which, on every call, packs as many log::pwpb::LogEntry items +// as possible into a log::pwpb::LogEntries message, writes the message to the +// provided writer, then repeats the process until there are no more entries in +// the MultiSink or the writer failed to write the outgoing package and +// error_handling is set to `kCloseStreamOnWriterError`. When error_handling is +// `kIgnoreWriterErrors` the drain will continue to retrieve log entries out of +// the MultiSink and attempt to send them out ignoring the writer errors without +// sending a drop count. // Note: the error handling and drop count reporting might change in the future. // Log filtering is done using the rules of the Filter provided if any. class RpcLogDrain : public multisink::MultiSink::Drain { @@ -60,17 +61,18 @@ class RpcLogDrain : public multisink::MultiSink::Drain { }; // The minimum buffer size, without the message payload or module sizes, - // needed to retrieve a log::LogEntry from the attached MultiSink. The user - // must account for the max message size to avoid log entry drops. The dropped - // field is not accounted since a dropped message has all other fields unset. + // needed to retrieve a log::pwpb::LogEntry from the attached MultiSink. The + // user must account for the max message size to avoid log entry drops. The + // dropped field is not accounted since a dropped message has all other fields + // unset. static constexpr size_t kMinEntrySizeWithoutPayload = - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MESSAGE, 0) + - protobuf::SizeOfFieldUint32(log::LogEntry::Fields::LINE_LEVEL) + - protobuf::SizeOfFieldUint32(log::LogEntry::Fields::FLAGS) + - protobuf::SizeOfFieldInt64(log::LogEntry::Fields::TIMESTAMP) + - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MODULE, 0) + - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::FILE, 0) + - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::THREAD, 0); + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::MESSAGE, 0) + + protobuf::SizeOfFieldUint32(log::pwpb::LogEntry::Fields::LINE_LEVEL) + + protobuf::SizeOfFieldUint32(log::pwpb::LogEntry::Fields::FLAGS) + + protobuf::SizeOfFieldInt64(log::pwpb::LogEntry::Fields::TIMESTAMP) + + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::MODULE, 0) + + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::FILE, 0) + + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::THREAD, 0); // Error messages sent when logs are dropped. static constexpr std::string_view kIngressErrorMessage{ @@ -99,14 +101,14 @@ class RpcLogDrain : public multisink::MultiSink::Drain { // bytes added to the encoded LogEntry. This constant and kMinEntryBufferSize // can be used to calculate the minimum RPC ChannelOutput buffer size. static constexpr size_t kLogEntriesEncodeFrameSize = - protobuf::TagSizeBytes(log::LogEntries::Fields::ENTRIES) + + protobuf::TagSizeBytes(log::pwpb::LogEntries::Fields::ENTRIES) + protobuf::kMaxSizeOfLength + protobuf::SizeOfFieldUint32( - log::LogEntries::Fields::FIRST_ENTRY_SEQUENCE_ID); + log::pwpb::LogEntries::Fields::FIRST_ENTRY_SEQUENCE_ID); // Creates a closed log stream with a writer that can be set at a later time. // The provided buffer must be large enough to hold the largest transmittable - // log::LogEntry or a drop count message at the very least. The user can + // log::pwpb::LogEntry or a drop count message at the very least. The user can // choose to provide a unique mutex for the drain, or share it to save RAM as // long as they are aware of contengency issues. RpcLogDrain( @@ -210,9 +212,9 @@ class RpcLogDrain : public multisink::MultiSink::Drain { Status& encoding_status) PW_LOCKS_EXCLUDED(mutex_); // Fills the outgoing buffer with as many entries as possible. - LogDrainState EncodeOutgoingPacket(log::LogEntries::MemoryEncoder& encoder, - uint32_t& packed_entry_count_out) - PW_EXCLUSIVE_LOCKS_REQUIRED(mutex_); + LogDrainState EncodeOutgoingPacket( + log::pwpb::LogEntries::MemoryEncoder& encoder, + uint32_t& packed_entry_count_out) PW_EXCLUSIVE_LOCKS_REQUIRED(mutex_); const uint32_t channel_id_; const LogDrainErrorHandling error_handling_; diff --git a/pw_log_rpc/rpc_log_drain.cc b/pw_log_rpc/rpc_log_drain.cc index 4b85e99ea..e5905a612 100644 --- a/pw_log_rpc/rpc_log_drain.cc +++ b/pw_log_rpc/rpc_log_drain.cc @@ -33,12 +33,13 @@ namespace { // Creates an encoded drop message on the provided buffer and adds it to the // bulk log entries. Resets the drop count when successfull. -void TryEncodeDropMessage(ByteSpan encoded_drop_message_buffer, - std::string_view reason, - uint32_t& drop_count, - log::LogEntries::MemoryEncoder& entries_encoder) { +void TryEncodeDropMessage( + ByteSpan encoded_drop_message_buffer, + std::string_view reason, + uint32_t& drop_count, + log::pwpb::LogEntries::MemoryEncoder& entries_encoder) { // Encode drop count and reason, if any, in log proto. - log::LogEntry::MemoryEncoder encoder(encoded_drop_message_buffer); + log::pwpb::LogEntry::MemoryEncoder encoder(encoded_drop_message_buffer); if (!reason.empty()) { encoder.WriteMessage(as_bytes(span<const char>(reason))).IgnoreError(); } @@ -51,7 +52,8 @@ void TryEncodeDropMessage(ByteSpan encoded_drop_message_buffer, if (drop_message.size() + RpcLogDrain::kLogEntriesEncodeFrameSize < entries_encoder.ConservativeWriteLimit()) { PW_CHECK_OK(entries_encoder.WriteBytes( - static_cast<uint32_t>(log::LogEntries::Fields::ENTRIES), drop_message)); + static_cast<uint32_t>(log::pwpb::LogEntries::Fields::ENTRIES), + drop_message)); drop_count = 0; } } @@ -113,7 +115,7 @@ RpcLogDrain::LogDrainState RpcLogDrain::SendLogs(size_t max_num_bundles, // No reason to keep polling this drain until the writer is opened. return LogDrainState::kCaughtUp; } - log::LogEntries::MemoryEncoder encoder(encoding_buffer); + log::pwpb::LogEntries::MemoryEncoder encoder(encoding_buffer); uint32_t packed_entry_count = 0; log_sink_state = EncodeOutgoingPacket(encoder, packed_entry_count); @@ -141,7 +143,8 @@ RpcLogDrain::LogDrainState RpcLogDrain::SendLogs(size_t max_num_bundles, } RpcLogDrain::LogDrainState RpcLogDrain::EncodeOutgoingPacket( - log::LogEntries::MemoryEncoder& encoder, uint32_t& packed_entry_count_out) { + log::pwpb::LogEntries::MemoryEncoder& encoder, + uint32_t& packed_entry_count_out) { const size_t total_buffer_size = encoder.ConservativeWriteLimit(); do { // Peek entry and get drop count from multisink. @@ -245,7 +248,7 @@ RpcLogDrain::LogDrainState RpcLogDrain::EncodeOutgoingPacket( // Encode the entry and remove it from multisink. PW_CHECK_OK(encoder.WriteBytes( - static_cast<uint32_t>(log::LogEntries::Fields::ENTRIES), + static_cast<uint32_t>(log::pwpb::LogEntries::Fields::ENTRIES), possible_entry.value().entry())); PW_CHECK_OK(PopEntry(possible_entry.value())); ++packed_entry_count_out; diff --git a/pw_log_rpc/rpc_log_drain_test.cc b/pw_log_rpc/rpc_log_drain_test.cc index 97b3eedf6..580b82cfb 100644 --- a/pw_log_rpc/rpc_log_drain_test.cc +++ b/pw_log_rpc/rpc_log_drain_test.cc @@ -244,18 +244,18 @@ class TrickleTest : public ::testing::Test { static constexpr uint64_t kSampleTimestamp = 9000; static constexpr std::string_view kSampleThreadName = "thread"; static constexpr size_t kBasicLogSizeWithoutPayload = - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MESSAGE, 0) + + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::MESSAGE, 0) + protobuf::SizeOfFieldUint32( - log::LogEntry::Fields::LINE_LEVEL, + log::pwpb::LogEntry::Fields::LINE_LEVEL, log::PackLineLevel(kSampleMetadata.line_number(), kSampleMetadata.level())) + - protobuf::SizeOfFieldUint32(log::LogEntry::Fields::FLAGS, + protobuf::SizeOfFieldUint32(log::pwpb::LogEntry::Fields::FLAGS, kSampleMetadata.flags()) + - protobuf::SizeOfFieldInt64(log::LogEntry::Fields::TIMESTAMP, + protobuf::SizeOfFieldInt64(log::pwpb::LogEntry::Fields::TIMESTAMP, kSampleTimestamp) + - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MODULE, + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::MODULE, sizeof(kSampleMetadata.module())) + - protobuf::SizeOfFieldBytes(log::LogEntry::Fields::THREAD, + protobuf::SizeOfFieldBytes(log::pwpb::LogEntry::Fields::THREAD, kSampleThreadName.size()); static constexpr size_t kDrainEncodeBufferSize = kBasicLogSizeWithoutPayload + kMaxMessageSize; diff --git a/pw_log_rpc/test_utils.cc b/pw_log_rpc/test_utils.cc index 4831d5894..09ab6d401 100644 --- a/pw_log_rpc/test_utils.cc +++ b/pw_log_rpc/test_utils.cc @@ -28,7 +28,7 @@ namespace pw::log_rpc { namespace { void VerifyOptionallyTokenizedField(protobuf::Decoder& entry_decoder, - log::LogEntry::Fields field_number, + log::pwpb::LogEntry::Fields field_number, ConstByteSpan expected_data) { if (expected_data.empty()) { return; @@ -53,12 +53,12 @@ void VerifyLogEntry(protobuf::Decoder& entry_decoder, const TestLogEntry& expected_entry, uint32_t& drop_count_out) { VerifyOptionallyTokenizedField(entry_decoder, - log::LogEntry::Fields::MESSAGE, + log::pwpb::LogEntry::Fields::MESSAGE, expected_entry.tokenized_data); if (expected_entry.metadata.level()) { ASSERT_EQ(entry_decoder.Next(), OkStatus()); ASSERT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::LINE_LEVEL)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::LINE_LEVEL)); uint32_t line_level; ASSERT_TRUE(entry_decoder.ReadUint32(&line_level).ok()); EXPECT_EQ(expected_entry.metadata.level(), @@ -69,18 +69,19 @@ void VerifyLogEntry(protobuf::Decoder& entry_decoder, if (expected_entry.metadata.flags()) { ASSERT_EQ(entry_decoder.Next(), OkStatus()); ASSERT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::FLAGS)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::FLAGS)); uint32_t flags; ASSERT_TRUE(entry_decoder.ReadUint32(&flags).ok()); EXPECT_EQ(expected_entry.metadata.flags(), flags); } if (expected_entry.timestamp) { ASSERT_EQ(entry_decoder.Next(), OkStatus()); - ASSERT_TRUE(entry_decoder.FieldNumber() == - static_cast<uint32_t>(log::LogEntry::Fields::TIMESTAMP) || - entry_decoder.FieldNumber() == - static_cast<uint32_t>( - log::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); + ASSERT_TRUE( + entry_decoder.FieldNumber() == + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::TIMESTAMP) || + entry_decoder.FieldNumber() == + static_cast<uint32_t>( + log::pwpb::LogEntry::Fields::TIME_SINCE_LAST_ENTRY)); int64_t timestamp; ASSERT_TRUE(entry_decoder.ReadInt64(×tamp).ok()); EXPECT_EQ(expected_entry.timestamp, timestamp); @@ -88,7 +89,7 @@ void VerifyLogEntry(protobuf::Decoder& entry_decoder, if (expected_entry.dropped) { ASSERT_EQ(entry_decoder.Next(), OkStatus()); ASSERT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::DROPPED)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::DROPPED)); uint32_t dropped = 0; ASSERT_TRUE(entry_decoder.ReadUint32(&dropped).ok()); EXPECT_EQ(expected_entry.dropped, dropped); @@ -97,16 +98,17 @@ void VerifyLogEntry(protobuf::Decoder& entry_decoder, if (expected_entry.metadata.module()) { ASSERT_EQ(entry_decoder.Next(), OkStatus()); ASSERT_EQ(entry_decoder.FieldNumber(), - static_cast<uint32_t>(log::LogEntry::Fields::MODULE)); + static_cast<uint32_t>(log::pwpb::LogEntry::Fields::MODULE)); const Result<uint32_t> module = protobuf::DecodeBytesToUint32(entry_decoder); ASSERT_EQ(module.status(), OkStatus()); EXPECT_EQ(expected_entry.metadata.module(), module.value()); } VerifyOptionallyTokenizedField( - entry_decoder, log::LogEntry::Fields::FILE, expected_entry.file); - VerifyOptionallyTokenizedField( - entry_decoder, log::LogEntry::Fields::THREAD, expected_entry.thread); + entry_decoder, log::pwpb::LogEntry::Fields::FILE, expected_entry.file); + VerifyOptionallyTokenizedField(entry_decoder, + log::pwpb::LogEntry::Fields::THREAD, + expected_entry.thread); } // Compares an encoded LogEntry's fields against the expected sequence ID and @@ -120,9 +122,9 @@ void VerifyLogEntries(protobuf::Decoder& entries_decoder, uint32_t& drop_count_out) { size_t entry_index = entries_count_out; while (entries_decoder.Next().ok()) { - if (static_cast<pw::log::LogEntries::Fields>( + if (static_cast<log::pwpb::LogEntries::Fields>( entries_decoder.FieldNumber()) == - log::LogEntries::Fields::ENTRIES) { + log::pwpb::LogEntries::Fields::ENTRIES) { ConstByteSpan entry; EXPECT_EQ(entries_decoder.ReadBytes(&entry), OkStatus()); protobuf::Decoder entry_decoder(entry); @@ -141,9 +143,9 @@ void VerifyLogEntries(protobuf::Decoder& entries_decoder, if (current_drop_count == 0) { ++entries_count_out; } - } else if (static_cast<pw::log::LogEntries::Fields>( + } else if (static_cast<log::pwpb::LogEntries::Fields>( entries_decoder.FieldNumber()) == - log::LogEntries::Fields::FIRST_ENTRY_SEQUENCE_ID) { + log::pwpb::LogEntries::Fields::FIRST_ENTRY_SEQUENCE_ID) { uint32_t first_entry_sequence_id = 0; EXPECT_EQ(entries_decoder.ReadUint32(&first_entry_sequence_id), OkStatus()); @@ -155,9 +157,9 @@ void VerifyLogEntries(protobuf::Decoder& entries_decoder, size_t CountLogEntries(protobuf::Decoder& entries_decoder) { size_t entries_found = 0; while (entries_decoder.Next().ok()) { - if (static_cast<pw::log::LogEntries::Fields>( + if (static_cast<log::pwpb::LogEntries::Fields>( entries_decoder.FieldNumber()) == - log::LogEntries::Fields::ENTRIES) { + log::pwpb::LogEntries::Fields::ENTRIES) { ++entries_found; } } diff --git a/pw_metric/metric_service_pwpb.cc b/pw_metric/metric_service_pwpb.cc index 5a222f0c7..b52b6a1e5 100644 --- a/pw_metric/metric_service_pwpb.cc +++ b/pw_metric/metric_service_pwpb.cc @@ -49,7 +49,8 @@ class PwpbMetricWriter : public virtual internal::MetricWriter { { // Scope to control proto_encoder lifetime. // Grab the next available Metric slot to write to in the response. - proto::Metric::StreamEncoder proto_encoder = encoder_.GetMetricsEncoder(); + proto::pwpb::Metric::StreamEncoder proto_encoder = + encoder_.GetMetricsEncoder(); PW_TRY(proto_encoder.WriteTokenPath(path)); // Encode the metric value. if (metric.is_float()) { @@ -74,7 +75,7 @@ class PwpbMetricWriter : public virtual internal::MetricWriter { // Different way to clear MemoryEncoder. Copy constructor is disabled // for memory encoder, and there is no "clear()" method. encoder_.~MemoryEncoder(); - new (&encoder_) proto::MetricRequest::MemoryEncoder(response_); + new (&encoder_) proto::pwpb::MetricRequest::MemoryEncoder(response_); metrics_count = 0; } return status; @@ -85,7 +86,7 @@ class PwpbMetricWriter : public virtual internal::MetricWriter { // This RPC stream writer handle must be valid for the metric writer // lifetime. rpc::RawServerWriter& response_writer_; - proto::MetricRequest::MemoryEncoder encoder_; + proto::pwpb::MetricRequest::MemoryEncoder encoder_; size_t metrics_count = 0; }; } // namespace @@ -95,8 +96,8 @@ void MetricService::Get(ConstByteSpan /*request*/, // For now, ignore the request and just stream all the metrics back. // TODO(amontanez): Make this follow the metric_service.options configuration. constexpr size_t kSizeOfOneMetric = - pw::metric::proto::MetricResponse::kMaxEncodedSizeBytes + - pw::metric::proto::Metric::kMaxEncodedSizeBytes; + pw::metric::proto::pwpb::MetricResponse::kMaxEncodedSizeBytes + + pw::metric::proto::pwpb::Metric::kMaxEncodedSizeBytes; constexpr size_t kEncodeBufferSize = kMaxNumPackedEntries * kSizeOfOneMetric; std::array<std::byte, kEncodeBufferSize> encode_buffer; diff --git a/pw_metric/metric_service_pwpb_test.cc b/pw_metric/metric_service_pwpb_test.cc index e256ba873..7d0b5077e 100644 --- a/pw_metric/metric_service_pwpb_test.cc +++ b/pw_metric/metric_service_pwpb_test.cc @@ -34,7 +34,7 @@ size_t CountEncodedMetrics(ConstByteSpan serialized_path) { while (decoder.Next().ok()) { switch (decoder.FieldNumber()) { case static_cast<uint32_t>( - pw::metric::proto::MetricResponse::Fields::METRICS): { + pw::metric::proto::pwpb::MetricResponse::Fields::METRICS): { num_metrics++; } } @@ -47,7 +47,8 @@ size_t SumMetricInts(ConstByteSpan serialized_path) { size_t metrics_sum = 0; while (decoder.Next().ok()) { switch (decoder.FieldNumber()) { - case static_cast<uint32_t>(pw::metric::proto::Metric::Fields::AS_INT): { + case static_cast<uint32_t>( + pw::metric::proto::pwpb::Metric::Fields::AS_INT): { uint32_t metric_value; EXPECT_EQ(OkStatus(), decoder.ReadUint32(&metric_value)); metrics_sum += metric_value; @@ -63,7 +64,7 @@ size_t GetMetricsSum(ConstByteSpan serialized_metric_buffer) { while (decoder.Next().ok()) { switch (decoder.FieldNumber()) { case static_cast<uint32_t>( - pw::metric::proto::MetricResponse::Fields::METRICS): { + pw::metric::proto::pwpb::MetricResponse::Fields::METRICS): { ConstByteSpan metric_buffer; EXPECT_EQ(OkStatus(), decoder.ReadBytes(&metric_buffer)); metrics_sum += SumMetricInts(metric_buffer); diff --git a/pw_protobuf/codegen_decoder_test.cc b/pw_protobuf/codegen_decoder_test.cc index 4082070d9..78f69111a 100644 --- a/pw_protobuf/codegen_decoder_test.cc +++ b/pw_protobuf/codegen_decoder_test.cc @@ -39,7 +39,20 @@ namespace pw::protobuf { namespace { -using namespace pw::protobuf::test; +using test::pwpb::Bool; +using test::pwpb::Enum; + +namespace DeviceInfo = test::pwpb::DeviceInfo; +namespace KeyValuePair = test::pwpb::KeyValuePair; +namespace Pigweed = test::pwpb::Pigweed; +namespace Proto = test::pwpb::Proto; +namespace RepeatedTest = test::pwpb::RepeatedTest; +namespace TestResult = test::pwpb::TestResult; + +namespace imported { +using ::pw::protobuf::test::imported::pwpb::IsValidStatus; +using ::pw::protobuf::test::imported::pwpb::Status; +} // namespace imported TEST(Codegen, StreamDecoder) { // clang-format off diff --git a/pw_protobuf/codegen_encoder_test.cc b/pw_protobuf/codegen_encoder_test.cc index 49f036217..e6645a94e 100644 --- a/pw_protobuf/codegen_encoder_test.cc +++ b/pw_protobuf/codegen_encoder_test.cc @@ -32,7 +32,25 @@ namespace pw::protobuf { namespace { -using namespace pw::protobuf::test; +using test::pwpb::Bool; +using test::pwpb::Enum; + +namespace Bar = test::pwpb::Bar; +namespace BaseMessage = test::pwpb::BaseMessage; +namespace Crate = test::pwpb::Crate; +namespace DeviceInfo = test::pwpb::DeviceInfo; +namespace Foo = test::pwpb::Foo; +namespace IntegerMetadata = test::pwpb::IntegerMetadata; +namespace KeyValuePair = test::pwpb::KeyValuePair; +namespace Overlay = test::pwpb::Overlay; +namespace Period = test::pwpb::Period; +namespace Pigweed = test::pwpb::Pigweed; +namespace Proto = test::pwpb::Proto; +namespace RepeatedTest = test::pwpb::RepeatedTest; + +namespace imported { +namespace Timestamp = ::pw::protobuf::test::imported::pwpb::Timestamp; +} // namespace imported TEST(Codegen, Codegen) { std::byte encode_buffer[Pigweed::kMaxEncodedSizeBytes + @@ -488,7 +506,8 @@ TEST(Codegen, Import) { } TEST(Codegen, NonPigweedPackage) { - using namespace non::pigweed::package::name; + namespace Packed = ::non::pigweed::package::name::pwpb::Packed; + std::byte encode_buffer[Packed::kMaxEncodedSizeBytes]; std::array<const int64_t, 2> repeated = {0, 1}; stream::MemoryWriter writer(encode_buffer); diff --git a/pw_protobuf/codegen_message_test.cc b/pw_protobuf/codegen_message_test.cc index 395ba85e8..e1752cf57 100644 --- a/pw_protobuf/codegen_message_test.cc +++ b/pw_protobuf/codegen_message_test.cc @@ -39,7 +39,7 @@ namespace pw::protobuf { namespace { -using namespace ::pw::protobuf::test; +using namespace ::pw::protobuf::test::pwpb; PW_MODIFY_DIAGNOSTICS_PUSH(); PW_MODIFY_DIAGNOSTIC(ignored, "-Wmissing-field-initializers"); diff --git a/pw_protobuf/size_report/oneof_codegen_comparison.cc b/pw_protobuf/size_report/oneof_codegen_comparison.cc index 8c06b45fa..39de80002 100644 --- a/pw_protobuf/size_report/oneof_codegen_comparison.cc +++ b/pw_protobuf/size_report/oneof_codegen_comparison.cc @@ -36,6 +36,9 @@ namespace pw::protobuf_size_report { namespace { +namespace ItemInfo = pwpb::ItemInfo; +namespace ResponseInfo = pwpb::ResponseInfo; + template <typename T> PW_NO_INLINE void ConsumeValue(T val) { [[maybe_unused]] volatile T no_optimize = val; diff --git a/pw_protobuf/size_report/simple_codegen_comparison.cc b/pw_protobuf/size_report/simple_codegen_comparison.cc index 277a8f196..eade00a44 100644 --- a/pw_protobuf/size_report/simple_codegen_comparison.cc +++ b/pw_protobuf/size_report/simple_codegen_comparison.cc @@ -43,7 +43,7 @@ PW_NO_INLINE void ConsumeValue(T val) { #if _PW_PROTOBUF_SIZE_REPORT_NO_CODEGEN -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> encode_buffer; +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> encode_buffer; pw::protobuf::MemoryEncoder generic_encoder(encode_buffer); PW_NO_INLINE void BasicEncode() { @@ -54,27 +54,27 @@ PW_NO_INLINE void BasicEncode() { ConsumeValue(status); } -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> decode_buffer; +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> decode_buffer; pw::protobuf::Decoder generic_decoder(decode_buffer); PW_NO_INLINE void BasicDecode() { while (generic_decoder.Next().ok()) { switch (generic_decoder.FieldNumber()) { - case static_cast<uint32_t>(ItemInfo::Fields::OFFSET): { + case static_cast<uint32_t>(pwpb::ItemInfo::Fields::OFFSET): { uint64_t value; if (generic_decoder.ReadUint64(&value).ok()) { ConsumeValue(value); } break; } - case static_cast<uint32_t>(ItemInfo::Fields::SIZE): { + case static_cast<uint32_t>(pwpb::ItemInfo::Fields::SIZE): { uint32_t value; if (generic_decoder.ReadUint32(&value).ok()) { ConsumeValue(value); } break; } - case static_cast<uint32_t>(ItemInfo::Fields::ACCESS_LEVEL): { + case static_cast<uint32_t>(pwpb::ItemInfo::Fields::ACCESS_LEVEL): { uint32_t value; if (generic_decoder.ReadUint32(&value).ok()) { @@ -89,46 +89,46 @@ PW_NO_INLINE void BasicDecode() { #if _PW_PROTOBUF_SIZE_REPORT_WIRE_FORMAT -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> encode_buffer; -ItemInfo::MemoryEncoder encoder(encode_buffer); +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> encode_buffer; +pwpb::ItemInfo::MemoryEncoder encoder(encode_buffer); PW_NO_INLINE void BasicEncode() { pw::Status status; status.Update(encoder.WriteOffset(0x5001DBADFEEDBEE5)); status.Update(encoder.WriteSize(128)); - status.Update(encoder.WriteAccessLevel(ItemInfo::Access::WRITE)); + status.Update(encoder.WriteAccessLevel(pwpb::ItemInfo::Access::WRITE)); ConsumeValue(status); } -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> decode_buffer; +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> decode_buffer; pw::stream::MemoryReader reader(decode_buffer); -ItemInfo::StreamDecoder decoder(reader); +pwpb::ItemInfo::StreamDecoder decoder(reader); PW_NO_INLINE void BasicDecode() { while (decoder.Next().ok()) { - pw::Result<ItemInfo::Fields> field = decoder.Field(); + pw::Result<pwpb::ItemInfo::Fields> field = decoder.Field(); if (!field.ok()) { ConsumeValue(field.status()); return; } switch (field.value()) { - case ItemInfo::Fields::OFFSET: { + case pwpb::ItemInfo::Fields::OFFSET: { pw::Result<uint64_t> value = decoder.ReadOffset(); if (value.ok()) { ConsumeValue(value); } break; } - case ItemInfo::Fields::SIZE: { + case pwpb::ItemInfo::Fields::SIZE: { pw::Result<uint32_t> value = decoder.ReadSize(); if (value.ok()) { ConsumeValue(value); } break; } - case ItemInfo::Fields::ACCESS_LEVEL: { - pw::Result<ItemInfo::Access> value = decoder.ReadAccessLevel(); + case pwpb::ItemInfo::Fields::ACCESS_LEVEL: { + pw::Result<pwpb::ItemInfo::Access> value = decoder.ReadAccessLevel(); if (value.ok()) { ConsumeValue(value); } @@ -141,21 +141,21 @@ PW_NO_INLINE void BasicDecode() { #if _PW_PROTOBUF_SIZE_REPORT_MESSAGE -ItemInfo::Message message; +pwpb::ItemInfo::Message message; -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> encode_buffer; -ItemInfo::MemoryEncoder encoder(encode_buffer); +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> encode_buffer; +pwpb::ItemInfo::MemoryEncoder encoder(encode_buffer); PW_NO_INLINE void BasicEncode() { message.offset = 0x5001DBADFEEDBEE5; message.size = 128; - message.access_level = ItemInfo::Access::WRITE; + message.access_level = pwpb::ItemInfo::Access::WRITE; ConsumeValue(encoder.Write(message)); } -std::array<std::byte, ItemInfo::kMaxEncodedSizeBytes> decode_buffer; +std::array<std::byte, pwpb::ItemInfo::kMaxEncodedSizeBytes> decode_buffer; pw::stream::MemoryReader reader(decode_buffer); -ItemInfo::StreamDecoder decoder(reader); +pwpb::ItemInfo::StreamDecoder decoder(reader); PW_NO_INLINE void BasicDecode() { if (pw::Status status = decoder.Read(message); status.ok()) { diff --git a/pw_protobuf_compiler/nested_packages_test.cc b/pw_protobuf_compiler/nested_packages_test.cc index 7d203d9f2..1b1dff592 100644 --- a/pw_protobuf_compiler/nested_packages_test.cc +++ b/pw_protobuf_compiler/nested_packages_test.cc @@ -19,14 +19,15 @@ #include "proto_root/data_type/thing/thing.pwpb.h" #include "proto_root/data_type/thing/type_of_thing.pwpb.h" +namespace pw::protobuf_compiler { +namespace { + TEST(NestedPackages, CompilesProtobufs) { - using Aggregate = pw::protobuf_compiler::proto_root::Aggregate::Message; - using AggregateWrapper = - pw::protobuf_compiler::proto_root::AggregateWrapper::Message; - using Id = pw::protobuf_compiler::proto_root::data_type::id::Id::Message; - using Thing = - pw::protobuf_compiler::proto_root::data_type::thing::Thing::Message; - using pw::protobuf_compiler::proto_root::data_type::thing::TypeOfThing; + using Aggregate = proto_root::pwpb::Aggregate::Message; + using AggregateWrapper = proto_root::pwpb::AggregateWrapper::Message; + using Id = proto_root::data_type::id::pwpb::Id::Message; + using Thing = proto_root::data_type::thing::pwpb::Thing::Message; + using proto_root::data_type::thing::pwpb::TypeOfThing; AggregateWrapper wrapper = { Id{0u, {1, 2}}, @@ -66,3 +67,6 @@ TEST(NestedPackages, CompilesProtobufs) { EXPECT_EQ(wrapper.aggregate.mountain.id.impl.bar, 6); EXPECT_EQ(wrapper.aggregate.mountain.type, TypeOfThing::kObject); } + +} // namespace +} // namespace pw::protobuf_compiler diff --git a/pw_protobuf_compiler/pwpb_test.cc b/pw_protobuf_compiler/pwpb_test.cc index c507d5098..a7d2d3599 100644 --- a/pw_protobuf_compiler/pwpb_test.cc +++ b/pw_protobuf_compiler/pwpb_test.cc @@ -16,8 +16,11 @@ #include "pw_protobuf_compiler_pwpb_protos/pwpb_test.pwpb.h" #include "pw_string/string.h" +namespace pw::protobuf_compiler { +namespace { + TEST(Pwpb, CompilesProtobufs) { - pw::protobuf_compiler::Point::Message point = {4, 8, "point"}; + pwpb::Point::Message point = {4, 8, "point"}; EXPECT_EQ(point.x, 4u); EXPECT_EQ(point.y, 8u); EXPECT_EQ(point.name.size(), 5u); @@ -25,7 +28,7 @@ TEST(Pwpb, CompilesProtobufs) { } TEST(Pwpb, OptionsFilesAreApplied) { - pw::protobuf_compiler::OptionsFileExample::Message string_options_comparison; + pwpb::OptionsFileExample::Message string_options_comparison; static_assert( std::is_same_v<decltype(string_options_comparison.thirty_two_chars), @@ -40,8 +43,10 @@ TEST(Pwpb, OptionsFilesAreApplied) { static_assert( std::is_same_v< decltype(string_options_comparison.unspecified_length), - pw::protobuf::Callback< - pw::protobuf_compiler::OptionsFileExample::StreamEncoder, - pw::protobuf_compiler::OptionsFileExample::StreamDecoder>>, + pw::protobuf::Callback<pwpb::OptionsFileExample::StreamEncoder, + pwpb::OptionsFileExample::StreamDecoder>>, "The field `unspecified_length` should be a `pw::protobuf::Callback`."); } + +} // namespace +} // namespace pw::protobuf_compiler diff --git a/pw_rpc/call.cc b/pw_rpc/call.cc index e323cfcb5..dfe411bdb 100644 --- a/pw_rpc/call.cc +++ b/pw_rpc/call.cc @@ -22,6 +22,8 @@ namespace pw::rpc::internal { +using pwpb::PacketType; + // Creates an active server-side Call. Call::Call(const LockedCallContext& context, MethodType type) : Call(context.server().ClaimLocked(), diff --git a/pw_rpc/call_test.cc b/pw_rpc/call_test.cc index 8c5afa9bc..7457353f6 100644 --- a/pw_rpc/call_test.cc +++ b/pw_rpc/call_test.cc @@ -37,7 +37,7 @@ class TestService : public Service { namespace internal { namespace { -constexpr Packet kPacket(PacketType::REQUEST, 99, 16, 8); +constexpr Packet kPacket(pwpb::PacketType::REQUEST, 99, 16, 8); using ::pw::rpc::internal::test::FakeServerReader; using ::pw::rpc::internal::test::FakeServerReaderWriter; @@ -109,7 +109,7 @@ TEST_F(ServerWriterTest, Finish_SendsResponse) { ASSERT_EQ(context_.output().total_packets(), 1u); const Packet& packet = context_.output().last_packet(); - EXPECT_EQ(packet.type(), PacketType::RESPONSE); + EXPECT_EQ(packet.type(), pwpb::PacketType::RESPONSE); EXPECT_EQ(packet.channel_id(), context_.channel_id()); EXPECT_EQ(packet.service_id(), context_.service_id()); EXPECT_EQ(packet.method_id(), context_.get().method().id()); diff --git a/pw_rpc/channel.cc b/pw_rpc/channel.cc index d672373b3..5e1ff9bbb 100644 --- a/pw_rpc/channel.cc +++ b/pw_rpc/channel.cc @@ -39,8 +39,8 @@ Result<uint32_t> ExtractChannelId(ConstByteSpan packet) { protobuf::Decoder decoder(packet); while (decoder.Next().ok()) { - if (static_cast<internal::RpcPacket::Fields>(decoder.FieldNumber()) != - internal::RpcPacket::Fields::CHANNEL_ID) { + if (static_cast<internal::pwpb::RpcPacket::Fields>(decoder.FieldNumber()) != + internal::pwpb::RpcPacket::Fields::CHANNEL_ID) { continue; } uint32_t channel_id; diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc index 111ed4290..e96a7bd9b 100644 --- a/pw_rpc/channel_test.cc +++ b/pw_rpc/channel_test.cc @@ -35,7 +35,7 @@ TEST(ChannelOutput, Name) { } constexpr Packet kTestPacket( - PacketType::RESPONSE, 23, 42, 100, 0, {}, Status::NotFound()); + pwpb::PacketType::RESPONSE, 23, 42, 100, 0, {}, Status::NotFound()); const size_t kReservedSize = 2 /* type */ + 2 /* channel */ + 5 /* service */ + 5 /* method */ + 2 /* payload key */ + 2 /* status (if not OK) */; @@ -64,7 +64,7 @@ TEST(Channel, MaxSafePayload) { payload[i] = std::byte(i % std::numeric_limits<uint8_t>::max()); } - Packet packet(PacketType::SERVER_STREAM, + Packet packet(pwpb::PacketType::SERVER_STREAM, /*channel_id=*/kUint32Max, // Varint, needs to be uint32_t max. /*service_id=*/42, // Fixed-width. Value doesn't matter. /*method_id=*/100, // Fixed-width. Value doesn't matter. @@ -96,7 +96,7 @@ TEST(Channel, MaxSafePayload_OffByOne) { payload[i] = std::byte(i % std::numeric_limits<uint8_t>::max()); } - Packet packet(PacketType::SERVER_STREAM, + Packet packet(pwpb::PacketType::SERVER_STREAM, /*channel_id=*/kUint32Max, // Varint, needs to be uint32_t max. /*service_id=*/42, // Fixed-width. Value doesn't matter. /*method_id=*/100, // Fixed-width. Value doesn't matter. diff --git a/pw_rpc/client.cc b/pw_rpc/client.cc index e579db8b3..1358d1fbf 100644 --- a/pw_rpc/client.cc +++ b/pw_rpc/client.cc @@ -27,7 +27,7 @@ namespace pw::rpc { namespace { using internal::Packet; -using internal::PacketType; +using internal::pwpb::PacketType; } // namespace diff --git a/pw_rpc/client_server_test.cc b/pw_rpc/client_server_test.cc index 15a50e944..bb2c72b0d 100644 --- a/pw_rpc/client_server_test.cc +++ b/pw_rpc/client_server_test.cc @@ -51,7 +51,7 @@ TEST(ClientServer, ProcessPacket_CallsServer) { client_server.server().RegisterService(service); Packet packet( - PacketType::REQUEST, kFakeChannelId, kFakeServiceId, kFakeMethodId); + pwpb::PacketType::REQUEST, kFakeChannelId, kFakeServiceId, kFakeMethodId); std::array<std::byte, 32> buffer; Result result = packet.Encode(buffer); EXPECT_EQ(result.status(), OkStatus()); @@ -65,8 +65,10 @@ TEST(ClientServer, ProcessPacket_CallsClient) { // Same packet as above, but type RESPONSE will skip the server and call into // the client. - Packet packet( - PacketType::RESPONSE, kFakeChannelId, kFakeServiceId, kFakeMethodId); + Packet packet(pwpb::PacketType::RESPONSE, + kFakeChannelId, + kFakeServiceId, + kFakeMethodId); std::array<std::byte, 32> buffer; Result result = packet.Encode(buffer); EXPECT_EQ(result.status(), OkStatus()); diff --git a/pw_rpc/fake_channel_output.cc b/pw_rpc/fake_channel_output.cc index f98f0b3cd..dc5b69305 100644 --- a/pw_rpc/fake_channel_output.cc +++ b/pw_rpc/fake_channel_output.cc @@ -63,26 +63,26 @@ Status FakeChannelOutput::HandlePacket(span<const std::byte> buffer) { CopyPayloadToBuffer(packet); switch (packet.type()) { - case PacketType::REQUEST: + case pwpb::PacketType::REQUEST: return OkStatus(); - case PacketType::RESPONSE: + case pwpb::PacketType::RESPONSE: total_response_packets_ += 1; return OkStatus(); - case PacketType::CLIENT_STREAM: + case pwpb::PacketType::CLIENT_STREAM: return OkStatus(); - case PacketType::DEPRECATED_SERVER_STREAM_END: + case pwpb::PacketType::DEPRECATED_SERVER_STREAM_END: PW_CRASH("Deprecated PacketType %d", static_cast<int>(packet.type())); - case PacketType::CLIENT_ERROR: + case pwpb::PacketType::CLIENT_ERROR: PW_LOG_WARN("FakeChannelOutput received client error: %s", packet.status().str()); return OkStatus(); - case PacketType::SERVER_ERROR: + case pwpb::PacketType::SERVER_ERROR: PW_LOG_WARN("FakeChannelOutput received server error: %s", packet.status().str()); return OkStatus(); - case PacketType::DEPRECATED_CANCEL: - case PacketType::SERVER_STREAM: - case PacketType::CLIENT_STREAM_END: + case pwpb::PacketType::DEPRECATED_CANCEL: + case pwpb::PacketType::SERVER_STREAM: + case pwpb::PacketType::CLIENT_STREAM_END: return OkStatus(); } PW_CRASH("Unhandled PacketType %d", static_cast<int>(result.value().type())); diff --git a/pw_rpc/fake_channel_output_test.cc b/pw_rpc/fake_channel_output_test.cc index 202be7e43..ce90f76c6 100644 --- a/pw_rpc/fake_channel_output_test.cc +++ b/pw_rpc/fake_channel_output_test.cc @@ -50,7 +50,7 @@ TEST(FakeChannelOutput, SendAndClear) { constexpr MethodType type = MethodType::kServerStreaming; TestFakeChannelOutput output; Channel channel(kChannelId, &output); - const internal::Packet server_stream_packet(PacketType::SERVER_STREAM, + const internal::Packet server_stream_packet(pwpb::PacketType::SERVER_STREAM, kChannelId, kServiceId, kMethodId, @@ -77,7 +77,7 @@ TEST(FakeChannelOutput, SendAndFakeFutureResults) { constexpr MethodType type = MethodType::kUnary; TestFakeChannelOutput output; Channel channel(kChannelId, &output); - const internal::Packet response_packet(PacketType::RESPONSE, + const internal::Packet response_packet(pwpb::PacketType::RESPONSE, kChannelId, kServiceId, kMethodId, @@ -103,7 +103,7 @@ TEST(FakeChannelOutput, SendAndFakeFutureResults) { EXPECT_EQ(output.total_payloads(type), 2u); EXPECT_EQ(output.total_packets(), 2u); - const internal::Packet server_stream_packet(PacketType::SERVER_STREAM, + const internal::Packet server_stream_packet(pwpb::PacketType::SERVER_STREAM, kChannelId, kServiceId, kMethodId, @@ -124,7 +124,7 @@ TEST(FakeChannelOutput, SendAndFakeSingleResult) { constexpr MethodType type = MethodType::kUnary; TestFakeChannelOutput output; Channel channel(kChannelId, &output); - const internal::Packet response_packet(PacketType::RESPONSE, + const internal::Packet response_packet(pwpb::PacketType::RESPONSE, kChannelId, kServiceId, kMethodId, @@ -158,7 +158,7 @@ TEST(FakeChannelOutput, SendAndFakeSingleResult) { TEST(FakeChannelOutput, SendResponseUpdated) { TestFakeChannelOutput output; Channel channel(kChannelId, &output); - const internal::Packet response_packet(PacketType::RESPONSE, + const internal::Packet response_packet(pwpb::PacketType::RESPONSE, kChannelId, kServiceId, kMethodId, @@ -176,15 +176,19 @@ TEST(FakeChannelOutput, SendResponseUpdated) { EXPECT_TRUE(output.done()); output.clear(); - const internal::Packet packet_empty_payload( - PacketType::RESPONSE, kChannelId, kServiceId, kMethodId, kCallId, {}); + const internal::Packet packet_empty_payload(pwpb::PacketType::RESPONSE, + kChannelId, + kServiceId, + kMethodId, + kCallId, + {}); EXPECT_EQ(channel.Send(packet_empty_payload), OkStatus()); EXPECT_EQ(output.last_response(MethodType::kUnary).size(), 0u); EXPECT_EQ(output.total_payloads(MethodType::kUnary), 1u); EXPECT_EQ(output.total_packets(), 1u); EXPECT_TRUE(output.done()); - const internal::Packet server_stream_packet(PacketType::SERVER_STREAM, + const internal::Packet server_stream_packet(pwpb::PacketType::SERVER_STREAM, kChannelId, kServiceId, kMethodId, diff --git a/pw_rpc/nanopb/client_call_test.cc b/pw_rpc/nanopb/client_call_test.cc index 837620557..1bb06d430 100644 --- a/pw_rpc/nanopb/client_call_test.cc +++ b/pw_rpc/nanopb/client_call_test.cc @@ -198,7 +198,7 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnServerError) { [this](Status status) { last_error_ = status; }); EXPECT_EQ(OkStatus(), - context.SendPacket(internal::PacketType::SERVER_ERROR, + context.SendPacket(internal::pwpb::PacketType::SERVER_ERROR, Status::NotFound())); EXPECT_EQ(responses_received_, 0); @@ -382,7 +382,7 @@ TEST_F(ServerStreamingClientCall, InvokesErrorCallbackOnInvalidResponses) { EXPECT_EQ(last_response_number_, 22); EXPECT_EQ(OkStatus(), - context.SendPacket(internal::PacketType::SERVER_ERROR, + context.SendPacket(internal::pwpb::PacketType::SERVER_ERROR, Status::NotFound())); EXPECT_EQ(responses_received_, 2); EXPECT_EQ(rpc_error_, Status::NotFound()); diff --git a/pw_rpc/nanopb/fake_channel_output_test.cc b/pw_rpc/nanopb/fake_channel_output_test.cc index 8bdd9a14d..7cd97f954 100644 --- a/pw_rpc/nanopb/fake_channel_output_test.cc +++ b/pw_rpc/nanopb/fake_channel_output_test.cc @@ -40,7 +40,7 @@ TEST(NanopbFakeChannelOutput, Requests) { std::array<std::byte, 128> buffer; - auto packet = Packet(PacketType::REQUEST, + auto packet = Packet(pwpb::PacketType::REQUEST, 1, Info::kServiceId, Info::kMethodId, @@ -70,7 +70,7 @@ TEST(NanopbFakeChannelOutput, Responses) { std::array<std::byte, 128> buffer; - auto packet = Packet(PacketType::RESPONSE, + auto packet = Packet(pwpb::PacketType::RESPONSE, 1, Info::kServiceId, Info::kMethodId, diff --git a/pw_rpc/nanopb/method_test.cc b/pw_rpc/nanopb/method_test.cc index b766a8e84..9b84e1730 100644 --- a/pw_rpc/nanopb/method_test.cc +++ b/pw_rpc/nanopb/method_test.cc @@ -238,7 +238,7 @@ TEST(NanopbMethod, SyncUnaryRpc_InvalidPayload_SendsError) { kSyncUnary.Invoke(context.get(), context.request(bad_payload)); const Packet& packet = context.output().last_packet(); - EXPECT_EQ(PacketType::SERVER_ERROR, packet.type()); + EXPECT_EQ(pwpb::PacketType::SERVER_ERROR, packet.type()); EXPECT_EQ(Status::DataLoss(), packet.status()); EXPECT_EQ(context.service_id(), packet.service_id()); EXPECT_EQ(kSyncUnary.id(), packet.method_id()); @@ -256,7 +256,7 @@ TEST(NanopbMethod, AsyncUnaryRpc_ResponseEncodingFails_SendsInternalError) { kAsyncUnary.Invoke(context.get(), context.request(request)); const Packet& packet = context.output().last_packet(); - EXPECT_EQ(PacketType::SERVER_ERROR, packet.type()); + EXPECT_EQ(pwpb::PacketType::SERVER_ERROR, packet.type()); EXPECT_EQ(Status::Internal(), packet.status()); EXPECT_EQ(context.service_id(), packet.service_id()); EXPECT_EQ(kAsyncUnary.id(), packet.method_id()); diff --git a/pw_rpc/nanopb/method_union_test.cc b/pw_rpc/nanopb/method_union_test.cc index 6eacb5978..0c68f4377 100644 --- a/pw_rpc/nanopb/method_union_test.cc +++ b/pw_rpc/nanopb/method_union_test.cc @@ -119,7 +119,7 @@ TEST(NanopbMethodUnion, Raw_CallsServerStreamingMethod) { EXPECT_TRUE(context.service().last_raw_writer.active()); EXPECT_EQ(OkStatus(), context.service().last_raw_writer.Finish()); - EXPECT_EQ(context.output().last_packet().type(), PacketType::RESPONSE); + EXPECT_EQ(context.output().last_packet().type(), pwpb::PacketType::RESPONSE); } TEST(NanopbMethodUnion, Nanopb_CallsUnaryMethod) { @@ -162,7 +162,7 @@ TEST(NanopbMethodUnion, Nanopb_CallsServerStreamingMethod) { EXPECT_TRUE(context.service().last_writer.active()); EXPECT_EQ(OkStatus(), context.service().last_writer.Finish()); - EXPECT_EQ(context.output().last_packet().type(), PacketType::RESPONSE); + EXPECT_EQ(context.output().last_packet().type(), pwpb::PacketType::RESPONSE); } } // namespace diff --git a/pw_rpc/nanopb/public/pw_rpc/nanopb/fake_channel_output.h b/pw_rpc/nanopb/public/pw_rpc/nanopb/fake_channel_output.h index dd5fba3b8..b88c11087 100644 --- a/pw_rpc/nanopb/public/pw_rpc/nanopb/fake_channel_output.h +++ b/pw_rpc/nanopb/public/pw_rpc/nanopb/fake_channel_output.h @@ -125,10 +125,10 @@ class NanopbFakeChannelOutput final NanopbPayloadsView<Request<kMethod>> requests( uint32_t channel_id = Channel::kUnassignedChannelId) const PW_NO_LOCK_SAFETY_ANALYSIS { - constexpr internal::PacketType packet_type = + constexpr internal::pwpb::PacketType packet_type = HasClientStream(internal::MethodInfo<kMethod>::kType) - ? internal::PacketType::CLIENT_STREAM - : internal::PacketType::REQUEST; + ? internal::pwpb::PacketType::CLIENT_STREAM + : internal::pwpb::PacketType::REQUEST; return NanopbPayloadsView<Request<kMethod>>( internal::MethodInfo<kMethod>::serde().request(), Base::packets(), @@ -150,10 +150,10 @@ class NanopbFakeChannelOutput final NanopbPayloadsView<Response<kMethod>> responses( uint32_t channel_id = Channel::kUnassignedChannelId) const PW_NO_LOCK_SAFETY_ANALYSIS { - constexpr internal::PacketType packet_type = + constexpr internal::pwpb::PacketType packet_type = HasServerStream(internal::MethodInfo<kMethod>::kType) - ? internal::PacketType::SERVER_STREAM - : internal::PacketType::RESPONSE; + ? internal::pwpb::PacketType::SERVER_STREAM + : internal::pwpb::PacketType::RESPONSE; return NanopbPayloadsView<Response<kMethod>>( internal::MethodInfo<kMethod>::serde().response(), Base::packets(), diff --git a/pw_rpc/packet.cc b/pw_rpc/packet.cc index 5a464285b..0abbdb0a1 100644 --- a/pw_rpc/packet.cc +++ b/pw_rpc/packet.cc @@ -18,6 +18,10 @@ namespace pw::rpc::internal { +using pwpb::PacketType; + +namespace RpcPacket = pwpb::RpcPacket; + Result<Packet> Packet::FromBuffer(ConstByteSpan data) { Packet packet; Status status; diff --git a/pw_rpc/packet_meta_test.cc b/pw_rpc/packet_meta_test.cc index 1fa4bae22..d21f3a48d 100644 --- a/pw_rpc/packet_meta_test.cc +++ b/pw_rpc/packet_meta_test.cc @@ -28,7 +28,7 @@ TEST(PacketMeta, FromBufferDecodesValidMinimalPacket) { internal::Packet packet; packet.set_channel_id(kChannelId); packet.set_service_id(internal::UnwrapServiceId(kServiceId)); - packet.set_type(internal::PacketType::RESPONSE); + packet.set_type(internal::pwpb::PacketType::RESPONSE); packet.set_method_id(kMethodId); std::byte buffer[128]; diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc index d2e9e2772..a0d7da3b6 100644 --- a/pw_rpc/packet_test.cc +++ b/pw_rpc/packet_test.cc @@ -22,6 +22,7 @@ namespace pw::rpc::internal { namespace { using protobuf::FieldKey; +using ::pw::rpc::internal::pwpb::PacketType; using std::byte; constexpr auto kPayload = bytes::Array<0x82, 0x02, 0xff, 0xff>(); diff --git a/pw_rpc/public/pw_rpc/internal/call.h b/pw_rpc/public/pw_rpc/internal/call.h index 4a26a618d..26f76fbfc 100644 --- a/pw_rpc/public/pw_rpc/internal/call.h +++ b/pw_rpc/public/pw_rpc/internal/call.h @@ -106,7 +106,7 @@ class Call : public IntrusiveList<Call>::Item { Status CloseAndSendResponseLocked(ConstByteSpan response, Status status) PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()) { return CloseAndSendFinalPacketLocked( - PacketType::RESPONSE, response, status); + pwpb::PacketType::RESPONSE, response, status); } Status CloseAndSendResponse(Status status) PW_LOCKS_EXCLUDED(rpc_lock()) { @@ -115,7 +115,8 @@ class Call : public IntrusiveList<Call>::Item { Status CloseAndSendServerErrorLocked(Status error) PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()) { - return CloseAndSendFinalPacketLocked(PacketType::SERVER_ERROR, {}, error); + return CloseAndSendFinalPacketLocked( + pwpb::PacketType::SERVER_ERROR, {}, error); } // Public call that ends the client stream for a client call. @@ -127,7 +128,7 @@ class Call : public IntrusiveList<Call>::Item { // Internal call that closes the client stream. Status CloseClientStreamLocked() PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()) { client_stream_state_ = kClientStreamInactive; - return SendPacket(PacketType::CLIENT_STREAM_END, {}, {}); + return SendPacket(pwpb::PacketType::CLIENT_STREAM_END, {}, {}); } // Sends a payload in either a server or client stream packet. @@ -145,7 +146,7 @@ class Call : public IntrusiveList<Call>::Item { PW_UNLOCK_FUNCTION(rpc_lock()) { // TODO(b/234876851): Ensure the call object is locked before releasing the // RPC mutex. - if (const Status status = SendPacket(PacketType::REQUEST, payload); + if (const Status status = SendPacket(pwpb::PacketType::REQUEST, payload); !status.ok()) { HandleError(status); } else { @@ -276,14 +277,15 @@ class Call : public IntrusiveList<Call>::Item { Status CloseAndSendResponseLocked(Status status) PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()) { - return CloseAndSendFinalPacketLocked(PacketType::RESPONSE, {}, status); + return CloseAndSendFinalPacketLocked( + pwpb::PacketType::RESPONSE, {}, status); } // Cancels an RPC. For client calls only. Status Cancel() PW_LOCKS_EXCLUDED(rpc_lock()) { LockGuard lock(rpc_lock()); return CloseAndSendFinalPacketLocked( - PacketType::CLIENT_ERROR, {}, Status::Cancelled()); + pwpb::PacketType::CLIENT_ERROR, {}, Status::Cancelled()); } // Unregisters the RPC from the endpoint & marks as closed. The call may be @@ -307,7 +309,7 @@ class Call : public IntrusiveList<Call>::Item { MethodType type, CallType call_type); - Packet MakePacket(PacketType type, + Packet MakePacket(pwpb::PacketType type, ConstByteSpan payload, Status status = OkStatus()) const PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()) { @@ -330,12 +332,12 @@ class Call : public IntrusiveList<Call>::Item { // previously acquired buffer or in a standalone buffer. // // Returns FAILED_PRECONDITION if the call is not active(). - Status SendPacket(PacketType type, + Status SendPacket(pwpb::PacketType type, ConstByteSpan payload, Status status = OkStatus()) PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()); - Status CloseAndSendFinalPacketLocked(PacketType type, + Status CloseAndSendFinalPacketLocked(pwpb::PacketType type, ConstByteSpan response, Status status) PW_EXCLUSIVE_LOCKS_REQUIRED(rpc_lock()); diff --git a/pw_rpc/public/pw_rpc/internal/fake_channel_output.h b/pw_rpc/public/pw_rpc/internal/fake_channel_output.h index 5263ccc9c..de29e1b4c 100644 --- a/pw_rpc/public/pw_rpc/internal/fake_channel_output.h +++ b/pw_rpc/public/pw_rpc/internal/fake_channel_output.h @@ -121,8 +121,8 @@ class FakeChannelOutput : public ChannelOutput { const PW_LOCKS_EXCLUDED(mutex_) { LockGuard lock(mutex_); return StatusView(packets_, - internal::PacketType::RESPONSE, - internal::PacketType::RESPONSE, + internal::pwpb::PacketType::RESPONSE, + internal::pwpb::PacketType::RESPONSE, channel_id, MethodInfo<kMethod>::kServiceId, MethodInfo<kMethod>::kMethodId); @@ -140,8 +140,8 @@ class FakeChannelOutput : public ChannelOutput { PW_LOCKS_EXCLUDED(mutex_) { LockGuard lock(mutex_); return StatusView(packets_, - internal::PacketType::CLIENT_ERROR, - internal::PacketType::SERVER_ERROR, + internal::pwpb::PacketType::CLIENT_ERROR, + internal::pwpb::PacketType::SERVER_ERROR, channel_id, MethodInfo<kMethod>::kServiceId, MethodInfo<kMethod>::kMethodId); @@ -157,8 +157,8 @@ class FakeChannelOutput : public ChannelOutput { return internal::test::PacketsView( packets_, internal::test::PacketFilter( - internal::PacketType::CLIENT_STREAM_END, - internal::PacketType::CLIENT_STREAM_END, + internal::pwpb::PacketType::CLIENT_STREAM_END, + internal::pwpb::PacketType::CLIENT_STREAM_END, channel_id, MethodInfo<kMethod>::kServiceId, MethodInfo<kMethod>::kMethodId)) diff --git a/pw_rpc/public/pw_rpc/internal/packet.h b/pw_rpc/public/pw_rpc/internal/packet.h index 290681c81..b843bfd72 100644 --- a/pw_rpc/public/pw_rpc/internal/packet.h +++ b/pw_rpc/public/pw_rpc/internal/packet.h @@ -29,18 +29,19 @@ class Packet { static constexpr uint32_t kUnassignedId = 0; // TODO(b/236156534): This can use the pwpb generated - // pw::rpc::internal::RpcPacket::kMaxEncodedSizeBytes once the max value of - // enums is properly accounted for and when `status` is changed from a uint32 - // to a StatusCode. + // pw::rpc::internal::pwpb::RpcPacket::kMaxEncodedSizeBytes once the max value + // of enums is properly accounted for and when `status` is changed from a + // uint32 to a StatusCode. static constexpr size_t kMinEncodedSizeWithoutPayload = - protobuf::SizeOfFieldEnum(RpcPacket::Fields::TYPE, 7) + - protobuf::SizeOfFieldUint32(RpcPacket::Fields::CHANNEL_ID) + - protobuf::SizeOfFieldFixed32(RpcPacket::Fields::SERVICE_ID) + - protobuf::SizeOfFieldFixed32(RpcPacket::Fields::METHOD_ID) + - protobuf::SizeOfDelimitedFieldWithoutValue(RpcPacket::Fields::PAYLOAD) + - protobuf::SizeOfFieldUint32(RpcPacket::Fields::STATUS, + protobuf::SizeOfFieldEnum(pwpb::RpcPacket::Fields::TYPE, 7) + + protobuf::SizeOfFieldUint32(pwpb::RpcPacket::Fields::CHANNEL_ID) + + protobuf::SizeOfFieldFixed32(pwpb::RpcPacket::Fields::SERVICE_ID) + + protobuf::SizeOfFieldFixed32(pwpb::RpcPacket::Fields::METHOD_ID) + + protobuf::SizeOfDelimitedFieldWithoutValue( + pwpb::RpcPacket::Fields::PAYLOAD) + + protobuf::SizeOfFieldUint32(pwpb::RpcPacket::Fields::STATUS, Status::Unauthenticated().code()) + - protobuf::SizeOfFieldUint32(RpcPacket::Fields::CALL_ID); + protobuf::SizeOfFieldUint32(pwpb::RpcPacket::Fields::CALL_ID); // Parses a packet from a protobuf message. Missing or malformed fields take // their default values. @@ -50,7 +51,7 @@ class Packet { // provided packet. static constexpr Packet Response(const Packet& request, Status status = OkStatus()) { - return Packet(PacketType::RESPONSE, + return Packet(pwpb::PacketType::RESPONSE, request.channel_id(), request.service_id(), request.method_id(), @@ -62,7 +63,7 @@ class Packet { // Creates a SERVER_ERROR packet with the channel, service, and method ID of // the provided packet. static constexpr Packet ServerError(const Packet& packet, Status status) { - return Packet(PacketType::SERVER_ERROR, + return Packet(pwpb::PacketType::SERVER_ERROR, packet.channel_id(), packet.service_id(), packet.method_id(), @@ -74,7 +75,7 @@ class Packet { // Creates a CLIENT_ERROR packet with the channel, service, and method ID of // the provided packet. static constexpr Packet ClientError(const Packet& packet, Status status) { - return Packet(PacketType::CLIENT_ERROR, + return Packet(pwpb::PacketType::CLIENT_ERROR, packet.channel_id(), packet.service_id(), packet.method_id(), @@ -85,9 +86,10 @@ class Packet { // Creates an empty packet. constexpr Packet() - : Packet(PacketType{}, kUnassignedId, kUnassignedId, kUnassignedId) {} + : Packet( + pwpb::PacketType{}, kUnassignedId, kUnassignedId, kUnassignedId) {} - constexpr Packet(PacketType type, + constexpr Packet(pwpb::PacketType type, uint32_t channel_id, uint32_t service_id, uint32_t method_id, @@ -119,7 +121,7 @@ class Packet { return static_cast<int>(type_) % 2 == 0 ? kServer : kClient; } - constexpr PacketType type() const { return type_; } + constexpr pwpb::PacketType type() const { return type_; } constexpr uint32_t channel_id() const { return channel_id_; } constexpr uint32_t service_id() const { return service_id_; } constexpr uint32_t method_id() const { return method_id_; } @@ -127,7 +129,7 @@ class Packet { constexpr const ConstByteSpan& payload() const { return payload_; } constexpr const Status& status() const { return status_; } - constexpr void set_type(PacketType type) { type_ = type; } + constexpr void set_type(pwpb::PacketType type) { type_ = type; } constexpr void set_channel_id(uint32_t channel_id) { channel_id_ = channel_id; } @@ -140,7 +142,7 @@ class Packet { constexpr void set_status(Status status) { status_ = status; } private: - PacketType type_; + pwpb::PacketType type_; uint32_t channel_id_; uint32_t service_id_; uint32_t method_id_; diff --git a/pw_rpc/public/pw_rpc/internal/test_method_context.h b/pw_rpc/public/pw_rpc/internal/test_method_context.h index 5db32412b..2a126daaa 100644 --- a/pw_rpc/public/pw_rpc/internal/test_method_context.h +++ b/pw_rpc/public/pw_rpc/internal/test_method_context.h @@ -76,6 +76,8 @@ class InvocationContext { } void SendClientError(Status error) { + using PacketType = ::pw::rpc::internal::pwpb::PacketType; + std::byte packet[kNoPayloadPacketSizeBytes]; PW_ASSERT(server_ .ProcessPacket(Packet(PacketType::CLIENT_ERROR, @@ -113,6 +115,8 @@ class InvocationContext { template <size_t kMaxPayloadSize = 32> void SendClientStream(ConstByteSpan payload) { + using PacketType = ::pw::rpc::internal::pwpb::PacketType; + std::byte packet[kNoPayloadPacketSizeBytes + 3 + kMaxPayloadSize]; PW_ASSERT(server_ .ProcessPacket(Packet(PacketType::CLIENT_STREAM, @@ -127,6 +131,8 @@ class InvocationContext { } void SendClientStreamEnd() { + using PacketType = ::pw::rpc::internal::pwpb::PacketType; + std::byte packet[kNoPayloadPacketSizeBytes]; PW_ASSERT(server_ .ProcessPacket(Packet(PacketType::CLIENT_STREAM_END, diff --git a/pw_rpc/public/pw_rpc/internal/test_utils.h b/pw_rpc/public/pw_rpc/internal/test_utils.h index 4c329b991..be30d7e8f 100644 --- a/pw_rpc/public/pw_rpc/internal/test_utils.h +++ b/pw_rpc/public/pw_rpc/internal/test_utils.h @@ -55,7 +55,7 @@ class ServerContextForTest { // Create packets for this context's channel, service, and method. internal::Packet request(span<const std::byte> payload) const { - return internal::Packet(internal::PacketType::REQUEST, + return internal::Packet(internal::pwpb::PacketType::REQUEST, kChannelId, kServiceId, context_.method().id(), @@ -65,7 +65,7 @@ class ServerContextForTest { internal::Packet response(Status status, span<const std::byte> payload = {}) const { - return internal::Packet(internal::PacketType::RESPONSE, + return internal::Packet(internal::pwpb::PacketType::RESPONSE, kChannelId, kServiceId, context_.method().id(), @@ -75,7 +75,7 @@ class ServerContextForTest { } internal::Packet server_stream(span<const std::byte> payload) const { - return internal::Packet(internal::PacketType::SERVER_STREAM, + return internal::Packet(internal::pwpb::PacketType::SERVER_STREAM, kChannelId, kServiceId, context_.method().id(), @@ -84,7 +84,7 @@ class ServerContextForTest { } internal::Packet client_stream(span<const std::byte> payload) const { - return internal::Packet(internal::PacketType::CLIENT_STREAM, + return internal::Packet(internal::pwpb::PacketType::CLIENT_STREAM, kChannelId, kServiceId, context_.method().id(), @@ -126,7 +126,7 @@ class ClientContextForTest { // Sends a packet to be processed by the client. Returns the client's // ProcessPacket status. - Status SendPacket(internal::PacketType type, + Status SendPacket(internal::pwpb::PacketType type, Status status = OkStatus(), span<const std::byte> payload = {}) { uint32_t call_id = @@ -141,11 +141,12 @@ class ClientContextForTest { } Status SendResponse(Status status, span<const std::byte> payload = {}) { - return SendPacket(internal::PacketType::RESPONSE, status, payload); + return SendPacket(internal::pwpb::PacketType::RESPONSE, status, payload); } Status SendServerStream(span<const std::byte> payload) { - return SendPacket(internal::PacketType::SERVER_STREAM, OkStatus(), payload); + return SendPacket( + internal::pwpb::PacketType::SERVER_STREAM, OkStatus(), payload); } private: diff --git a/pw_rpc/public/pw_rpc/payloads_view.h b/pw_rpc/public/pw_rpc/payloads_view.h index 07fa7f3fb..9d003ddca 100644 --- a/pw_rpc/public/pw_rpc/payloads_view.h +++ b/pw_rpc/public/pw_rpc/payloads_view.h @@ -39,8 +39,8 @@ class FakeChannelOutput; class PacketFilter { public: // Use Channel::kUnassignedChannelId to ignore the channel. - constexpr PacketFilter(PacketType packet_type_1, - PacketType packet_type_2, + constexpr PacketFilter(internal::pwpb::PacketType packet_type_1, + internal::pwpb::PacketType packet_type_2, uint32_t channel_id, uint32_t service_id, uint32_t method_id) @@ -62,8 +62,8 @@ class PacketFilter { private: // Support filtering on two packet types to handle reading both client and // server streams for bidirectional streams. - PacketType packet_type_1_; - PacketType packet_type_2_; + internal::pwpb::PacketType packet_type_1_; + internal::pwpb::PacketType packet_type_2_; uint32_t channel_id_; uint32_t service_id_; uint32_t method_id_; @@ -130,7 +130,7 @@ class PayloadsView { template <auto kMethod> using MethodInfo = internal::MethodInfo<kMethod>; - using PacketType = internal::PacketType; + using PacketType = internal::pwpb::PacketType; template <auto kMethod> static constexpr PayloadsView For(const Vector<internal::Packet>& packets, @@ -243,7 +243,7 @@ class StatusView { template <auto kMethod> using MethodInfo = internal::MethodInfo<kMethod>; - using PacketType = internal::PacketType; + using PacketType = internal::pwpb::PacketType; constexpr StatusView(const Vector<internal::Packet>& packets, PacketType packet_type_1, diff --git a/pw_rpc/pwpb/client_call_test.cc b/pw_rpc/pwpb/client_call_test.cc index 47b4490bb..d5580615b 100644 --- a/pw_rpc/pwpb/client_call_test.cc +++ b/pw_rpc/pwpb/client_call_test.cc @@ -27,6 +27,11 @@ namespace pw::rpc { namespace { using internal::ClientContextForTest; +using internal::pwpb::PacketType; + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; constexpr uint32_t kServiceId = 16; constexpr uint32_t kUnaryMethodId = 111; @@ -34,62 +39,59 @@ constexpr uint32_t kServerStreamingMethodId = 112; class FakeGeneratedServiceClient { public: - static PwpbUnaryReceiver<test::TestResponse::Message> TestUnaryRpc( + static PwpbUnaryReceiver<TestResponse::Message> TestUnaryRpc( Client& client, uint32_t channel_id, - const test::TestRequest::Message& request, - Function<void(const test::TestResponse::Message&, Status)> on_response, + const TestRequest::Message& request, + Function<void(const TestResponse::Message&, Status)> on_response, Function<void(Status)> on_error = nullptr) { - return internal::PwpbUnaryResponseClientCall<test::TestResponse::Message>:: - Start<PwpbUnaryReceiver<test::TestResponse::Message>>( - client, - channel_id, - kServiceId, - kUnaryMethodId, - internal::kPwpbMethodSerde<&test::TestRequest::kMessageFields, - &test::TestResponse::kMessageFields>, - std::move(on_response), - std::move(on_error), - request); + return internal::PwpbUnaryResponseClientCall<TestResponse::Message>::Start< + PwpbUnaryReceiver<TestResponse::Message>>( + client, + channel_id, + kServiceId, + kUnaryMethodId, + internal::kPwpbMethodSerde<&TestRequest::kMessageFields, + &TestResponse::kMessageFields>, + std::move(on_response), + std::move(on_error), + request); } - static PwpbUnaryReceiver<test::TestResponse::Message> TestAnotherUnaryRpc( + static PwpbUnaryReceiver<TestResponse::Message> TestAnotherUnaryRpc( Client& client, uint32_t channel_id, - const test::TestRequest::Message& request, - Function<void(const test::TestResponse::Message&, Status)> on_response, + const TestRequest::Message& request, + Function<void(const TestResponse::Message&, Status)> on_response, Function<void(Status)> on_error = nullptr) { - return internal::PwpbUnaryResponseClientCall<test::TestResponse::Message>:: - Start<PwpbUnaryReceiver<test::TestResponse::Message>>( - client, - channel_id, - kServiceId, - kUnaryMethodId, - internal::kPwpbMethodSerde<&test::TestRequest::kMessageFields, - &test::TestResponse::kMessageFields>, - std::move(on_response), - std::move(on_error), - request); + return internal::PwpbUnaryResponseClientCall<TestResponse::Message>::Start< + PwpbUnaryReceiver<TestResponse::Message>>( + client, + channel_id, + kServiceId, + kUnaryMethodId, + internal::kPwpbMethodSerde<&TestRequest::kMessageFields, + &TestResponse::kMessageFields>, + std::move(on_response), + std::move(on_error), + request); } - static PwpbClientReader<test::TestStreamResponse::Message> - TestServerStreamRpc( + static PwpbClientReader<TestStreamResponse::Message> TestServerStreamRpc( Client& client, uint32_t channel_id, - const test::TestRequest::Message& request, - Function<void(const test::TestStreamResponse::Message&)> on_response, + const TestRequest::Message& request, + Function<void(const TestStreamResponse::Message&)> on_response, Function<void(Status)> on_stream_end, Function<void(Status)> on_error = nullptr) { - return internal:: - PwpbStreamResponseClientCall<test::TestStreamResponse::Message>::Start< - PwpbClientReader<test::TestStreamResponse::Message>>( + return internal::PwpbStreamResponseClientCall<TestStreamResponse::Message>:: + Start<PwpbClientReader<TestStreamResponse::Message>>( client, channel_id, kServiceId, kServerStreamingMethodId, - internal::kPwpbMethodSerde< - &test::TestRequest::kMessageFields, - &test::TestStreamResponse::kMessageFields>, + internal::kPwpbMethodSerde<&TestRequest::kMessageFields, + &TestStreamResponse::kMessageFields>, std::move(on_response), std::move(on_stream_end), std::move(on_error), @@ -112,7 +114,7 @@ TEST(PwpbClientCall, Unary_SendsRequestPacket) { EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kUnaryMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 123); } @@ -131,13 +133,13 @@ TEST_F(UnaryClientCall, InvokesCallbackOnValidResponse) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [this](const test::TestResponse::Message& response, Status status) { + [this](const TestResponse::Message& response, Status status) { ++responses_received_; last_status_ = status; last_response_value_ = response.value; }); - PW_ENCODE_PB(test::TestResponse, response, .value = 42); + PW_ENCODE_PB(TestResponse, response, .value = 42); EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response)); ASSERT_EQ(responses_received_, 1); @@ -154,7 +156,7 @@ TEST_F(UnaryClientCall, DoesNothingOnNullCallback) { {.integer = 123, .status_code = 0}, nullptr); - PW_ENCODE_PB(test::TestResponse, response, .value = 42); + PW_ENCODE_PB(TestResponse, response, .value = 42); EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response)); ASSERT_EQ(responses_received_, 0); @@ -167,7 +169,7 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnInvalidResponse) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [this](const test::TestResponse::Message& response, Status status) { + [this](const TestResponse::Message& response, Status status) { ++responses_received_; last_status_ = status; last_response_value_ = response.value; @@ -190,7 +192,7 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnServerError) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [this](const test::TestResponse::Message& response, Status status) { + [this](const TestResponse::Message& response, Status status) { ++responses_received_; last_status_ = status; last_response_value_ = response.value; @@ -198,8 +200,7 @@ TEST_F(UnaryClientCall, InvokesErrorCallbackOnServerError) { [this](Status status) { last_error_ = status; }); EXPECT_EQ(OkStatus(), - context.SendPacket(internal::PacketType::SERVER_ERROR, - Status::NotFound())); + context.SendPacket(PacketType::SERVER_ERROR, Status::NotFound())); EXPECT_EQ(responses_received_, 0); EXPECT_EQ(last_error_, Status::NotFound()); @@ -212,7 +213,7 @@ TEST_F(UnaryClientCall, DoesNothingOnErrorWithoutCallback) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [this](const test::TestResponse::Message& response, Status status) { + [this](const TestResponse::Message& response, Status status) { ++responses_received_; last_status_ = status; last_response_value_ = response.value; @@ -232,17 +233,17 @@ TEST_F(UnaryClientCall, OnlyReceivesOneResponse) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [this](const test::TestResponse::Message& response, Status status) { + [this](const TestResponse::Message& response, Status status) { ++responses_received_; last_status_ = status; last_response_value_ = response.value; }); - PW_ENCODE_PB(test::TestResponse, r1, .value = 42); + PW_ENCODE_PB(TestResponse, r1, .value = 42); EXPECT_EQ(OkStatus(), context.SendResponse(Status::Unimplemented(), r1)); - PW_ENCODE_PB(test::TestResponse, r2, .value = 44); + PW_ENCODE_PB(TestResponse, r2, .value = 44); EXPECT_EQ(OkStatus(), context.SendResponse(Status::OutOfRange(), r2)); - PW_ENCODE_PB(test::TestResponse, r3, .value = 46); + PW_ENCODE_PB(TestResponse, r3, .value = 46); EXPECT_EQ(OkStatus(), context.SendResponse(Status::Internal(), r3)); EXPECT_EQ(responses_received_, 1); @@ -275,7 +276,7 @@ TEST_F(ServerStreamingClientCall, SendsRequestPacket) { EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kServerStreamingMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 71); } @@ -286,7 +287,7 @@ TEST_F(ServerStreamingClientCall, InvokesCallbackOnValidResponse) { context.client(), context.channel().id(), {.integer = 71, .status_code = 0}, - [this](const test::TestStreamResponse::Message& response) { + [this](const TestStreamResponse::Message& response) { ++responses_received_; last_response_number_ = response.number; }, @@ -295,19 +296,19 @@ TEST_F(ServerStreamingClientCall, InvokesCallbackOnValidResponse) { stream_status_ = status; }); - PW_ENCODE_PB(test::TestStreamResponse, r1, .chunk = {}, .number = 11u); + PW_ENCODE_PB(TestStreamResponse, r1, .chunk = {}, .number = 11u); EXPECT_EQ(OkStatus(), context.SendServerStream(r1)); EXPECT_TRUE(active_); EXPECT_EQ(responses_received_, 1); EXPECT_EQ(last_response_number_, 11); - PW_ENCODE_PB(test::TestStreamResponse, r2, .chunk = {}, .number = 22u); + PW_ENCODE_PB(TestStreamResponse, r2, .chunk = {}, .number = 22u); EXPECT_EQ(OkStatus(), context.SendServerStream(r2)); EXPECT_TRUE(active_); EXPECT_EQ(responses_received_, 2); EXPECT_EQ(last_response_number_, 22); - PW_ENCODE_PB(test::TestStreamResponse, r3, .chunk = {}, .number = 33u); + PW_ENCODE_PB(TestStreamResponse, r3, .chunk = {}, .number = 33u); EXPECT_EQ(OkStatus(), context.SendServerStream(r3)); EXPECT_TRUE(active_); EXPECT_EQ(responses_received_, 3); @@ -321,7 +322,7 @@ TEST_F(ServerStreamingClientCall, InvokesStreamEndOnFinish) { context.client(), context.channel().id(), {.integer = 71, .status_code = 0}, - [this](const test::TestStreamResponse::Message& response) { + [this](const TestStreamResponse::Message& response) { ++responses_received_; last_response_number_ = response.number; }, @@ -330,18 +331,18 @@ TEST_F(ServerStreamingClientCall, InvokesStreamEndOnFinish) { stream_status_ = status; }); - PW_ENCODE_PB(test::TestStreamResponse, r1, .chunk = {}, .number = 11u); + PW_ENCODE_PB(TestStreamResponse, r1, .chunk = {}, .number = 11u); EXPECT_EQ(OkStatus(), context.SendServerStream(r1)); EXPECT_TRUE(active_); - PW_ENCODE_PB(test::TestStreamResponse, r2, .chunk = {}, .number = 22u); + PW_ENCODE_PB(TestStreamResponse, r2, .chunk = {}, .number = 22u); EXPECT_EQ(OkStatus(), context.SendServerStream(r2)); EXPECT_TRUE(active_); // Close the stream. EXPECT_EQ(OkStatus(), context.SendResponse(Status::NotFound())); - PW_ENCODE_PB(test::TestStreamResponse, r3, .chunk = {}, .number = 33u); + PW_ENCODE_PB(TestStreamResponse, r3, .chunk = {}, .number = 33u); EXPECT_EQ(OkStatus(), context.SendServerStream(r3)); EXPECT_FALSE(active_); @@ -355,14 +356,14 @@ TEST_F(ServerStreamingClientCall, InvokesErrorCallbackOnInvalidResponses) { context.client(), context.channel().id(), {.integer = 71, .status_code = 0}, - [this](const test::TestStreamResponse::Message& response) { + [this](const TestStreamResponse::Message& response) { ++responses_received_; last_response_number_ = response.number; }, nullptr, [this](Status error) { rpc_error_ = error; }); - PW_ENCODE_PB(test::TestStreamResponse, r1, .chunk = {}, .number = 11u); + PW_ENCODE_PB(TestStreamResponse, r1, .chunk = {}, .number = 11u); EXPECT_EQ(OkStatus(), context.SendServerStream(r1)); EXPECT_TRUE(active_); EXPECT_EQ(responses_received_, 1); @@ -375,15 +376,14 @@ TEST_F(ServerStreamingClientCall, InvokesErrorCallbackOnInvalidResponses) { ASSERT_TRUE(rpc_error_.has_value()); EXPECT_EQ(rpc_error_, Status::DataLoss()); - PW_ENCODE_PB(test::TestStreamResponse, r2, .chunk = {}, .number = 22u); + PW_ENCODE_PB(TestStreamResponse, r2, .chunk = {}, .number = 22u); EXPECT_EQ(OkStatus(), context.SendServerStream(r2)); EXPECT_TRUE(active_); EXPECT_EQ(responses_received_, 2); EXPECT_EQ(last_response_number_, 22); EXPECT_EQ(OkStatus(), - context.SendPacket(internal::PacketType::SERVER_ERROR, - Status::NotFound())); + context.SendPacket(PacketType::SERVER_ERROR, Status::NotFound())); EXPECT_EQ(responses_received_, 2); EXPECT_EQ(rpc_error_, Status::NotFound()); } diff --git a/pw_rpc/pwpb/client_reader_writer_test.cc b/pw_rpc/pwpb/client_reader_writer_test.cc index b4d53a39f..540f0106d 100644 --- a/pw_rpc/pwpb/client_reader_writer_test.cc +++ b/pw_rpc/pwpb/client_reader_writer_test.cc @@ -28,6 +28,10 @@ namespace { using test::pw_rpc::pwpb::TestService; +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + void FailIfCalled(Status) { FAIL(); } template <typename T> void FailIfOnNextCalled(const T&) { @@ -39,21 +43,19 @@ void FailIfOnCompletedCalled(const T&, Status) { } TEST(PwpbUnaryReceiver, DefaultConstructed) { - PwpbUnaryReceiver<test::TestResponse::Message> call; + PwpbUnaryReceiver<TestResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); - call.set_on_completed([](const test::TestResponse::Message&, Status) {}); + call.set_on_completed([](const TestResponse::Message&, Status) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientWriter, DefaultConstructed) { - PwpbClientWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> - call; + PwpbClientWriter<TestRequest::Message, TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); @@ -62,13 +64,12 @@ TEST(PwpbClientWriter, DefaultConstructed) { EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); EXPECT_EQ(Status::FailedPrecondition(), call.CloseClientStream()); - call.set_on_completed( - [](const test::TestStreamResponse::Message&, Status) {}); + call.set_on_completed([](const TestStreamResponse::Message&, Status) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientReader, DefaultConstructed) { - PwpbClientReader<test::TestStreamResponse::Message> call; + PwpbClientReader<TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); @@ -76,13 +77,12 @@ TEST(PwpbClientReader, DefaultConstructed) { EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); call.set_on_completed([](Status) {}); - call.set_on_next([](const test::TestStreamResponse::Message&) {}); + call.set_on_next([](const TestStreamResponse::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientReaderWriter, DefaultConstructed) { - PwpbClientReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> + PwpbClientReaderWriter<TestRequest::Message, TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); @@ -93,19 +93,18 @@ TEST(PwpbClientReaderWriter, DefaultConstructed) { EXPECT_EQ(Status::FailedPrecondition(), call.CloseClientStream()); call.set_on_completed([](Status) {}); - call.set_on_next([](const test::TestStreamResponse::Message&) {}); + call.set_on_next([](const TestStreamResponse::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbUnaryReceiver, Closed) { PwpbClientTestContext ctx; - PwpbUnaryReceiver<test::TestResponse::Message> call = - TestService::TestUnaryRpc( - ctx.client(), - ctx.channel().id(), - {}, - FailIfOnCompletedCalled<test::TestResponse::Message>, - FailIfCalled); + PwpbUnaryReceiver<TestResponse::Message> call = + TestService::TestUnaryRpc(ctx.client(), + ctx.channel().id(), + {}, + FailIfOnCompletedCalled<TestResponse::Message>, + FailIfCalled); ASSERT_EQ(OkStatus(), call.Cancel()); ASSERT_FALSE(call.active()); @@ -113,18 +112,17 @@ TEST(PwpbUnaryReceiver, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); - call.set_on_completed([](const test::TestResponse::Message&, Status) {}); + call.set_on_completed([](const TestResponse::Message&, Status) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientWriter, Closed) { PwpbClientTestContext ctx; - PwpbClientWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> - call = TestService::TestClientStreamRpc( + PwpbClientWriter<TestRequest::Message, TestStreamResponse::Message> call = + TestService::TestClientStreamRpc( ctx.client(), ctx.channel().id(), - FailIfOnCompletedCalled<test::TestStreamResponse::Message>, + FailIfOnCompletedCalled<TestStreamResponse::Message>, FailIfCalled); ASSERT_EQ(OkStatus(), call.Cancel()); @@ -135,19 +133,18 @@ TEST(PwpbClientWriter, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); EXPECT_EQ(Status::FailedPrecondition(), call.CloseClientStream()); - call.set_on_completed( - [](const test::TestStreamResponse::Message&, Status) {}); + call.set_on_completed([](const TestStreamResponse::Message&, Status) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientReader, Closed) { PwpbClientTestContext ctx; - PwpbClientReader<test::TestStreamResponse::Message> call = + PwpbClientReader<TestStreamResponse::Message> call = TestService::TestServerStreamRpc( ctx.client(), ctx.channel().id(), {}, - FailIfOnNextCalled<test::TestStreamResponse::Message>, + FailIfOnNextCalled<TestStreamResponse::Message>, FailIfCalled, FailIfCalled); ASSERT_EQ(OkStatus(), call.Cancel()); @@ -158,18 +155,17 @@ TEST(PwpbClientReader, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.Cancel()); call.set_on_completed([](Status) {}); - call.set_on_next([](const test::TestStreamResponse::Message&) {}); + call.set_on_next([](const TestStreamResponse::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbClientReaderWriter, Closed) { PwpbClientTestContext ctx; - PwpbClientReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> + PwpbClientReaderWriter<TestRequest::Message, TestStreamResponse::Message> call = TestService::TestBidirectionalStreamRpc( ctx.client(), ctx.channel().id(), - FailIfOnNextCalled<test::TestStreamResponse::Message>, + FailIfOnNextCalled<TestStreamResponse::Message>, FailIfCalled, FailIfCalled); ASSERT_EQ(OkStatus(), call.Cancel()); @@ -182,7 +178,7 @@ TEST(PwpbClientReaderWriter, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.CloseClientStream()); call.set_on_completed([](Status) {}); - call.set_on_next([](const test::TestStreamResponse::Message&) {}); + call.set_on_next([](const TestStreamResponse::Message&) {}); call.set_on_error([](Status) {}); } @@ -190,17 +186,17 @@ TEST(PwpbUnaryReceiver, CallbacksMoveCorrectly) { PwpbClientTestContext ctx; struct { - test::TestResponse::Message payload = {.value = 12345678}; + TestResponse::Message payload = {.value = 12345678}; std::optional<Status> status; } reply; - PwpbUnaryReceiver<test::TestResponse::Message> call_2; + PwpbUnaryReceiver<TestResponse::Message> call_2; { PwpbUnaryReceiver call_1 = TestService::TestUnaryRpc( ctx.client(), ctx.channel().id(), {}, - [&reply](const test::TestResponse::Message& response, Status status) { + [&reply](const TestResponse::Message& response, Status status) { reply.payload = response; reply.status = status; }); @@ -217,16 +213,15 @@ TEST(PwpbUnaryReceiver, CallbacksMoveCorrectly) { TEST(PwpbClientReaderWriter, CallbacksMoveCorrectly) { PwpbClientTestContext ctx; - test::TestStreamResponse::Message payload = {.chunk = {}, .number = 13579}; + TestStreamResponse::Message payload = {.chunk = {}, .number = 13579}; - PwpbClientReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> + PwpbClientReaderWriter<TestRequest::Message, TestStreamResponse::Message> call_2; { PwpbClientReaderWriter call_1 = TestService::TestBidirectionalStreamRpc( ctx.client(), ctx.channel().id(), - [&payload](const test::TestStreamResponse::Message& response) { + [&payload](const TestStreamResponse::Message& response) { payload = response; }); diff --git a/pw_rpc/pwpb/client_server_context_test.cc b/pw_rpc/pwpb/client_server_context_test.cc index 092313119..bd45154ef 100644 --- a/pw_rpc/pwpb/client_server_context_test.cc +++ b/pw_rpc/pwpb/client_server_context_test.cc @@ -17,6 +17,14 @@ #include "pw_rpc_test_protos/test.rpc.pwpb.h" namespace pw::rpc { +namespace { + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + +} // namespace + namespace test { using GeneratedService = ::pw::rpc::test::pw_rpc::pwpb::TestService; @@ -51,12 +59,11 @@ TEST(PwpbClientServerTestContext, ReceivesUnaryRpcReponse) { test::TestService service; ctx.server().RegisterService(service); - test::TestResponse::Message response = {}; - auto handler = [&response](const test::TestResponse::Message& server_response, + TestResponse::Message response = {}; + auto handler = [&response](const TestResponse::Message& server_response, pw::Status) { response = server_response; }; - test::TestRequest::Message request{.integer = 1, - .status_code = OkStatus().code()}; + TestRequest::Message request{.integer = 1, .status_code = OkStatus().code()}; auto call = test::GeneratedService::TestUnaryRpc( ctx.client(), ctx.channel().id(), request, handler); // Force manual forwarding of packets as context is not threaded @@ -77,19 +84,15 @@ TEST(PwpbClientServerTestContext, ReceivesMultipleReponses) { test::TestService service; ctx.server().RegisterService(service); - test::TestResponse::Message response1 = {}; - test::TestResponse::Message response2 = {}; - auto handler1 = [&response1]( - const test::TestResponse::Message& server_response, - pw::Status) { response1 = server_response; }; - auto handler2 = [&response2]( - const test::TestResponse::Message& server_response, - pw::Status) { response2 = server_response; }; - - test::TestRequest::Message request1{.integer = 1, - .status_code = OkStatus().code()}; - test::TestRequest::Message request2{.integer = 2, - .status_code = OkStatus().code()}; + TestResponse::Message response1 = {}; + TestResponse::Message response2 = {}; + auto handler1 = [&response1](const TestResponse::Message& server_response, + pw::Status) { response1 = server_response; }; + auto handler2 = [&response2](const TestResponse::Message& server_response, + pw::Status) { response2 = server_response; }; + + TestRequest::Message request1{.integer = 1, .status_code = OkStatus().code()}; + TestRequest::Message request2{.integer = 2, .status_code = OkStatus().code()}; const auto call1 = test::GeneratedService::TestUnaryRpc( ctx.client(), ctx.channel().id(), request1, handler1); // Force manual forwarding of packets as context is not threaded diff --git a/pw_rpc/pwpb/client_server_context_threaded_test.cc b/pw_rpc/pwpb/client_server_context_threaded_test.cc index baadc18f9..ae1306df3 100644 --- a/pw_rpc/pwpb/client_server_context_threaded_test.cc +++ b/pw_rpc/pwpb/client_server_context_threaded_test.cc @@ -19,6 +19,14 @@ #include "pw_thread/test_threads.h" namespace pw::rpc { +namespace { + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + +} // namespace + namespace test { using GeneratedService = ::pw::rpc::test::pw_rpc::pwpb::TestService; @@ -51,15 +59,13 @@ namespace { class RpcCaller { public: void BlockOnResponse(uint32_t i, Client& client, uint32_t channel_id) { - test::TestRequest::Message request{.integer = i, - .status_code = OkStatus().code()}; + TestRequest::Message request{.integer = i, + .status_code = OkStatus().code()}; auto call = test::GeneratedService::TestUnaryRpc( client, channel_id, request, - [this](const test::TestResponse::Message&, Status) { - semaphore_.release(); - }, + [this](const TestResponse::Message&, Status) { semaphore_.release(); }, [](Status) {}); semaphore_.acquire(); diff --git a/pw_rpc/pwpb/codegen_test.cc b/pw_rpc/pwpb/codegen_test.cc index ebe883929..d85760350 100644 --- a/pw_rpc/pwpb/codegen_test.cc +++ b/pw_rpc/pwpb/codegen_test.cc @@ -29,23 +29,23 @@ namespace test { class TestService final : public pw_rpc::pwpb::TestService::Service<TestService> { public: - Status TestUnaryRpc(const TestRequest::Message& request, - TestResponse::Message& response) { + Status TestUnaryRpc(const pwpb::TestRequest::Message& request, + pwpb::TestResponse::Message& response) { response.value = request.integer + 1; return static_cast<Status::Code>(request.status_code); } void TestAnotherUnaryRpc( - const TestRequest::Message& request, - PwpbUnaryResponder<TestResponse::Message>& responder) { - TestResponse::Message response{}; + const pwpb::TestRequest::Message& request, + PwpbUnaryResponder<pwpb::TestResponse::Message>& responder) { + pwpb::TestResponse::Message response{}; EXPECT_EQ(OkStatus(), responder.Finish(response, TestUnaryRpc(request, response))); } static void TestServerStreamRpc( - const TestRequest::Message& request, - ServerWriter<TestStreamResponse::Message>& writer) { + const pwpb::TestRequest::Message& request, + ServerWriter<pwpb::TestStreamResponse::Message>& writer) { for (int i = 0; i < request.integer; ++i) { EXPECT_EQ( OkStatus(), @@ -57,19 +57,22 @@ class TestService final } void TestClientStreamRpc( - ServerReader<TestRequest::Message, TestStreamResponse::Message>& - new_reader) { + ServerReader<pwpb::TestRequest::Message, + pwpb::TestStreamResponse::Message>& new_reader) { reader = std::move(new_reader); } void TestBidirectionalStreamRpc( - ServerReaderWriter<TestRequest::Message, TestStreamResponse::Message>& + ServerReaderWriter<pwpb::TestRequest::Message, + pwpb::TestStreamResponse::Message>& new_reader_writer) { reader_writer = std::move(new_reader_writer); } - ServerReader<TestRequest::Message, TestStreamResponse::Message> reader; - ServerReaderWriter<TestRequest::Message, TestStreamResponse::Message> + ServerReader<pwpb::TestRequest::Message, pwpb::TestStreamResponse::Message> + reader; + ServerReaderWriter<pwpb::TestRequest::Message, + pwpb::TestStreamResponse::Message> reader_writer; }; @@ -164,9 +167,11 @@ TEST(PwpbCodegen, Server_InvokeClientStreamingRpc) { context.call(); - test::TestRequest::Message request = {}; + test::pwpb::TestRequest::Message request = {}; context.service().reader.set_on_next( - [&request](const test::TestRequest::Message& req) { request = req; }); + [&request](const test::pwpb::TestRequest::Message& req) { + request = req; + }); context.SendClientStream({.integer = -99, .status_code = 10}); EXPECT_EQ(request.integer, -99); @@ -185,9 +190,11 @@ TEST(PwpbCodegen, Server_InvokeBidirectionalStreamingRpc) { context.call(); - test::TestRequest::Message request = {}; + test::pwpb::TestRequest::Message request = {}; context.service().reader_writer.set_on_next( - [&request](const test::TestRequest::Message& req) { request = req; }); + [&request](const test::pwpb::TestRequest::Message& req) { + request = req; + }); context.SendClientStream({.integer = -99, .status_code = 10}); EXPECT_EQ(request.integer, -99); @@ -203,8 +210,9 @@ TEST(PwpbCodegen, Server_InvokeBidirectionalStreamingRpc) { } TEST(PwpbCodegen, ClientCall_DefaultConstructor) { - PwpbUnaryReceiver<test::TestResponse::Message> unary_call; - PwpbClientReader<test::TestStreamResponse::Message> server_streaming_call; + PwpbUnaryReceiver<test::pwpb::TestResponse::Message> unary_call; + PwpbClientReader<test::pwpb::TestStreamResponse::Message> + server_streaming_call; } using TestServiceClient = test::pw_rpc::pwpb::TestService::Client; @@ -224,7 +232,8 @@ TEST(PwpbCodegen, Client_InvokesUnaryRpcWithCallback) { auto call = test_client.TestUnaryRpc( {.integer = 123, .status_code = 0}, - [&result](const test::TestResponse::Message& response, Status status) { + [&result](const test::pwpb::TestResponse::Message& response, + Status status) { result.last_status = status; result.response_value = response.value; }); @@ -238,10 +247,10 @@ TEST(PwpbCodegen, Client_InvokesUnaryRpcWithCallback) { EXPECT_EQ(packet.channel_id(), context.channel().id()); EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(test::pwpb::TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 123); - PW_ENCODE_PB(test::TestResponse, response, .value = 42); + PW_ENCODE_PB(test::pwpb::TestResponse, response, .value = 42); EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response)); EXPECT_EQ(result.last_status, OkStatus()); EXPECT_EQ(result.response_value, 42); @@ -265,7 +274,7 @@ TEST(PwpbCodegen, Client_InvokesServerStreamingRpcWithCallback) { auto call = test_client.TestServerStreamRpc( {.integer = 123, .status_code = 0}, - [&result](const test::TestStreamResponse::Message& response) { + [&result](const test::pwpb::TestStreamResponse::Message& response) { result.active = true; result.response_value = response.number; }, @@ -283,10 +292,11 @@ TEST(PwpbCodegen, Client_InvokesServerStreamingRpcWithCallback) { EXPECT_EQ(packet.channel_id(), context.channel().id()); EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(test::pwpb::TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 123); - PW_ENCODE_PB(test::TestStreamResponse, response, .chunk = {}, .number = 11u); + PW_ENCODE_PB( + test::pwpb::TestStreamResponse, response, .chunk = {}, .number = 11u); EXPECT_EQ(OkStatus(), context.SendServerStream(response)); EXPECT_TRUE(result.active); EXPECT_EQ(result.response_value, 11); @@ -311,7 +321,8 @@ TEST(PwpbCodegen, Client_StaticMethod_InvokesUnaryRpcWithCallback) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [&result](const test::TestResponse::Message& response, Status status) { + [&result](const test::pwpb::TestResponse::Message& response, + Status status) { result.last_status = status; result.response_value = response.value; }); @@ -325,10 +336,10 @@ TEST(PwpbCodegen, Client_StaticMethod_InvokesUnaryRpcWithCallback) { EXPECT_EQ(packet.channel_id(), context.channel().id()); EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(test::pwpb::TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 123); - PW_ENCODE_PB(test::TestResponse, response, .value = 42); + PW_ENCODE_PB(test::pwpb::TestResponse, response, .value = 42); EXPECT_EQ(OkStatus(), context.SendResponse(OkStatus(), response)); EXPECT_EQ(result.last_status, OkStatus()); EXPECT_EQ(result.response_value, 42); @@ -350,7 +361,7 @@ TEST(PwpbCodegen, Client_StaticMethod_InvokesServerStreamingRpcWithCallback) { context.client(), context.channel().id(), {.integer = 123, .status_code = 0}, - [&result](const test::TestStreamResponse::Message& response) { + [&result](const test::pwpb::TestStreamResponse::Message& response) { result.active = true; result.response_value = response.number; }, @@ -368,10 +379,11 @@ TEST(PwpbCodegen, Client_StaticMethod_InvokesServerStreamingRpcWithCallback) { EXPECT_EQ(packet.channel_id(), context.channel().id()); EXPECT_EQ(packet.service_id(), kServiceId); EXPECT_EQ(packet.method_id(), kMethodId); - PW_DECODE_PB(test::TestRequest, sent_proto, packet.payload()); + PW_DECODE_PB(test::pwpb::TestRequest, sent_proto, packet.payload()); EXPECT_EQ(sent_proto.integer, 123); - PW_ENCODE_PB(test::TestStreamResponse, response, .chunk = {}, .number = 11u); + PW_ENCODE_PB( + test::pwpb::TestStreamResponse, response, .chunk = {}, .number = 11u); EXPECT_EQ(OkStatus(), context.SendServerStream(response)); EXPECT_TRUE(result.active); EXPECT_EQ(result.response_value, 11); diff --git a/pw_rpc/pwpb/fake_channel_output_test.cc b/pw_rpc/pwpb/fake_channel_output_test.cc index 5aaf2b843..8cdeb7302 100644 --- a/pw_rpc/pwpb/fake_channel_output_test.cc +++ b/pw_rpc/pwpb/fake_channel_output_test.cc @@ -29,8 +29,9 @@ PW_MODIFY_DIAGNOSTIC(ignored, "-Wmissing-field-initializers"); namespace pw::rpc::internal::test { namespace { -using rpc::test::pw_rpc::pwpb::TestService; -using Info = internal::MethodInfo<TestService::TestUnaryRpc>; +using ::pw::rpc::internal::pwpb::PacketType; +using ::pw::rpc::test::pw_rpc::pwpb::TestService; +using Info = ::pw::rpc::internal::MethodInfo<TestService::TestUnaryRpc>; TEST(PwpbFakeChannelOutput, Requests) { PwpbFakeChannelOutput<1> output; diff --git a/pw_rpc/pwpb/method_info_test.cc b/pw_rpc/pwpb/method_info_test.cc index 4e9627206..8102be561 100644 --- a/pw_rpc/pwpb/method_info_test.cc +++ b/pw_rpc/pwpb/method_info_test.cc @@ -20,6 +20,15 @@ #include "pw_status/status.h" namespace pw::rpc { + +namespace test { + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + +} // namespace test + namespace { class TestService final diff --git a/pw_rpc/pwpb/method_lookup_test.cc b/pw_rpc/pwpb/method_lookup_test.cc index 1b3c88412..d0a578e6a 100644 --- a/pw_rpc/pwpb/method_lookup_test.cc +++ b/pw_rpc/pwpb/method_lookup_test.cc @@ -20,6 +20,10 @@ namespace pw::rpc { namespace { +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + class MixedService1 : public test::pw_rpc::pwpb::TestService::Service<MixedService1> { public: @@ -28,13 +32,13 @@ class MixedService1 ASSERT_EQ(OkStatus(), responder.Finish(response, OkStatus())); } - void TestAnotherUnaryRpc(const test::TestRequest::Message&, - PwpbUnaryResponder<test::TestResponse::Message>&) { + void TestAnotherUnaryRpc(const TestRequest::Message&, + PwpbUnaryResponder<TestResponse::Message>&) { called_async_unary_method = true; } - void TestServerStreamRpc(const test::TestRequest::Message&, - ServerWriter<test::TestStreamResponse::Message>&) { + void TestServerStreamRpc(const TestRequest::Message&, + ServerWriter<TestStreamResponse::Message>&) { called_server_streaming_method = true; } @@ -43,8 +47,7 @@ class MixedService1 } void TestBidirectionalStreamRpc( - ServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>&) { + ServerReaderWriter<TestRequest::Message, TestStreamResponse::Message>&) { called_bidirectional_streaming_method = true; } @@ -57,8 +60,7 @@ class MixedService1 class MixedService2 : public test::pw_rpc::pwpb::TestService::Service<MixedService2> { public: - Status TestUnaryRpc(const test::TestRequest::Message&, - test::TestResponse::Message&) { + Status TestUnaryRpc(const TestRequest::Message&, TestResponse::Message&) { return Status::Unauthenticated(); } @@ -70,8 +72,8 @@ class MixedService2 called_server_streaming_method = true; } - void TestClientStreamRpc(ServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message>&) { + void TestClientStreamRpc( + ServerReader<TestRequest::Message, TestStreamResponse::Message>&) { called_client_streaming_method = true; } diff --git a/pw_rpc/pwpb/method_test.cc b/pw_rpc/pwpb/method_test.cc index 3a31d0956..76f728f59 100644 --- a/pw_rpc/pwpb/method_test.cc +++ b/pw_rpc/pwpb/method_test.cc @@ -120,44 +120,45 @@ class FakeServiceBase : public Service { static constexpr std::array<PwpbMethodUnion, 5> kMethods = { PwpbMethod::SynchronousUnary<&Impl::DoNothing>( 10u, - kPwpbMethodSerde<&pw::rpc::test::Empty::kMessageFields, - &pw::rpc::test::Empty::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::Empty::kMessageFields, + &pw::rpc::test::pwpb::Empty::kMessageFields>), PwpbMethod::AsynchronousUnary<&Impl::AddFive>( 11u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), PwpbMethod::ServerStreaming<&Impl::StartStream>( 12u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), PwpbMethod::ClientStreaming<&Impl::ClientStream>( 13u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), PwpbMethod::BidirectionalStreaming<&Impl::BidirectionalStream>( 14u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>)}; + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), + }; }; class FakeService : public FakeServiceBase<FakeService> { public: FakeService(uint32_t id) : FakeServiceBase(id) {} - Status DoNothing(const pw::rpc::test::Empty::Message&, - pw::rpc::test::Empty::Message&) { + Status DoNothing(const pw::rpc::test::pwpb::Empty::Message&, + pw::rpc::test::pwpb::Empty::Message&) { return Status::Unknown(); } - void AddFive( - const pw::rpc::test::TestRequest::Message& request, - PwpbUnaryResponder<pw::rpc::test::TestResponse::Message>& responder) { + void AddFive(const pw::rpc::test::pwpb::TestRequest::Message& request, + PwpbUnaryResponder<pw::rpc::test::pwpb::TestResponse::Message>& + responder) { last_request = request; if (fail_to_encode_async_unary_response) { - pw::rpc::test::TestResponse::Message response = {}; + pw::rpc::test::pwpb::TestResponse::Message response = {}; response.repeated_field.SetEncoder( - [](const pw::rpc::test::TestResponse::StreamEncoder&) { + [](const pw::rpc::test::pwpb::TestResponse::StreamEncoder&) { return Status::Internal(); }); ASSERT_EQ(OkStatus(), responder.Finish(response, Status::NotFound())); @@ -170,34 +171,34 @@ class FakeService : public FakeServiceBase<FakeService> { } void StartStream( - const pw::rpc::test::TestRequest::Message& request, - PwpbServerWriter<pw::rpc::test::TestResponse::Message>& writer) { + const pw::rpc::test::pwpb::TestRequest::Message& request, + PwpbServerWriter<pw::rpc::test::pwpb::TestResponse::Message>& writer) { last_request = request; last_writer = std::move(writer); } void ClientStream( - PwpbServerReader<pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message>& reader) { + PwpbServerReader<pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message>& reader) { last_reader = std::move(reader); } void BidirectionalStream( - PwpbServerReaderWriter<pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message>& + PwpbServerReaderWriter<pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message>& reader_writer) { last_reader_writer = std::move(reader_writer); } bool fail_to_encode_async_unary_response = false; - pw::rpc::test::TestRequest::Message last_request; - PwpbServerWriter<pw::rpc::test::TestResponse::Message> last_writer; - PwpbServerReader<pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message> + pw::rpc::test::pwpb::TestRequest::Message last_request; + PwpbServerWriter<pw::rpc::test::pwpb::TestResponse::Message> last_writer; + PwpbServerReader<pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message> last_reader; - PwpbServerReaderWriter<pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message> + PwpbServerReaderWriter<pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message> last_reader_writer; }; @@ -213,8 +214,10 @@ constexpr const PwpbMethod& kBidirectionalStream = std::get<4>(FakeServiceBase<FakeService>::kMethods).pwpb_method(); TEST(PwpbMethod, AsyncUnaryRpc_SendsResponse) { - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = 123, .status_code = 0); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = 123, + .status_code = 0); ServerContextForTest<FakeService> context(kAsyncUnary); rpc_lock().lock(); @@ -242,7 +245,7 @@ TEST(PwpbMethod, SyncUnaryRpc_InvalidPayload_SendsError) { kSyncUnary.Invoke(context.get(), context.request(bad_payload)); const Packet& packet = context.output().last_packet(); - EXPECT_EQ(PacketType::SERVER_ERROR, packet.type()); + EXPECT_EQ(pwpb::PacketType::SERVER_ERROR, packet.type()); EXPECT_EQ(Status::DataLoss(), packet.status()); EXPECT_EQ(context.service_id(), packet.service_id()); EXPECT_EQ(kSyncUnary.id(), packet.method_id()); @@ -250,8 +253,10 @@ TEST(PwpbMethod, SyncUnaryRpc_InvalidPayload_SendsError) { TEST(PwpbMethod, AsyncUnaryRpc_ResponseEncodingFails_SendsInternalError) { constexpr int64_t value = 0x7FFFFFFF'FFFFFF00ll; - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = value, .status_code = 0); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = value, + .status_code = 0); ServerContextForTest<FakeService> context(kAsyncUnary); context.service().fail_to_encode_async_unary_response = true; @@ -260,7 +265,7 @@ TEST(PwpbMethod, AsyncUnaryRpc_ResponseEncodingFails_SendsInternalError) { kAsyncUnary.Invoke(context.get(), context.request(request)); const Packet& packet = context.output().last_packet(); - EXPECT_EQ(PacketType::SERVER_ERROR, packet.type()); + EXPECT_EQ(pwpb::PacketType::SERVER_ERROR, packet.type()); EXPECT_EQ(Status::Internal(), packet.status()); EXPECT_EQ(context.service_id(), packet.service_id()); EXPECT_EQ(kAsyncUnary.id(), packet.method_id()); @@ -269,8 +274,10 @@ TEST(PwpbMethod, AsyncUnaryRpc_ResponseEncodingFails_SendsInternalError) { } TEST(PwpbMethod, ServerStreamingRpc_SendsNothingWhenInitiallyCalled) { - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = 555, .status_code = 0); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = 555, + .status_code = 0); ServerContextForTest<FakeService> context(kServerStream); @@ -289,7 +296,7 @@ TEST(PwpbMethod, ServerWriter_SendsResponse) { EXPECT_EQ(OkStatus(), context.service().last_writer.Write({.value = 100})); - PW_ENCODE_PB(pw::rpc::test::TestResponse, payload, .value = 100); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestResponse, payload, .value = 100); std::array<byte, 128> encoded_response = {}; auto encoded = context.server_stream(payload).Encode(encoded_response); ASSERT_EQ(OkStatus(), encoded.status()); @@ -315,7 +322,7 @@ TEST(PwpbMethod, ServerWriter_WriteAfterMoved_ReturnsFailedPrecondition) { rpc_lock().lock(); kServerStream.Invoke(context.get(), context.request({})); - PwpbServerWriter<pw::rpc::test::TestResponse::Message> new_writer = + PwpbServerWriter<pw::rpc::test::pwpb::TestResponse::Message> new_writer = std::move(context.service().last_writer); EXPECT_EQ(OkStatus(), new_writer.Write({.value = 100})); @@ -336,9 +343,9 @@ TEST(PwpbMethod, ServerStreamingRpc_ResponseEncodingFails_InternalError) { EXPECT_EQ(OkStatus(), context.service().last_writer.Write({})); - pw::rpc::test::TestResponse::Message response = {}; + pw::rpc::test::pwpb::TestResponse::Message response = {}; response.repeated_field.SetEncoder( - [](const pw::rpc::test::TestResponse::StreamEncoder&) { + [](const pw::rpc::test::pwpb::TestResponse::StreamEncoder&) { return Status::Internal(); }); EXPECT_EQ(Status::Internal(), context.service().last_writer.Write(response)); @@ -350,13 +357,13 @@ TEST(PwpbMethod, ServerReader_HandlesRequests) { rpc_lock().lock(); kClientStream.Invoke(context.get(), context.request({})); - pw::rpc::test::TestRequest::Message request_struct{}; + pw::rpc::test::pwpb::TestRequest::Message request_struct{}; context.service().last_reader.set_on_next( - [&request_struct](const pw::rpc::test::TestRequest::Message& req) { + [&request_struct](const pw::rpc::test::pwpb::TestRequest::Message& req) { request_struct = req; }); - PW_ENCODE_PB(pw::rpc::test::TestRequest, + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, request, .integer = 1 << 30, .status_code = 9); @@ -378,7 +385,7 @@ TEST(PwpbMethod, ServerReaderWriter_WritesResponses) { EXPECT_EQ(OkStatus(), context.service().last_reader_writer.Write({.value = 100})); - PW_ENCODE_PB(pw::rpc::test::TestResponse, payload, .value = 100); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestResponse, payload, .value = 100); std::array<byte, 128> encoded_response = {}; auto encoded = context.server_stream(payload).Encode(encoded_response); ASSERT_EQ(OkStatus(), encoded.status()); @@ -393,13 +400,13 @@ TEST(PwpbMethod, ServerReaderWriter_HandlesRequests) { rpc_lock().lock(); kBidirectionalStream.Invoke(context.get(), context.request({})); - pw::rpc::test::TestRequest::Message request_struct{}; + pw::rpc::test::pwpb::TestRequest::Message request_struct{}; context.service().last_reader_writer.set_on_next( - [&request_struct](const pw::rpc::test::TestRequest::Message& req) { + [&request_struct](const pw::rpc::test::pwpb::TestRequest::Message& req) { request_struct = req; }); - PW_ENCODE_PB(pw::rpc::test::TestRequest, + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, request, .integer = 1 << 29, .status_code = 8); diff --git a/pw_rpc/pwpb/method_union_test.cc b/pw_rpc/pwpb/method_union_test.cc index 5233f9d2a..f474f15e1 100644 --- a/pw_rpc/pwpb/method_union_test.cc +++ b/pw_rpc/pwpb/method_union_test.cc @@ -34,32 +34,32 @@ class FakeGeneratedService : public Service { static constexpr std::array<PwpbMethodUnion, 4> kMethods = { GetPwpbOrRawMethodFor<&Implementation::DoNothing, MethodType::kUnary, - pw::rpc::test::Empty::Message, - pw::rpc::test::Empty::Message>( + pw::rpc::test::pwpb::Empty::Message, + pw::rpc::test::pwpb::Empty::Message>( 10u, - kPwpbMethodSerde<&pw::rpc::test::Empty::kMessageFields, - &pw::rpc::test::Empty::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::Empty::kMessageFields, + &pw::rpc::test::pwpb::Empty::kMessageFields>), GetPwpbOrRawMethodFor<&Implementation::RawStream, MethodType::kServerStreaming, - pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message>( + pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message>( 11u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), GetPwpbOrRawMethodFor<&Implementation::AddFive, MethodType::kUnary, - pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message>( + pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message>( 12u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), GetPwpbOrRawMethodFor<&Implementation::StartStream, MethodType::kServerStreaming, - pw::rpc::test::TestRequest::Message, - pw::rpc::test::TestResponse::Message>( + pw::rpc::test::pwpb::TestRequest::Message, + pw::rpc::test::pwpb::TestResponse::Message>( 13u, - kPwpbMethodSerde<&pw::rpc::test::TestRequest::kMessageFields, - &pw::rpc::test::TestResponse::kMessageFields>), + kPwpbMethodSerde<&pw::rpc::test::pwpb::TestRequest::kMessageFields, + &pw::rpc::test::pwpb::TestResponse::kMessageFields>), }; }; @@ -68,8 +68,8 @@ class FakeGeneratedServiceImpl public: FakeGeneratedServiceImpl(uint32_t id) : FakeGeneratedService(id) {} - Status AddFive(const pw::rpc::test::TestRequest::Message& request, - pw::rpc::test::TestResponse::Message& response) { + Status AddFive(const pw::rpc::test::pwpb::TestRequest::Message& request, + pw::rpc::test::pwpb::TestResponse::Message& response) { last_request = request; response.value = request.integer + 5; return Status::Unauthenticated(); @@ -84,14 +84,14 @@ class FakeGeneratedServiceImpl } void StartStream( - const pw::rpc::test::TestRequest::Message& request, - PwpbServerWriter<pw::rpc::test::TestResponse::Message>& writer) { + const pw::rpc::test::pwpb::TestRequest::Message& request, + PwpbServerWriter<pw::rpc::test::pwpb::TestResponse::Message>& writer) { last_request = request; last_writer = std::move(writer); } - pw::rpc::test::TestRequest::Message last_request; - PwpbServerWriter<pw::rpc::test::TestResponse::Message> last_writer; + pw::rpc::test::pwpb::TestRequest::Message last_request; + PwpbServerWriter<pw::rpc::test::pwpb::TestResponse::Message> last_writer; RawServerWriter last_raw_writer; }; @@ -107,8 +107,10 @@ TEST(PwpbMethodUnion, Raw_CallsUnaryMethod) { } TEST(PwpbMethodUnion, Raw_CallsServerStreamingMethod) { - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = 555, .status_code = 0); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = 555, + .status_code = 0); const Method& method = std::get<1>(FakeGeneratedServiceImpl::kMethods).method(); @@ -119,12 +121,14 @@ TEST(PwpbMethodUnion, Raw_CallsServerStreamingMethod) { EXPECT_TRUE(context.service().last_raw_writer.active()); EXPECT_EQ(OkStatus(), context.service().last_raw_writer.Finish()); - EXPECT_EQ(context.output().last_packet().type(), PacketType::RESPONSE); + EXPECT_EQ(context.output().last_packet().type(), pwpb::PacketType::RESPONSE); } TEST(PwpbMethodUnion, Pwpb_CallsUnaryMethod) { - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = 123, .status_code = 3); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = 123, + .status_code = 3); const Method& method = std::get<2>(FakeGeneratedServiceImpl::kMethods).method(); @@ -148,8 +152,10 @@ TEST(PwpbMethodUnion, Pwpb_CallsUnaryMethod) { } TEST(PwpbMethodUnion, Pwpb_CallsServerStreamingMethod) { - PW_ENCODE_PB( - pw::rpc::test::TestRequest, request, .integer = 555, .status_code = 0); + PW_ENCODE_PB(pw::rpc::test::pwpb::TestRequest, + request, + .integer = 555, + .status_code = 0); const Method& method = std::get<3>(FakeGeneratedServiceImpl::kMethods).method(); @@ -162,7 +168,7 @@ TEST(PwpbMethodUnion, Pwpb_CallsServerStreamingMethod) { EXPECT_TRUE(context.service().last_writer.active()); EXPECT_EQ(OkStatus(), context.service().last_writer.Finish()); - EXPECT_EQ(context.output().last_packet().type(), PacketType::RESPONSE); + EXPECT_EQ(context.output().last_packet().type(), pwpb::PacketType::RESPONSE); } } // namespace diff --git a/pw_rpc/pwpb/public/pw_rpc/echo_service_pwpb.h b/pw_rpc/pwpb/public/pw_rpc/echo_service_pwpb.h index b15ef3054..bb0e0f807 100644 --- a/pw_rpc/pwpb/public/pw_rpc/echo_service_pwpb.h +++ b/pw_rpc/pwpb/public/pw_rpc/echo_service_pwpb.h @@ -20,8 +20,8 @@ namespace pw::rpc { class EchoService final : public pw_rpc::pwpb::EchoService::Service<EchoService> { public: - Status Echo(const EchoMessage::Message& request, - EchoMessage::Message& response) { + Status Echo(const pwpb::EchoMessage::Message& request, + pwpb::EchoMessage::Message& response) { response.msg = request.msg; return OkStatus(); } diff --git a/pw_rpc/pwpb/public/pw_rpc/pwpb/fake_channel_output.h b/pw_rpc/pwpb/public/pw_rpc/pwpb/fake_channel_output.h index d26994198..fcbfb7346 100644 --- a/pw_rpc/pwpb/public/pw_rpc/pwpb/fake_channel_output.h +++ b/pw_rpc/pwpb/public/pw_rpc/pwpb/fake_channel_output.h @@ -125,10 +125,10 @@ class PwpbFakeChannelOutput final PwpbPayloadsView<Request<kMethod>> requests( uint32_t channel_id = Channel::kUnassignedChannelId) const PW_NO_LOCK_SAFETY_ANALYSIS { - constexpr internal::PacketType packet_type = + constexpr internal::pwpb::PacketType packet_type = HasClientStream(internal::MethodInfo<kMethod>::kType) - ? internal::PacketType::CLIENT_STREAM - : internal::PacketType::REQUEST; + ? internal::pwpb::PacketType::CLIENT_STREAM + : internal::pwpb::PacketType::REQUEST; return PwpbPayloadsView<Request<kMethod>>( internal::MethodInfo<kMethod>::serde().request(), internal::test::FakeChannelOutputBuffer< @@ -152,10 +152,10 @@ class PwpbFakeChannelOutput final PwpbPayloadsView<Response<kMethod>> responses( uint32_t channel_id = Channel::kUnassignedChannelId) const PW_NO_LOCK_SAFETY_ANALYSIS { - constexpr internal::PacketType packet_type = + constexpr internal::pwpb::PacketType packet_type = HasServerStream(internal::MethodInfo<kMethod>::kType) - ? internal::PacketType::SERVER_STREAM - : internal::PacketType::RESPONSE; + ? internal::pwpb::PacketType::SERVER_STREAM + : internal::pwpb::PacketType::RESPONSE; return PwpbPayloadsView<Response<kMethod>>( internal::MethodInfo<kMethod>::serde().response(), internal::test::FakeChannelOutputBuffer< diff --git a/pw_rpc/pwpb/serde_test.cc b/pw_rpc/pwpb/serde_test.cc index e590a6366..d9da19749 100644 --- a/pw_rpc/pwpb/serde_test.cc +++ b/pw_rpc/pwpb/serde_test.cc @@ -21,8 +21,10 @@ namespace pw::rpc::internal { namespace { -constexpr PwpbSerde kTestRequest(&test::TestRequest::kMessageFields); -constexpr test::TestRequest::Message kProto{.integer = 3, .status_code = 0}; +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; + +constexpr PwpbSerde kTestRequest(&TestRequest::kMessageFields); +constexpr TestRequest::Message kProto{.integer = 3, .status_code = 0}; TEST(PwpbSerde, Encode) { std::byte buffer[32] = {}; @@ -42,7 +44,7 @@ TEST(PwpbSerde, Encode_TooSmall) { TEST(PwpbSerde, Decode) { constexpr std::byte buffer[]{std::byte{1} << 3, std::byte{3}}; - test::TestRequest::Message proto = {}; + TestRequest::Message proto = {}; EXPECT_EQ(OkStatus(), kTestRequest.Decode(buffer, proto)); diff --git a/pw_rpc/pwpb/server_callback_test.cc b/pw_rpc/pwpb/server_callback_test.cc index 7e5e27fe3..780279a3d 100644 --- a/pw_rpc/pwpb/server_callback_test.cc +++ b/pw_rpc/pwpb/server_callback_test.cc @@ -21,38 +21,41 @@ #include "pw_rpc_test_protos/test.rpc.pwpb.h" namespace pw::rpc { +namespace { + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; class TestServiceImpl final : public test::pw_rpc::pwpb::TestService::Service<TestServiceImpl> { public: - Status TestUnaryRpc(const test::TestRequest::Message&, - test::TestResponse::Message& response) { + Status TestUnaryRpc(const TestRequest::Message&, + TestResponse::Message& response) { response.value = 42; return OkStatus(); } - Status TestAnotherUnaryRpc(const test::TestRequest::Message&, - test::TestResponse::Message& response) { + Status TestAnotherUnaryRpc(const TestRequest::Message&, + TestResponse::Message& response) { response.value = 42; response.repeated_field.SetEncoder( - [](test::TestResponse::StreamEncoder& encoder) { + [](TestResponse::StreamEncoder& encoder) { constexpr std::array<uint32_t, 3> kValues = {7, 8, 9}; return encoder.WriteRepeatedField(kValues); }); return OkStatus(); } - void TestServerStreamRpc( - const test::TestRequest::Message&, - PwpbServerWriter<test::TestStreamResponse::Message>&) {} + void TestServerStreamRpc(const TestRequest::Message&, + PwpbServerWriter<TestStreamResponse::Message>&) {} void TestClientStreamRpc( - PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message>&) {} + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message>&) {} void TestBidirectionalStreamRpc( - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>&) {} + PwpbServerReaderWriter<TestRequest::Message, + TestStreamResponse::Message>&) {} }; TEST(PwpbTestMethodContext, ResponseWithoutCallbacks) { @@ -61,7 +64,7 @@ TEST(PwpbTestMethodContext, ResponseWithoutCallbacks) { PW_PWPB_TEST_METHOD_CONTEXT(TestServiceImpl, TestUnaryRpc) ctx; ASSERT_EQ(ctx.call({}), OkStatus()); - test::TestResponse::Message response = ctx.response(); + TestResponse::Message response = ctx.response(); EXPECT_EQ(42, response.value); } @@ -73,9 +76,9 @@ TEST(PwpbTestMethodContext, ResponseWithCallbacks) { // response() method as a parameter. pw::Vector<uint32_t, 4> values{}; - test::TestResponse::Message response{}; + TestResponse::Message response{}; response.repeated_field.SetDecoder( - [&values](test::TestResponse::StreamDecoder& decoder) { + [&values](TestResponse::StreamDecoder& decoder) { return decoder.ReadRepeatedField(values); }); ctx.response(response); @@ -88,4 +91,5 @@ TEST(PwpbTestMethodContext, ResponseWithCallbacks) { EXPECT_EQ(9u, values[2]); } +} // namespace } // namespace pw::rpc diff --git a/pw_rpc/pwpb/server_reader_writer_test.cc b/pw_rpc/pwpb/server_reader_writer_test.cc index a73559ec0..0a3c89960 100644 --- a/pw_rpc/pwpb/server_reader_writer_test.cc +++ b/pw_rpc/pwpb/server_reader_writer_test.cc @@ -21,29 +21,31 @@ #include "pw_rpc_test_protos/test.rpc.pwpb.h" namespace pw::rpc { +namespace { + +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; class TestServiceImpl final : public test::pw_rpc::pwpb::TestService::Service<TestServiceImpl> { public: - Status TestUnaryRpc(const test::TestRequest::Message&, - test::TestResponse::Message&) { + Status TestUnaryRpc(const TestRequest::Message&, TestResponse::Message&) { return OkStatus(); } - void TestAnotherUnaryRpc(const test::TestRequest::Message&, - PwpbUnaryResponder<test::TestResponse::Message>&) {} + void TestAnotherUnaryRpc(const TestRequest::Message&, + PwpbUnaryResponder<TestResponse::Message>&) {} - void TestServerStreamRpc( - const test::TestRequest::Message&, - PwpbServerWriter<test::TestStreamResponse::Message>&) {} + void TestServerStreamRpc(const TestRequest::Message&, + PwpbServerWriter<TestStreamResponse::Message>&) {} void TestClientStreamRpc( - PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message>&) {} + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message>&) {} void TestBidirectionalStreamRpc( - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>&) {} + PwpbServerReaderWriter<TestRequest::Message, + TestStreamResponse::Message>&) {} }; template <auto kMethod> @@ -65,7 +67,7 @@ struct ReaderWriterTestContext { using test::pw_rpc::pwpb::TestService; TEST(PwpbUnaryResponder, DefaultConstructed) { - PwpbUnaryResponder<test::TestResponse::Message> call; + PwpbUnaryResponder<TestResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); @@ -76,7 +78,7 @@ TEST(PwpbUnaryResponder, DefaultConstructed) { } TEST(PwpbServerWriter, DefaultConstructed) { - PwpbServerWriter<test::TestStreamResponse::Message> call; + PwpbServerWriter<TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); @@ -88,22 +90,19 @@ TEST(PwpbServerWriter, DefaultConstructed) { } TEST(PwpbServerReader, DefaultConstructed) { - PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message> - call; + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); EXPECT_EQ(call.channel_id(), Channel::kUnassignedChannelId); EXPECT_EQ(Status::FailedPrecondition(), call.Finish({}, OkStatus())); - call.set_on_next([](const test::TestRequest::Message&) {}); + call.set_on_next([](const TestRequest::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbServerReaderWriter, DefaultConstructed) { - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message> + PwpbServerReaderWriter<TestRequest::Message, TestStreamResponse::Message> call; ASSERT_FALSE(call.active()); @@ -112,15 +111,14 @@ TEST(PwpbServerReaderWriter, DefaultConstructed) { EXPECT_EQ(Status::FailedPrecondition(), call.Write({})); EXPECT_EQ(Status::FailedPrecondition(), call.Finish(OkStatus())); - call.set_on_next([](const test::TestRequest::Message&) {}); + call.set_on_next([](const TestRequest::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbUnaryResponder, Closed) { ReaderWriterTestContext<TestService::TestUnaryRpc> ctx; - PwpbUnaryResponder call = - PwpbUnaryResponder<test::TestResponse::Message>::Open< - TestService::TestUnaryRpc>(ctx.server, ctx.channel.id(), ctx.service); + PwpbUnaryResponder call = PwpbUnaryResponder<TestResponse::Message>::Open< + TestService::TestUnaryRpc>(ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), call.Finish({}, OkStatus())); ASSERT_FALSE(call.active()); @@ -133,10 +131,9 @@ TEST(PwpbUnaryResponder, Closed) { TEST(PwpbServerWriter, Closed) { ReaderWriterTestContext<TestService::TestServerStreamRpc> ctx; - PwpbServerWriter call = - PwpbServerWriter<test::TestStreamResponse::Message>::Open< - TestService::TestServerStreamRpc>( - ctx.server, ctx.channel.id(), ctx.service); + PwpbServerWriter call = PwpbServerWriter<TestStreamResponse::Message>::Open< + TestService::TestServerStreamRpc>( + ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), call.Finish(OkStatus())); ASSERT_FALSE(call.active()); @@ -150,9 +147,9 @@ TEST(PwpbServerWriter, Closed) { TEST(PwpbServerReader, Closed) { ReaderWriterTestContext<TestService::TestClientStreamRpc> ctx; - PwpbServerReader call = PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message>:: - Open<TestService::TestClientStreamRpc>( + PwpbServerReader call = + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message>::Open< + TestService::TestClientStreamRpc>( ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), call.Finish({}, OkStatus())); @@ -161,15 +158,15 @@ TEST(PwpbServerReader, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.Finish({}, OkStatus())); - call.set_on_next([](const test::TestRequest::Message&) {}); + call.set_on_next([](const TestRequest::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbServerReaderWriter, Closed) { ReaderWriterTestContext<TestService::TestBidirectionalStreamRpc> ctx; PwpbServerReaderWriter call = - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>:: + PwpbServerReaderWriter<TestRequest::Message, + TestStreamResponse::Message>:: Open<TestService::TestBidirectionalStreamRpc>( ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), call.Finish(OkStatus())); @@ -180,14 +177,14 @@ TEST(PwpbServerReaderWriter, Closed) { EXPECT_EQ(Status::FailedPrecondition(), call.Write({})); EXPECT_EQ(Status::FailedPrecondition(), call.Finish(OkStatus())); - call.set_on_next([](const test::TestRequest::Message&) {}); + call.set_on_next([](const TestRequest::Message&) {}); call.set_on_error([](Status) {}); } TEST(PwpbUnaryResponder, Open_ReturnsUsableResponder) { ReaderWriterTestContext<TestService::TestUnaryRpc> ctx; PwpbUnaryResponder responder = - PwpbUnaryResponder<test::TestResponse::Message>::Open< + PwpbUnaryResponder<TestResponse::Message>::Open< TestService::TestUnaryRpc>(ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), @@ -200,7 +197,7 @@ TEST(PwpbUnaryResponder, Open_ReturnsUsableResponder) { TEST(PwpbServerWriter, Open_ReturnsUsableWriter) { ReaderWriterTestContext<TestService::TestServerStreamRpc> ctx; PwpbServerWriter responder = - PwpbServerWriter<test::TestStreamResponse::Message>::Open< + PwpbServerWriter<TestStreamResponse::Message>::Open< TestService::TestServerStreamRpc>( ctx.server, ctx.channel.id(), ctx.service); @@ -215,10 +212,9 @@ TEST(PwpbServerWriter, Open_ReturnsUsableWriter) { TEST(PwpbServerReader, Open_ReturnsUsableReader) { ReaderWriterTestContext<TestService::TestClientStreamRpc> ctx; PwpbServerReader responder = - PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message>:: - Open<TestService::TestClientStreamRpc>( - ctx.server, ctx.channel.id(), ctx.service); + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message>::Open< + TestService::TestClientStreamRpc>( + ctx.server, ctx.channel.id(), ctx.service); ASSERT_EQ(OkStatus(), responder.Finish({.chunk = {}, .number = 321})); @@ -229,8 +225,8 @@ TEST(PwpbServerReader, Open_ReturnsUsableReader) { TEST(PwpbServerReaderWriter, Open_ReturnsUsableReaderWriter) { ReaderWriterTestContext<TestService::TestBidirectionalStreamRpc> ctx; PwpbServerReaderWriter responder = - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>:: + PwpbServerReaderWriter<TestRequest::Message, + TestStreamResponse::Message>:: Open<TestService::TestBidirectionalStreamRpc>( ctx.server, ctx.channel.id(), ctx.service); @@ -248,8 +244,8 @@ TEST(RawServerReaderWriter, Open_UnknownChannel) { ASSERT_EQ(OkStatus(), ctx.server.CloseChannel(ctx.kChannelId)); PwpbServerReaderWriter call = - PwpbServerReaderWriter<test::TestRequest::Message, - test::TestStreamResponse::Message>:: + PwpbServerReaderWriter<TestRequest::Message, + TestStreamResponse::Message>:: Open<TestService::TestBidirectionalStreamRpc>( ctx.server, ctx.kChannelId, ctx.service); @@ -274,24 +270,21 @@ TEST(PwpbServerReader, CallbacksMoveCorrectly) { ASSERT_TRUE(call_1.active()); - test::TestRequest::Message received_request = {.integer = 12345678, - .status_code = 1}; + TestRequest::Message received_request = {.integer = 12345678, + .status_code = 1}; - call_1.set_on_next( - [&received_request](const test::TestRequest::Message& value) { - received_request = value; - }); + call_1.set_on_next([&received_request](const TestRequest::Message& value) { + received_request = value; + }); - PwpbServerReader<test::TestRequest::Message, - test::TestStreamResponse::Message> - call_2; + PwpbServerReader<TestRequest::Message, TestStreamResponse::Message> call_2; call_2 = std::move(call_1); - constexpr test::TestRequest::Message request{.integer = 600613, - .status_code = 2}; + constexpr TestRequest::Message request{.integer = 600613, .status_code = 2}; ctx.SendClientStream(request); EXPECT_EQ(request.integer, received_request.integer); EXPECT_EQ(request.status_code, received_request.status_code); } +} // namespace } // namespace pw::rpc diff --git a/pw_rpc/pwpb/synchronous_call_test.cc b/pw_rpc/pwpb/synchronous_call_test.cc index a25da6a5d..ec070de53 100644 --- a/pw_rpc/pwpb/synchronous_call_test.cc +++ b/pw_rpc/pwpb/synchronous_call_test.cc @@ -34,6 +34,9 @@ namespace { using pw::rpc::test::pw_rpc::pwpb::TestService; using MethodInfo = internal::MethodInfo<TestService::TestUnaryRpc>; +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; + class SynchronousCallTest : public ::testing::Test { public: SynchronousCallTest() diff --git a/pw_rpc/raw/client_test.cc b/pw_rpc/raw/client_test.cc index 9dcf32d42..29e771818 100644 --- a/pw_rpc/raw/client_test.cc +++ b/pw_rpc/raw/client_test.cc @@ -174,7 +174,8 @@ TEST(Client, ProcessPacket_ReturnsInvalidArgumentOnServerPacket) { std::byte encoded[64]; Result<span<const std::byte>> result = - internal::Packet(internal::PacketType::REQUEST, 1, 2, 3).Encode(encoded); + internal::Packet(internal::pwpb::PacketType::REQUEST, 1, 2, 3) + .Encode(encoded); ASSERT_TRUE(result.ok()); EXPECT_EQ(context.client().ProcessPacket(*result), Status::InvalidArgument()); diff --git a/pw_rpc/raw/client_testing.cc b/pw_rpc/raw/client_testing.cc index 310d730f0..fd838bdbb 100644 --- a/pw_rpc/raw/client_testing.cc +++ b/pw_rpc/raw/client_testing.cc @@ -25,7 +25,7 @@ namespace pw::rpc { -void FakeServer::CheckProcessPacket(internal::PacketType type, +void FakeServer::CheckProcessPacket(internal::pwpb::PacketType type, uint32_t service_id, uint32_t method_id, std::optional<uint32_t> call_id, @@ -48,7 +48,7 @@ void FakeServer::CheckProcessPacket(internal::PacketType type, } } -Status FakeServer::ProcessPacket(internal::PacketType type, +Status FakeServer::ProcessPacket(internal::pwpb::PacketType type, uint32_t service_id, uint32_t method_id, std::optional<uint32_t> call_id, @@ -58,8 +58,8 @@ Status FakeServer::ProcessPacket(internal::PacketType type, internal::LockGuard lock(output_.mutex_); auto view = internal::test::PacketsView( output_.packets(), - internal::test::PacketFilter(internal::PacketType::REQUEST, - internal::PacketType::RESPONSE, + internal::test::PacketFilter(internal::pwpb::PacketType::REQUEST, + internal::pwpb::PacketType::RESPONSE, channel_id_, service_id, method_id)); diff --git a/pw_rpc/raw/codegen_test.cc b/pw_rpc/raw/codegen_test.cc index a2ad10c01..a5609473f 100644 --- a/pw_rpc/raw/codegen_test.cc +++ b/pw_rpc/raw/codegen_test.cc @@ -26,9 +26,13 @@ namespace pw::rpc { namespace { +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; +namespace TestStreamResponse = ::pw::rpc::test::pwpb::TestStreamResponse; + Vector<std::byte, 64> EncodeRequest(int integer, Status status) { Vector<std::byte, 64> buffer(64); - test::TestRequest::MemoryEncoder test_request(buffer); + TestRequest::MemoryEncoder test_request(buffer); EXPECT_EQ(OkStatus(), test_request.WriteInteger(integer)); EXPECT_EQ(OkStatus(), test_request.WriteStatusCode(status.code())); @@ -40,7 +44,7 @@ Vector<std::byte, 64> EncodeRequest(int integer, Status status) { Vector<std::byte, 64> EncodeResponse(int number) { Vector<std::byte, 64> buffer(64); - test::TestStreamResponse::MemoryEncoder test_response(buffer); + TestStreamResponse::MemoryEncoder test_response(buffer); EXPECT_EQ(OkStatus(), test_response.WriteNumber(number)); @@ -212,14 +216,14 @@ TEST(RawCodegen, Server_InvokeUnaryRpc) { protobuf::Decoder decoder(context.response()); while (decoder.Next().ok()) { - switch (static_cast<test::TestResponse::Fields>(decoder.FieldNumber())) { - case test::TestResponse::Fields::VALUE: { + switch (static_cast<TestResponse::Fields>(decoder.FieldNumber())) { + case TestResponse::Fields::VALUE: { int32_t value; EXPECT_EQ(OkStatus(), decoder.ReadInt32(&value)); EXPECT_EQ(value, 124); break; } - case test::TestResponse::Fields::REPEATED_FIELD: + case TestResponse::Fields::REPEATED_FIELD: break; // Ignore this field } } @@ -234,14 +238,14 @@ TEST(RawCodegen, Server_InvokeAsyncUnaryRpc) { protobuf::Decoder decoder(context.response()); while (decoder.Next().ok()) { - switch (static_cast<test::TestResponse::Fields>(decoder.FieldNumber())) { - case test::TestResponse::Fields::VALUE: { + switch (static_cast<TestResponse::Fields>(decoder.FieldNumber())) { + case TestResponse::Fields::VALUE: { int32_t value; EXPECT_EQ(OkStatus(), decoder.ReadInt32(&value)); EXPECT_EQ(value, 124); break; } - case test::TestResponse::Fields::REPEATED_FIELD: + case TestResponse::Fields::REPEATED_FIELD: break; // Ignore this field } } @@ -321,15 +325,14 @@ TEST(RawCodegen, Server_InvokeServerStreamingRpc) { protobuf::Decoder decoder(context.responses().back()); while (decoder.Next().ok()) { - switch ( - static_cast<test::TestStreamResponse::Fields>(decoder.FieldNumber())) { - case test::TestStreamResponse::Fields::NUMBER: { + switch (static_cast<TestStreamResponse::Fields>(decoder.FieldNumber())) { + case TestStreamResponse::Fields::NUMBER: { int32_t value; EXPECT_EQ(OkStatus(), decoder.ReadInt32(&value)); EXPECT_EQ(value, 4); break; } - case test::TestStreamResponse::Fields::CHUNK: + case TestStreamResponse::Fields::CHUNK: FAIL(); break; } @@ -340,13 +343,12 @@ int32_t ReadResponseNumber(ConstByteSpan data) { int32_t value = -1; protobuf::Decoder decoder(data); while (decoder.Next().ok()) { - switch ( - static_cast<test::TestStreamResponse::Fields>(decoder.FieldNumber())) { - case test::TestStreamResponse::Fields::NUMBER: { + switch (static_cast<TestStreamResponse::Fields>(decoder.FieldNumber())) { + case TestStreamResponse::Fields::NUMBER: { EXPECT_EQ(OkStatus(), decoder.ReadInt32(&value)); break; } - case test::TestStreamResponse::Fields::CHUNK: + case TestStreamResponse::Fields::CHUNK: default: ADD_FAILURE(); break; diff --git a/pw_rpc/raw/method_test.cc b/pw_rpc/raw/method_test.cc index 0130ba056..9d9575715 100644 --- a/pw_rpc/raw/method_test.cc +++ b/pw_rpc/raw/method_test.cc @@ -31,8 +31,8 @@ namespace pw::rpc::internal { namespace { -namespace TestRequest = ::pw::rpc::test::TestRequest; -namespace TestResponse = ::pw::rpc::test::TestResponse; +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; // Create a fake service for use with the MethodImplTester. class TestRawService final : public Service { @@ -204,7 +204,7 @@ TEST(RawMethod, AsyncUnaryRpc0_SendsResponse) { kAsyncUnary0.Invoke(context.get(), context.request({})); const Packet& packet = context.output().last_packet(); - EXPECT_EQ(PacketType::RESPONSE, packet.type()); + EXPECT_EQ(pwpb::PacketType::RESPONSE, packet.type()); EXPECT_EQ(Status::Unknown(), packet.status()); EXPECT_EQ(context.service_id(), packet.service_id()); EXPECT_EQ(kAsyncUnary0.id(), packet.method_id()); @@ -274,7 +274,7 @@ TEST(RawServerWriter, Write_SendsPayload) { EXPECT_EQ(context.service().last_writer.Write(data), OkStatus()); const internal::Packet& packet = context.output().last_packet(); - EXPECT_EQ(packet.type(), internal::PacketType::SERVER_STREAM); + EXPECT_EQ(packet.type(), pwpb::PacketType::SERVER_STREAM); EXPECT_EQ(packet.channel_id(), context.channel_id()); EXPECT_EQ(packet.service_id(), context.service_id()); EXPECT_EQ(packet.method_id(), context.get().method().id()); @@ -290,7 +290,7 @@ TEST(RawServerWriter, Write_EmptyBuffer) { ASSERT_EQ(context.service().last_writer.Write({}), OkStatus()); const internal::Packet& packet = context.output().last_packet(); - EXPECT_EQ(packet.type(), internal::PacketType::SERVER_STREAM); + EXPECT_EQ(packet.type(), pwpb::PacketType::SERVER_STREAM); EXPECT_EQ(packet.channel_id(), context.channel_id()); EXPECT_EQ(packet.service_id(), context.service_id()); EXPECT_EQ(packet.method_id(), context.get().method().id()); diff --git a/pw_rpc/raw/method_union_test.cc b/pw_rpc/raw/method_union_test.cc index b57fba93f..356eefcad 100644 --- a/pw_rpc/raw/method_union_test.cc +++ b/pw_rpc/raw/method_union_test.cc @@ -27,8 +27,8 @@ namespace pw::rpc::internal { namespace { -namespace TestRequest = ::pw::rpc::test::TestRequest; -namespace TestResponse = ::pw::rpc::test::TestResponse; +namespace TestRequest = ::pw::rpc::test::pwpb::TestRequest; +namespace TestResponse = ::pw::rpc::test::pwpb::TestResponse; template <typename Implementation> class FakeGeneratedService : public Service { diff --git a/pw_rpc/raw/public/pw_rpc/raw/client_testing.h b/pw_rpc/raw/public/pw_rpc/raw/client_testing.h index 89cefe018..dbda24d58 100644 --- a/pw_rpc/raw/public/pw_rpc/raw/client_testing.h +++ b/pw_rpc/raw/public/pw_rpc/raw/client_testing.h @@ -47,7 +47,8 @@ class FakeServer { HasServerStream(internal::MethodInfo<kMethod>::kType)>> void SendResponse(Status status, std::optional<uint32_t> call_id = std::nullopt) const { - SendPacket<kMethod>(internal::PacketType::RESPONSE, {}, status, call_id); + SendPacket<kMethod>( + internal::pwpb::PacketType::RESPONSE, {}, status, call_id); } // Sends a response packet for a unary or client streaming streaming RPC to @@ -59,7 +60,7 @@ class FakeServer { Status status, std::optional<uint32_t> call_id = std::nullopt) const { SendPacket<kMethod>( - internal::PacketType::RESPONSE, payload, status, call_id); + internal::pwpb::PacketType::RESPONSE, payload, status, call_id); } // Sends a stream packet for a server or bidirectional streaming RPC to the @@ -70,20 +71,23 @@ class FakeServer { static_assert(HasServerStream(internal::MethodInfo<kMethod>::kType), "Only server and bidirectional streaming methods can receive " "server stream packets"); - SendPacket<kMethod>( - internal::PacketType::SERVER_STREAM, payload, OkStatus(), call_id); + SendPacket<kMethod>(internal::pwpb::PacketType::SERVER_STREAM, + payload, + OkStatus(), + call_id); } // Sends a server error packet to the client. template <auto kMethod> void SendServerError(Status error, std::optional<uint32_t> call_id = std::nullopt) const { - SendPacket<kMethod>(internal::PacketType::SERVER_ERROR, {}, error, call_id); + SendPacket<kMethod>( + internal::pwpb::PacketType::SERVER_ERROR, {}, error, call_id); } private: template <auto kMethod> - void SendPacket(internal::PacketType type, + void SendPacket(internal::pwpb::PacketType type, ConstByteSpan payload, Status status, std::optional<uint32_t> call_id) const { @@ -92,14 +96,14 @@ class FakeServer { type, Info::kServiceId, Info::kMethodId, call_id, payload, status); } - void CheckProcessPacket(internal::PacketType type, + void CheckProcessPacket(internal::pwpb::PacketType type, uint32_t service_id, uint32_t method_id, std::optional<uint32_t> call_id, ConstByteSpan payload, Status status) const; - Status ProcessPacket(internal::PacketType type, + Status ProcessPacket(internal::pwpb::PacketType type, uint32_t service_id, uint32_t method_id, std::optional<uint32_t> call_id, diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc index 270674a56..f33020edd 100644 --- a/pw_rpc/server.cc +++ b/pw_rpc/server.cc @@ -29,7 +29,7 @@ namespace pw::rpc { namespace { using internal::Packet; -using internal::PacketType; +using internal::pwpb::PacketType; } // namespace diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc index 5b6ec9406..505212612 100644 --- a/pw_rpc/server_test.cc +++ b/pw_rpc/server_test.cc @@ -33,9 +33,9 @@ namespace { using std::byte; using internal::Packet; -using internal::PacketType; using internal::TestMethod; using internal::TestMethodUnion; +using internal::pwpb::PacketType; class TestService : public Service { public: diff --git a/pw_rpc/test_helpers_test.cc b/pw_rpc/test_helpers_test.cc index 335424e64..7b4b6e2a9 100644 --- a/pw_rpc/test_helpers_test.cc +++ b/pw_rpc/test_helpers_test.cc @@ -47,8 +47,8 @@ class EntityUnderTest { void AskForEcho() { call_ = echo_client_.Echo( - EchoMessage::Message{}, - [this](const EchoMessage::Message& response, pw::Status status) { + pwpb::EchoMessage::Message{}, + [this](const pwpb::EchoMessage::Message& response, pw::Status status) { lock_.lock(); if (status.ok()) { last_echo_ = response.msg; @@ -77,7 +77,7 @@ class EntityUnderTest { private: pw_rpc::pwpb::EchoService::Client& echo_client_; - PwpbUnaryReceiver<EchoMessage::Message> call_; + PwpbUnaryReceiver<pwpb::EchoMessage::Message> call_; pw::sync::TimedThreadNotification notifier_; pw::Result<pw::InlineString<64>> last_echo_ PW_GUARDED_BY(lock_); mutable pw::sync::InterruptSpinLock lock_; diff --git a/pw_snapshot/cpp_compile_test.cc b/pw_snapshot/cpp_compile_test.cc index 43d35fdbc..681c3324d 100644 --- a/pw_snapshot/cpp_compile_test.cc +++ b/pw_snapshot/cpp_compile_test.cc @@ -26,9 +26,9 @@ TEST(Status, CompileTest) { std::byte submessage_buffer[kMaxProtoSize]; stream::MemoryWriter writer(encode_buffer); - Snapshot::StreamEncoder snapshot_encoder(writer, submessage_buffer); + pwpb::Snapshot::StreamEncoder snapshot_encoder(writer, submessage_buffer); { - Metadata::StreamEncoder metadata_encoder = + pwpb::Metadata::StreamEncoder metadata_encoder = snapshot_encoder.GetMetadataEncoder(); ASSERT_EQ(OkStatus(), metadata_encoder.WriteReason( diff --git a/pw_snapshot/uuid.cc b/pw_snapshot/uuid.cc index 3d61e3325..159a2896f 100644 --- a/pw_snapshot/uuid.cc +++ b/pw_snapshot/uuid.cc @@ -34,7 +34,7 @@ Result<ConstByteSpan> ReadUuidFromSnapshot(ConstByteSpan snapshot, while (decoder.Next().ok()) { if (decoder.FieldNumber() == static_cast<uint32_t>( - pw::snapshot::SnapshotBasicInfo::Fields::METADATA)) { + pw::snapshot::pwpb::SnapshotBasicInfo::Fields::METADATA)) { PW_TRY(decoder.ReadBytes(&metadata)); break; } @@ -48,7 +48,8 @@ Result<ConstByteSpan> ReadUuidFromSnapshot(ConstByteSpan snapshot, ConstByteSpan snapshot_uuid; while (decoder.Next().ok()) { if (decoder.FieldNumber() == - static_cast<uint32_t>(pw::snapshot::Metadata::Fields::SNAPSHOT_UUID)) { + static_cast<uint32_t>( + pw::snapshot::pwpb::Metadata::Fields::SNAPSHOT_UUID)) { PW_TRY(decoder.ReadBytes(&snapshot_uuid)); break; } diff --git a/pw_snapshot/uuid_test.cc b/pw_snapshot/uuid_test.cc index f7139408d..7c2f45367 100644 --- a/pw_snapshot/uuid_test.cc +++ b/pw_snapshot/uuid_test.cc @@ -28,9 +28,9 @@ namespace pw::snapshot { namespace { ConstByteSpan EncodeSnapshotWithUuid(ConstByteSpan uuid, ByteSpan dest) { - SnapshotBasicInfo::MemoryEncoder snapshot_encoder(dest); + pwpb::SnapshotBasicInfo::MemoryEncoder snapshot_encoder(dest); { - Metadata::StreamEncoder metadata_encoder = + pwpb::Metadata::StreamEncoder metadata_encoder = snapshot_encoder.GetMetadataEncoder(); EXPECT_EQ(OkStatus(), metadata_encoder.WriteSnapshotUuid(uuid)); } @@ -57,9 +57,9 @@ TEST(ReadUuid, NoUuid) { std::array<std::byte, 16> snapshot_buffer; // Write some snapshot metadata, but no UUID. - SnapshotBasicInfo::MemoryEncoder snapshot_encoder(snapshot_buffer); + pwpb::SnapshotBasicInfo::MemoryEncoder snapshot_encoder(snapshot_buffer); { - Metadata::StreamEncoder metadata_encoder = + pwpb::Metadata::StreamEncoder metadata_encoder = snapshot_encoder.GetMetadataEncoder(); EXPECT_EQ(OkStatus(), metadata_encoder.WriteFatal(true)); } diff --git a/pw_transfer/chunk.cc b/pw_transfer/chunk.cc index 2adbbf5a3..752c90a8d 100644 --- a/pw_transfer/chunk.cc +++ b/pw_transfer/chunk.cc @@ -21,7 +21,7 @@ namespace pw::transfer::internal { -namespace ProtoChunk = transfer::Chunk; +namespace ProtoChunk = transfer::pwpb::Chunk; Result<uint32_t> Chunk::ExtractIdentifier(ConstByteSpan message) { protobuf::Decoder decoder(message); diff --git a/pw_transfer/public/pw_transfer/internal/chunk.h b/pw_transfer/public/pw_transfer/internal/chunk.h index 027b98e91..02db72778 100644 --- a/pw_transfer/public/pw_transfer/internal/chunk.h +++ b/pw_transfer/public/pw_transfer/internal/chunk.h @@ -24,7 +24,7 @@ namespace pw::transfer::internal { class Chunk { public: - using Type = transfer::Chunk::Type; + using Type = transfer::pwpb::Chunk::Type; // Constructs a new chunk with the given transfer protocol version. All fields // are initialized to their zero values. diff --git a/pw_unit_test/public/pw_unit_test/unit_test_service.h b/pw_unit_test/public/pw_unit_test/unit_test_service.h index 78866011a..ca32ef5d8 100644 --- a/pw_unit_test/public/pw_unit_test/unit_test_service.h +++ b/pw_unit_test/public/pw_unit_test/unit_test_service.h @@ -37,7 +37,7 @@ class UnitTestService final // migrated to it. template <typename WriteFunction> void WriteEvent(WriteFunction event_writer) { - Event::MemoryEncoder event(encoding_buffer_); + pwpb::Event::MemoryEncoder event(encoding_buffer_); event_writer(event); if (event.status().ok()) { writer_.Write(event) |