kafka_wire_protocol/schema/unregister_broker_response/
v0.rs1use std::io::{Read, Result, Write};
4
5use serde::{Deserialize, Serialize};
6#[cfg(test)] use proptest_derive::Arbitrary;
7
8use crate::markers::{ApiMessage, Response};
9use crate::readable_writable::{Readable, Writable};
10use crate::tagged_fields::{RawTaggedField, read_tagged_fields, write_tagged_fields};
11#[cfg(test)] use crate::test_utils::proptest_strategies;
12
13#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
15#[cfg_attr(test, derive(Arbitrary))]
16pub struct UnregisterBrokerResponse {
17 pub throttle_time_ms: i32,
19 pub error_code: i16,
21 #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
23 pub error_message: Option<String>,
24 #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
26 pub _unknown_tagged_fields: Vec<RawTaggedField>,
27}
28
29impl ApiMessage for UnregisterBrokerResponse {
30 fn api_key(&self) -> i16 {
31 64
32 }
33
34 fn version(&self) -> i16 {
35 0
36 }
37}
38
39impl Response for UnregisterBrokerResponse { }
40
41impl Default for UnregisterBrokerResponse {
42 fn default() -> Self {
43 UnregisterBrokerResponse {
44 throttle_time_ms: 0_i32,
45 error_code: 0_i16,
46 error_message: Some(String::from("")),
47 _unknown_tagged_fields: Vec::new(),
48 }
49 }
50}
51
52impl UnregisterBrokerResponse {
53 pub fn new<S1: AsRef<str>>(throttle_time_ms: i32, error_code: i16, error_message: Option<S1>) -> Self {
54 Self {
55 throttle_time_ms,
56 error_code,
57 error_message: error_message.map(|s| s.as_ref().to_string()),
58 _unknown_tagged_fields: vec![],
59 }
60 }
61}
62
63#[cfg(test)]
64mod tests_unregister_broker_response_new_and_default {
65 use super::*;
66
67 #[test]
68 fn test() {
69 let d = UnregisterBrokerResponse::new(
70 0_i32,
71 0_i16,
72 Some(String::from("")),
73 );
74 assert_eq!(d, UnregisterBrokerResponse::default());
75 }
76}
77
78impl Readable for UnregisterBrokerResponse {
79 fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
80 let throttle_time_ms = i32::read(input)?;
81 let error_code = i16::read(input)?;
82 let error_message = Option::<String>::read_ext(input, "error_message", true)?;
83 let tagged_fields_callback = |tag: i32, _: &[u8]| {
84 match tag {
85 _ => Ok(false)
86 }
87 };
88 let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
89 Ok(UnregisterBrokerResponse {
90 throttle_time_ms, error_code, error_message, _unknown_tagged_fields
91 })
92 }
93}
94
95impl Writable for UnregisterBrokerResponse {
96 fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
97 self.throttle_time_ms.write(output)?;
98 self.error_code.write(output)?;
99 self.error_message.write_ext(output, "self.error_message", true)?;
100 write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
101 Ok(())
102 }
103}
104
105#[cfg(test)]
106mod tests {
107 use super::*;
108 use proptest::prelude::*;
109
110 #[test]
111 fn test_java_default() {
112 crate::test_utils::test_java_default::<UnregisterBrokerResponse>("UnregisterBrokerResponse", 0);
113 }
114
115 proptest! {
116 #[test]
117 fn test_serde(data: UnregisterBrokerResponse) {
118 crate::test_utils::test_serde(&data)?;
119 }
120 }
121
122 proptest! {
123 #[test]
124 fn test_java_arbitrary(data: UnregisterBrokerResponse) {
125 crate::test_utils::test_java_arbitrary(&data, "UnregisterBrokerResponse", 0);
126 }
127 }
128}