diff --git a/quiche/quic/core/internet_checksum.cc b/quiche/quic/core/internet_checksum.cc
index 746bd00..64bf1c7 100644
--- a/quiche/quic/core/internet_checksum.cc
+++ b/quiche/quic/core/internet_checksum.cc
@@ -7,6 +7,9 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
 namespace quic {
 
 void InternetChecksum::Update(const char* data, size_t size) {
@@ -25,6 +28,14 @@
   Update(reinterpret_cast<const char*>(data), size);
 }
 
+void InternetChecksum::Update(absl::string_view data) {
+  Update(data.data(), data.size());
+}
+
+void InternetChecksum::Update(absl::Span<const uint8_t> data) {
+  Update(reinterpret_cast<const char*>(data.data()), data.size());
+}
+
 uint16_t InternetChecksum::Value() const {
   uint32_t total = accumulator_;
   while (total & 0xffff0000u) {
diff --git a/quiche/quic/core/internet_checksum.h b/quiche/quic/core/internet_checksum.h
index 1faa0f0..7a23135 100644
--- a/quiche/quic/core/internet_checksum.h
+++ b/quiche/quic/core/internet_checksum.h
@@ -8,6 +8,8 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace quic {
@@ -20,8 +22,9 @@
   // If there is an extra byte at the end, the function has to be called on it
   // last.
   void Update(const char* data, size_t size);
-
   void Update(const uint8_t* data, size_t size);
+  void Update(absl::string_view data);
+  void Update(absl::Span<const uint8_t> data);
 
   uint16_t Value() const;
 
diff --git a/quiche/quic/test_tools/test_ip_packets.cc b/quiche/quic/test_tools/test_ip_packets.cc
new file mode 100644
index 0000000..c1b4b1f
--- /dev/null
+++ b/quiche/quic/test_tools/test_ip_packets.cc
@@ -0,0 +1,208 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/test_ip_packets.h"
+
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "quiche/quic/core/internet_checksum.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_data_writer.h"
+#include "quiche/common/quiche_endian.h"
+#include "quiche/common/quiche_ip_address.h"
+#include "quiche/common/quiche_ip_address_family.h"
+
+#if defined(__linux__)
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/udp.h>
+#endif
+
+namespace quic::test {
+
+namespace {
+
+// RFC791, Section 3.1. Size without the optional Options field.
+constexpr uint16_t kIpv4HeaderSize = 20;
+
+// RFC8200, Section 3.
+constexpr uint16_t kIpv6HeaderSize = 40;
+
+// RFC768.
+constexpr uint16_t kUdpHeaderSize = 8;
+constexpr uint8_t kUdpProtocol = 0x11;
+
+// For Windows compatibility, avoid dependency on netinet, but when building on
+// Linux, check that the constants match.
+#if defined(__linux__)
+static_assert(kIpv4HeaderSize == sizeof(iphdr));
+static_assert(kIpv6HeaderSize == sizeof(ip6_hdr));
+static_assert(kUdpHeaderSize == sizeof(udphdr));
+static_assert(kUdpProtocol == IPPROTO_UDP);
+#endif
+
+std::string CreateIpv4Header(int payload_length,
+                             quiche::QuicheIpAddress source_address,
+                             quiche::QuicheIpAddress destination_address,
+                             uint8_t protocol) {
+  QUICHE_CHECK_GT(payload_length, 0);
+  QUICHE_CHECK_LE(payload_length,
+                  std::numeric_limits<uint16_t>::max() - kIpv4HeaderSize);
+  QUICHE_CHECK(source_address.address_family() ==
+               quiche::IpAddressFamily::IP_V4);
+  QUICHE_CHECK(destination_address.address_family() ==
+               quiche::IpAddressFamily::IP_V4);
+
+  std::string header(kIpv4HeaderSize, '\0');
+  quiche::QuicheDataWriter header_writer(header.size(), header.data());
+
+  header_writer.WriteUInt8(0x45);  // Version: 4, Header length: 5 words
+  header_writer.WriteUInt8(0x00);  // DSCP: 0, ECN: 0
+  header_writer.WriteUInt16(kIpv4HeaderSize + payload_length);  // Total length
+  header_writer.WriteUInt16(0x0000);  // Identification: 0 (replaced by socket)
+  header_writer.WriteUInt16(0x0000);  // Flags: 0, Fragment offset: 0
+  header_writer.WriteUInt8(64);       // TTL: 64 hops/seconds
+  header_writer.WriteUInt8(protocol);
+  header_writer.WriteUInt16(0x0000);  // Checksum (replaced by socket)
+  header_writer.WriteStringPiece(source_address.ToPackedString());
+  header_writer.WriteStringPiece(destination_address.ToPackedString());
+  QUICHE_CHECK_EQ(header_writer.remaining(), 0u);
+
+  return header;
+}
+
+std::string CreateIpv6Header(int payload_length,
+                             quiche::QuicheIpAddress source_address,
+                             quiche::QuicheIpAddress destination_address,
+                             uint8_t next_header) {
+  QUICHE_CHECK_GT(payload_length, 0);
+  QUICHE_CHECK_LE(payload_length, std::numeric_limits<uint16_t>::max());
+  QUICHE_CHECK(source_address.address_family() ==
+               quiche::IpAddressFamily::IP_V6);
+  QUICHE_CHECK(destination_address.address_family() ==
+               quiche::IpAddressFamily::IP_V6);
+
+  std::string header(kIpv6HeaderSize, '\0');
+  quiche::QuicheDataWriter header_writer(header.size(), header.data());
+
+  // Version: 6
+  // Traffic class: 0
+  // Flow label: 0 (possibly replaced by socket)
+  header_writer.WriteUInt32(0x60000000);
+
+  header_writer.WriteUInt16(payload_length);
+  header_writer.WriteUInt8(next_header);
+  header_writer.WriteUInt8(64);  // Hop limit: 64
+  header_writer.WriteStringPiece(source_address.ToPackedString());
+  header_writer.WriteStringPiece(destination_address.ToPackedString());
+  QUICHE_CHECK_EQ(header_writer.remaining(), 0u);
+
+  return header;
+}
+
+}  // namespace
+
+std::string CreateIpPacket(const quiche::QuicheIpAddress& source_address,
+                           const quiche::QuicheIpAddress& destination_address,
+                           absl::string_view payload,
+                           IpPacketPayloadType payload_type) {
+  QUICHE_CHECK(source_address.address_family() ==
+               destination_address.address_family());
+
+  uint8_t payload_protocol;
+  switch (payload_type) {
+    case IpPacketPayloadType::kUdp:
+      payload_protocol = kUdpProtocol;
+      break;
+    default:
+      QUICHE_NOTREACHED();
+      return "";
+  }
+
+  std::string header;
+  switch (source_address.address_family()) {
+    case quiche::IpAddressFamily::IP_V4:
+      header = CreateIpv4Header(payload.size(), source_address,
+                                destination_address, payload_protocol);
+      break;
+    case quiche::IpAddressFamily::IP_V6:
+      header = CreateIpv6Header(payload.size(), source_address,
+                                destination_address, payload_protocol);
+      break;
+    default:
+      QUICHE_NOTREACHED();
+      return "";
+  }
+
+  return absl::StrCat(header, payload);
+}
+
+std::string CreateUdpPacket(const QuicSocketAddress& source_address,
+                            const QuicSocketAddress& destination_address,
+                            absl::string_view payload) {
+  QUICHE_CHECK(source_address.host().address_family() ==
+               destination_address.host().address_family());
+  QUICHE_CHECK(!payload.empty());
+  QUICHE_CHECK_LE(payload.size(),
+                  static_cast<uint16_t>(std::numeric_limits<uint16_t>::max() -
+                                        kUdpHeaderSize));
+
+  std::string header(kUdpHeaderSize, '\0');
+  quiche::QuicheDataWriter header_writer(header.size(), header.data());
+
+  header_writer.WriteUInt16(source_address.port());
+  header_writer.WriteUInt16(destination_address.port());
+  header_writer.WriteUInt16(kUdpHeaderSize + payload.size());
+
+  InternetChecksum checksum;
+  switch (source_address.host().address_family()) {
+    case quiche::IpAddressFamily::IP_V4: {
+      // IP pseudo header information. See RFC768.
+      checksum.Update(source_address.host().ToPackedString());
+      checksum.Update(destination_address.host().ToPackedString());
+      uint8_t protocol[] = {0x00, kUdpProtocol};
+      checksum.Update(protocol, sizeof(protocol));
+      uint16_t udp_length =
+          quiche::QuicheEndian::HostToNet16(kUdpHeaderSize + payload.size());
+      checksum.Update(reinterpret_cast<uint8_t*>(&udp_length),
+                      sizeof(udp_length));
+      break;
+    }
+    case quiche::IpAddressFamily::IP_V6: {
+      // IP pseudo header information. See RFC8200, Section 8.1.
+      checksum.Update(source_address.host().ToPackedString());
+      checksum.Update(destination_address.host().ToPackedString());
+      uint32_t udp_length =
+          quiche::QuicheEndian::HostToNet32(kUdpHeaderSize + payload.size());
+      checksum.Update(reinterpret_cast<uint8_t*>(&udp_length),
+                      sizeof(udp_length));
+      uint8_t protocol[] = {0x00, 0x00, 0x00, kUdpProtocol};
+      checksum.Update(protocol, sizeof(protocol));
+      break;
+    }
+    default:
+      QUICHE_NOTREACHED();
+      return "";
+  }
+
+  checksum.Update(header.data(), header.size());
+  checksum.Update(payload.data(), payload.size());
+  uint16_t checksum_val = checksum.Value();
+
+  // Checksum is always written in the same byte order in which it was
+  // calculated.
+  header_writer.WriteBytes(&checksum_val, sizeof(checksum_val));
+
+  QUICHE_CHECK_EQ(header_writer.remaining(), 0u);
+
+  return absl::StrCat(header, payload);
+}
+
+}  // namespace quic::test
diff --git a/quiche/quic/test_tools/test_ip_packets.h b/quiche/quic/test_tools/test_ip_packets.h
new file mode 100644
index 0000000..cda55e5
--- /dev/null
+++ b/quiche/quic/test_tools/test_ip_packets.h
@@ -0,0 +1,35 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_TEST_TOOLS_IP_PACKET_GENERATION_H_
+#define QUICHE_QUIC_TEST_TOOLS_IP_PACKET_GENERATION_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/quiche_ip_address.h"
+
+namespace quic::test {
+
+enum class IpPacketPayloadType {
+  kUdp,
+};
+
+// Create an IP packet, appropriate for sending to a raw IP socket.
+std::string CreateIpPacket(
+    const quiche::QuicheIpAddress& source_address,
+    const quiche::QuicheIpAddress& destination_address,
+    absl::string_view payload,
+    IpPacketPayloadType payload_type = IpPacketPayloadType::kUdp);
+
+// Create a UDP packet, appropriate for sending to a raw UDP socket or including
+// as the payload of an IP packet.
+std::string CreateUdpPacket(const QuicSocketAddress& source_address,
+                            const QuicSocketAddress& destination_address,
+                            absl::string_view payload);
+
+}  // namespace quic::test
+
+#endif  // QUICHE_QUIC_TEST_TOOLS_IP_PACKET_GENERATION_H_
diff --git a/quiche/quic/test_tools/test_ip_packets_test.cc b/quiche/quic/test_tools/test_ip_packets_test.cc
new file mode 100644
index 0000000..e60fc13
--- /dev/null
+++ b/quiche/quic/test_tools/test_ip_packets_test.cc
@@ -0,0 +1,90 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/test_tools/test_ip_packets.h"
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_ip_address.h"
+
+namespace quic::test {
+namespace {
+
+TEST(TestIpPacketsTest, CreateIpv4Packet) {
+  quiche::QuicheIpAddress source_ip;
+  ASSERT_TRUE(source_ip.FromString("192.0.2.45"));
+  ASSERT_TRUE(source_ip.IsIPv4());
+  QuicSocketAddress source_address{source_ip, /*port=*/54131};
+
+  quiche::QuicheIpAddress destination_ip;
+  ASSERT_TRUE(destination_ip.FromString("192.0.2.67"));
+  ASSERT_TRUE(destination_ip.IsIPv4());
+  QuicSocketAddress destination_address(destination_ip, /*port=*/57542);
+
+  std::string packet =
+      CreateIpPacket(source_ip, destination_ip,
+                     CreateUdpPacket(source_address, destination_address,
+                                     /*payload=*/"foo"),
+                     IpPacketPayloadType::kUdp);
+
+  constexpr static char kExpected[] =
+      "\x45"              // Version: 4, Header length: 5 words
+      "\x00"              // DSCP: 0, ECN: 0
+      "\x00\x1F"          // Total length: 31
+      "\x00\x00"          // Id: 0
+      "\x00\x00"          // Flags: 0, Fragment offset: 0
+      "\x40"              // TTL: 64 hops
+      "\x11"              // Protocol: 17 (UDP)
+      "\x00\x00"          // Header checksum: 0
+      "\xC0\x00\x02\x2D"  // Source IP
+      "\xC0\x00\x02\x43"  // Destination IP
+      "\xD3\x73"          // Source port
+      "\xE0\xC6"          // Destination port
+      "\x00\x0B"          // Length: 11
+      "\xF1\xBC"          // Checksum: 0xF1BC
+      "foo";              // Payload
+  EXPECT_EQ(absl::string_view(packet),
+            absl::string_view(kExpected, sizeof(kExpected) - 1));
+}
+
+TEST(TestIpPacketsTest, CreateIpv6Packet) {
+  quiche::QuicheIpAddress source_ip;
+  ASSERT_TRUE(source_ip.FromString("2001:db8::45"));
+  ASSERT_TRUE(source_ip.IsIPv6());
+  QuicSocketAddress source_address{source_ip, /*port=*/51941};
+
+  quiche::QuicheIpAddress destination_ip;
+  ASSERT_TRUE(destination_ip.FromString("2001:db8::67"));
+  ASSERT_TRUE(destination_ip.IsIPv6());
+  QuicSocketAddress destination_address(destination_ip, /*port=*/55341);
+
+  std::string packet =
+      CreateIpPacket(source_ip, destination_ip,
+                     CreateUdpPacket(source_address, destination_address,
+                                     /*payload=*/"foo"),
+                     IpPacketPayloadType::kUdp);
+
+  constexpr static char kExpected[] =
+      "\x60\x00\x00\x00"  // Version: 6, Traffic class: 0, Flow label: 0
+      "\x00\x0b"          // Payload length: 11
+      "\x11"              // Next header: 17 (UDP)
+      "\x40"              // Hop limit: 64
+      // Source IP
+      "\x20\x01\x0D\xB8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45"
+      // Destination IP
+      "\x20\x01\x0D\xB8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67"
+      "\xCA\xE5"  // Source port
+      "\xD8\x2D"  // Destination port
+      "\x00\x0B"  // Length: 11
+      "\x2B\x37"  // Checksum: 0x2B37
+      "foo";      // Payload
+  EXPECT_EQ(absl::string_view(packet),
+            absl::string_view(kExpected, sizeof(kExpected) - 1));
+}
+
+}  // namespace
+}  // namespace quic::test