Add equality operators for public data types in BinaryHttp*

PiperOrigin-RevId: 475643555

quiche/binary_http/binary_http_message.h

diff --git a/quiche/binary_http/binary_http_message.h b/quiche/binary_http/binary_http_message.h
index d7da4fe..852df93 100644
--- a/quiche/binary_http/binary_http_message.h
+++ b/quiche/binary_http/binary_http_message.h
@@ -30,6 +30,10 @@
       return name == rhs.name && value == rhs.value;
     }
 
+    bool operator!=(const BinaryHttpMessage::Field& rhs) const {
+      return !(*this == rhs);
+    }
+
     std::string DebugString() const;
   };
   virtual ~BinaryHttpMessage() = default;
@@ -87,6 +91,12 @@
     std::vector<BinaryHttpMessage::Field> fields_;
   };
 
+  bool operator==(const BinaryHttpMessage& rhs) const {
+    // `has_host_` is derived from `header_fields_` so it doesn't need to be
+    // tested directly.
+    return body_ == rhs.body_ && header_fields_ == rhs.header_fields_;
+  }
+
   absl::Status EncodeKnownLengthFieldsAndBody(
       quiche::QuicheDataWriter& writer) const;
   uint64_t EncodedKnownLengthFieldsAndBodySize() const;
@@ -114,6 +124,9 @@
       return method == rhs.method && scheme == rhs.scheme &&
              authority == rhs.authority && path == rhs.path;
     }
+    bool operator!=(const BinaryHttpRequest::ControlData& rhs) const {
+      return !(*this == rhs);
+    }
   };
   explicit BinaryHttpRequest(ControlData control_data)
       : control_data_(std::move(control_data)) {}
@@ -126,6 +139,15 @@
 
   virtual std::string DebugString() const override;
 
+  bool operator==(const BinaryHttpRequest& rhs) const {
+    return control_data_ == rhs.control_data_ &&
+           BinaryHttpMessage::operator==(rhs);
+  }
+
+  bool operator!=(const BinaryHttpRequest& rhs) const {
+    return !(*this == rhs);
+  }
+
  private:
   absl::Status EncodeControlData(quiche::QuicheDataWriter& writer) const;
 
@@ -164,6 +186,11 @@
       return status_code_ == rhs.status_code_ && fields_ == rhs.fields_;
     }
 
+    bool operator!=(
+        const BinaryHttpResponse::InformationalResponse& rhs) const {
+      return !(*this == rhs);
+    }
+
     // Adds a field with the provided name, converted to lower case.
     // Fields are in the order they are added.
     void AddField(absl::string_view name, std::string value);
@@ -211,6 +238,16 @@
 
   virtual std::string DebugString() const override;
 
+  bool operator==(const BinaryHttpResponse& rhs) const {
+    return informational_response_control_data_ ==
+               rhs.informational_response_control_data_ &&
+           status_code_ == rhs.status_code_ &&
+           BinaryHttpMessage::operator==(rhs);
+  }
+  bool operator!=(const BinaryHttpResponse& rhs) const {
+    return !(*this == rhs);
+  }
+
  private:
   // Returns Binary Http known length request formatted response.
   absl::StatusOr<std::string> EncodeAsKnownLength() const;

quiche/binary_http/binary_http_message_test.cc

diff --git a/quiche/binary_http/binary_http_message_test.cc b/quiche/binary_http/binary_http_message_test.cc
index 3ce4b0e..f98a375 100644
--- a/quiche/binary_http/binary_http_message_test.cc
+++ b/quiche/binary_http/binary_http_message_test.cc
@@ -262,6 +262,50 @@
             "body that I used to post.\r\n}}}"));
 }
 
+TEST(BinaryHttpRequest, Equality) {
+  BinaryHttpRequest request({"POST", "https", "www.example.com", "/hello.txt"});
+  request.AddHeaderField({"User-Agent", "not/telling"})
+      ->set_body({"hello, world!\r\n"});
+
+  BinaryHttpRequest same({"POST", "https", "www.example.com", "/hello.txt"});
+  same.AddHeaderField({"User-Agent", "not/telling"})
+      ->set_body({"hello, world!\r\n"});
+  EXPECT_EQ(request, same);
+}
+
+TEST(BinaryHttpRequest, Inequality) {
+  BinaryHttpRequest request({"POST", "https", "www.example.com", "/hello.txt"});
+  request.AddHeaderField({"User-Agent", "not/telling"})
+      ->set_body({"hello, world!\r\n"});
+
+  BinaryHttpRequest different_control(
+      {"PUT", "https", "www.example.com", "/hello.txt"});
+  different_control.AddHeaderField({"User-Agent", "not/telling"})
+      ->set_body({"hello, world!\r\n"});
+  EXPECT_NE(request, different_control);
+
+  BinaryHttpRequest different_header(
+      {"PUT", "https", "www.example.com", "/hello.txt"});
+  different_header.AddHeaderField({"User-Agent", "told/you"})
+      ->set_body({"hello, world!\r\n"});
+  EXPECT_NE(request, different_header);
+
+  BinaryHttpRequest no_header(
+      {"PUT", "https", "www.example.com", "/hello.txt"});
+  no_header.set_body({"hello, world!\r\n"});
+  EXPECT_NE(request, no_header);
+
+  BinaryHttpRequest different_body(
+      {"POST", "https", "www.example.com", "/hello.txt"});
+  different_body.AddHeaderField({"User-Agent", "not/telling"})
+      ->set_body({"goodbye, world!\r\n"});
+  EXPECT_NE(request, different_body);
+
+  BinaryHttpRequest no_body({"POST", "https", "www.example.com", "/hello.txt"});
+  no_body.AddHeaderField({"User-Agent", "not/telling"});
+  EXPECT_NE(request, no_body);
+}
+
 TEST(BinaryHttpResponse, EncodeNoBody) {
   /*
     HTTP/1.1 404 Not Found
@@ -572,4 +616,68 @@
   EXPECT_EQ(other, "hello, world!");
 }
 
+TEST(BinaryHttpResponse, Equality) {
+  BinaryHttpResponse response(200);
+  response.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
+  ASSERT_OK(
+      response.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}));
+
+  BinaryHttpResponse same(200);
+  same.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
+  ASSERT_OK(same.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}));
+  ASSERT_EQ(response, same);
+}
+
+TEST(BinaryHttpResponse, Inequality) {
+  BinaryHttpResponse response(200);
+  response.AddHeaderField({"Server", "Apache"})->set_body("Hello, world!\r\n");
+  ASSERT_OK(
+      response.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}));
+
+  BinaryHttpResponse different_status(201);
+  different_status.AddHeaderField({"Server", "Apache"})
+      ->set_body("Hello, world!\r\n");
+  EXPECT_OK(different_status.AddInformationalResponse(
+      102, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, different_status);
+
+  BinaryHttpResponse different_header(200);
+  different_header.AddHeaderField({"Server", "python3"})
+      ->set_body("Hello, world!\r\n");
+  EXPECT_OK(different_header.AddInformationalResponse(
+      102, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, different_header);
+
+  BinaryHttpResponse no_header(200);
+  no_header.set_body("Hello, world!\r\n");
+  EXPECT_OK(
+      no_header.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, no_header);
+
+  BinaryHttpResponse different_body(200);
+  different_body.AddHeaderField({"Server", "Apache"})
+      ->set_body("Goodbye, world!\r\n");
+  EXPECT_OK(different_body.AddInformationalResponse(
+      102, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, different_body);
+
+  BinaryHttpResponse no_body(200);
+  no_body.AddHeaderField({"Server", "Apache"});
+  EXPECT_OK(
+      no_body.AddInformationalResponse(102, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, no_body);
+
+  BinaryHttpResponse different_informational(200);
+  different_informational.AddHeaderField({"Server", "Apache"})
+      ->set_body("Hello, world!\r\n");
+  EXPECT_OK(different_informational.AddInformationalResponse(
+      198, {{"Running", "\"sleep 15\""}}));
+  EXPECT_NE(response, different_informational);
+
+  BinaryHttpResponse no_informational(200);
+  no_informational.AddHeaderField({"Server", "Apache"})
+      ->set_body("Hello, world!\r\n");
+  EXPECT_NE(response, no_informational);
+}
+
 }  // namespace quiche