v6ops P. S. Tiesel Internet-Draft SAP SE Intended status: Best Current Practice K. Ouellette Expires: 19 May 2027 B. Patton UNH-IOL 15 November 2026 Recommendations for IPv6 Testing of Applications draft-ietf-v6ops-ipv6-app-testing-09 Abstract This document provides guidance for application developers and Software-as-a-Service (SaaS) providers on how to approach IPv6 testing in Dual-stack (IPv4+IPv6), and IPv6-only scenarios, including "IPv6-only-strict" scenarios without any connectivity towards any relevant IPv4 endpoint. The document also discusses common misconceptions about the degree to which Operating Systems and libraries can abstract IPv6 issues away and explains common regressions to avoid when deploying IPv6 support. About This Document This note is to be removed before publishing as an RFC. Status information for this document may be found at https://datatracker.ietf.org/doc/draft-ietf-v6ops-ipv6-app-testing/. Source for this draft and an issue tracker can be found at https://github.com/ietf-wg-v6ops/draft-itef-v6ops-ipv6-app-testing. Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at https://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." Tiesel, et al. Expires 19 May 2027 [Page 1] Internet-Draft ipv6-app-testing November 2026 This Internet-Draft will expire on 19 May 2027. Copyright Notice Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/ license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 2. Conventions and Definitions . . . . . . . . . . . . . . . . . 5 2.1. Requirements Language . . . . . . . . . . . . . . . . . . 5 2.2. Base Connectivity Scenarios . . . . . . . . . . . . . . . 5 2.3. Lifecycle Functions . . . . . . . . . . . . . . . . . . . 6 3. Testing Objectives . . . . . . . . . . . . . . . . . . . . . 7 3.1. Connectivity Scenarios . . . . . . . . . . . . . . . . . 7 3.2. Testing with Intermediaries (e.g., Proxies) . . . . . . . 9 3.3. Testing Name Resolution Issues . . . . . . . . . . . . . 9 3.3.1. Missing DNS Records . . . . . . . . . . . . . . . . . 10 3.3.2. Incorrect DNS Resource Records . . . . . . . . . . . 10 3.3.3. DNS Delegation Issues . . . . . . . . . . . . . . . . 11 3.3.4. Testing with IP Literals . . . . . . . . . . . . . . 11 3.3.5. Testing Reverse DNS Lookups . . . . . . . . . . . . . 11 3.3.6. Testing with Link-local Names . . . . . . . . . . . . 11 3.4. Testing with Different Transports . . . . . . . . . . . . 11 3.5. Testing with Partially Broken Connectivity, MTU, and Fragmentation Issues . . . . . . . . . . . . . . . . . . 12 3.6. Testing without IPv4 Loopback Addresses (127.0.0.0/8) . . 13 3.7. Testing Lifecycle Function Considerations . . . . . . . . 13 3.8. Testing Complex Cloud Applications and Applying Test Cases . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.9. Special Considerations for Web-based Applications . . . . 15 3.10. Considerations for Addresses as Data . . . . . . . . . . 16 4. Testing Strategies . . . . . . . . . . . . . . . . . . . . . 16 4.1. IPv6-only-strict Clients . . . . . . . . . . . . . . . . 17 4.2. IPv6-only Servers . . . . . . . . . . . . . . . . . . . . 17 4.3. Client-based Tracing . . . . . . . . . . . . . . . . . . 17 4.4. Server-based Tracing . . . . . . . . . . . . . . . . . . 18 4.5. Network-based Tracing . . . . . . . . . . . . . . . . . . 18 Tiesel, et al. Expires 19 May 2027 [Page 2] Internet-Draft ipv6-app-testing November 2026 5. Common Sources of IPv6 Related Failures and Misbehavior . . . 18 5.1. Enable IPv6 Feature Gates . . . . . . . . . . . . . . . . 19 5.2. Ignoring to Test Management and Control Interfaces . . . 19 5.3. Destination Address Selection Preference and Address Filtering . . . . . . . . . . . . . . . . . . . . . . . . 19 5.4. Listening on IPv4 Only . . . . . . . . . . . . . . . . . 20 5.5. Input Validation and Output Rendering . . . . . . . . . . 20 5.6. Connectivity Checks . . . . . . . . . . . . . . . . . . . 21 5.7. Address Bindings in Server Backends . . . . . . . . . . . 21 5.8. Misbehaving Middleboxes . . . . . . . . . . . . . . . . . 21 6. Operational Considerations . . . . . . . . . . . . . . . . . 21 6.1. Operational Scope & Software Lifecycle . . . . . . . . . 22 6.2. Allow & Deny Lists . . . . . . . . . . . . . . . . . . . 22 6.3. Component and Service Reuse . . . . . . . . . . . . . . . 22 6.4. Ownership of Software Components . . . . . . . . . . . . 23 7. Security Considerations . . . . . . . . . . . . . . . . . . . 23 8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 23 9. References . . . . . . . . . . . . . . . . . . . . . . . . . 23 9.1. Normative References . . . . . . . . . . . . . . . . . . 23 9.2. Informative References . . . . . . . . . . . . . . . . . 24 Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 29 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 29 1. Introduction For the last 20 years, enabling applications for IPv6 has focused on coexistence with IPv4 and allowing traffic to shift towards IPv6 without breaking IPv4 operation. This target has changed in part due to a series of national regulations mandating state entities to proceed in the transition to IPv6, e.g., in China [CN-CAC-2023], the United States of America [US-OMB-M-21-07], Germany [DE-BIT-2020-14], and the Czech Republic [CZ-ENDv4]. IPv6 support thus means being fully functional in the absence of IPv4 and transition technologies providing connectivity to the IPv4 Internet. Therefore, applications are expected to function regardless of whether they are used in an IPv4-only environment, a Dual-stack environment, or an IPv6-only environment, with or without connectivity to the IPv4 Internet. To achieve this, applications need to be verified against all these scenarios. Tiesel, et al. Expires 19 May 2027 [Page 3] Internet-Draft ipv6-app-testing November 2026 The availability of IPv6 support in applications, from small command- line tools to huge cloud-based distributed applications like Enterprise Resource Planning (ERP) systems, has a considerable impact on the success of IPv6 deployment. While the IETF does not define compliance tests, best current practices exist for the behavior of general IPv6 nodes [RFC8504] and Customer Edge (CE) routers [RFC7084bis], as well as for test SIP-based applications [RFC5118]. However, at the time of writing this document, there exists no documented best current practices on how to test whether applications are ready for Dual-stack and IPv6-only environments. To fill that gap, this document provides guidance for application developers and cloud application providers on how to approach IPv6 testing. It describes the parts of an application lifecycle to include, which communication scenarios they should consider validating against, and which common regressions to avoid when adding IPv6 support. While many application developers assume that the network abstractions of an OS, communication libraries, application frameworks, or embedded platforms will handle the transition towards IPv6 transparently, leaky abstractions within these frameworks will make it difficult for an application developer to write address family-independent code for features such as allow/deny lists, tracing, and logging. Testing cloud applications poses an additional challenge, as these are typically composed of hundreds to thousands of micro and macroservices, forming a complex distributed system that requires intricate communication and orchestration infrastructure to operate. Enabling these applications to communicate over IPv6 requires careful analysis of data flows towards services, between components, and towards external services as well as analysis where IPv6 addresses may occur as metadata. As the scope of applications to be guided by this document ranges from small command-line tools to huge cloud-based systems, not all details discussed here are relevant for all applications. However, the underlying idea of how to approach IPv6 application testing is the same for all of these: Don't invent new tests for IPv6, but instead test whether the functional correctness is given irrespective of the address family used for communication. In cases where IP addresses are processed as data, make sure to update the tests to support IPv4 and IPv6 addressees. The remainder of this document is organized as follows: Section 2 contains the base definitions and scenarios used throughout the document. Section 3 provides guidance on testing objectives and dimensions that should be considered in an IPv6 testing campaign. Section 4 presents practical testing strategies for setting up the Tiesel, et al. Expires 19 May 2027 [Page 4] Internet-Draft ipv6-app-testing November 2026 scenarios defined in Section 3 without building all scenarios within a lab environment. Section 5 describes common sources of IPv6-related failures and misbehavior that application developers and testers should be aware of. Finally, Section 6 describes operational considerations to keep in mind while designing end-to-end tests. 2. Conventions and Definitions 2.1. Requirements Language The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here. These words may also appear in this document in lower case as plain English words, absent their normative meanings. 2.2. Base Connectivity Scenarios This document defines the following four "base connectivity scenarios" in which applications ought to be verified for availability and functional correctness: // *Note to the RFC-Editor:* The capitalization of the following // terms should be consistent with [IPv6-ONLY]. IPv4-only: A node or application that has native connectivity towards all endpoints relevant for the test scenario using IPv4 and no connectivity towards any relevant IPv6 endpoints. While this definition is narrower than the one from [IPv6-ONLY], and mirrors the _IPv6-only-strict_ scenario, it refrains from calling it _IPv4-only-strict_ for the sake of simplicity as transition technologies allowing IPv4-only endpoints to talk to arbitrary IPv6-only endpoints are not widely deployed and encapsulation cases mentioned in [IPv6-ONLY] are covered by the either the _Dual-stack_ or _IPv6-only with NAT64_ case. Dual-stack: A node or application that has native connectivity towards all endpoints relevant for the test scenario using IPv4 as well as using IPv6. This case covers the _Dual-Stack_ and _IPv6-Mostly (for clients not supporting Option 108 [RFC8925])_ cases in [IPv6-ONLY] and narrows it down by defining the scope to test-relevant endpoints. Tiesel, et al. Expires 19 May 2027 [Page 5] Internet-Draft ipv6-app-testing November 2026 IPv6-only with NAT64: A node or application that has native connectivity towards all endpoints relevant for the test scenario using IPv6 and connectivity towards IPv4 endpoints using a transition technology like NAT64, e.g., NAT64 in combination with CLAT [RFC6877], DNS64 [RFC6147], or local address synthesis. This document does not differentiate between stateful [RFC6146-bis] and stateless [RFC7915] NAT64 variants. This case covers the _IPv6-Only_ as well as _IPv6-Mostly (for clients supporting Option 108 [RFC8925])_ cases in [IPv6-ONLY] and narrows them down by defining the scope to test-relevant endpoints. IPv6-only-strict: A node or application that has native IPv6 connectivity towards all endpoints relevant for the test scenario and no connectivity towards any relevant IPv4 endpoints, neither encapsulated nor translated. This definition narrows down the _IPv6-Only-Strict_ definition from [IPv6-ONLY] by defining the scope to test-relevant endpoints. 2.3. Lifecycle Functions Orthogonal to the base scenarios, this document defines lifecycle functions (i.e., the phases in which an application is approached during a simplified lifecycle of the application) in accordance to [US-NIST.SP.500-267Ar1] as follows: * Installation: The installation of the application including any initial configuration required for getting the application in a state where remote services are operational. * User Interface: All forms of interactive access to the application (e.g., Web User Interface (UI) or API). * Management: All forms of remote management and monitoring functions. * Update: All forms of update functions, including both automatic and manual update mechanisms. Tiesel, et al. Expires 19 May 2027 [Page 6] Internet-Draft ipv6-app-testing November 2026 3. Testing Objectives As a basic principle, IPv6 application testing should always be derived from functional and integration testing. Therefore, the goal is to verify that the expected behavior is consistent across all connectivity scenarios, i.e., the application functions correctly in IPv4-only, Dual-stack, IPv6-only with NAT64, and IPv6-only-strict settings. This section provides guidance on which connectivity scenarios and parts of the lifecycle of an application to include in a testing campaign for an ideal application that is supposed to run anywhere. It is RECOMMENDED to apply these scenarios to all existing functional, integration, and end-to-end test cases that the application's communication pattern may influence. The document also explains how to approach testing of complex cloud applications and how to exclude connectivity scenarios based on the deployment environment. Testing for application-specific or protocol-specific issues is out of scope. While this section assumes that the communication scenarios are under full control of the tester, Section 4 explains how to conduct tests in cases where control over the test environment is limited. 3.1. Connectivity Scenarios Table 1 lists the combinations of connectivity scenarios that should be considered when testing the application for IPv6 issues. Not testing some of these cases may lead to failures in operations. Note, while the involved parties are listed here as "client" and "server" to reflect the most common case, the combinations can be used the same way when considering Peer-to-Peer (P2P) applications -- with "client" representing the initiating or first acting party. The first five scenarios marked as _base_ should cover all major code paths and fallback conditions and MUST be validated to work as expected unless the application's architecture or deployment makes them irrelevant (see Section 3.8 for further discussion). These include Dual-stack clients combined with IPv4-only and IPv6-only- strict servers, to test whether the additional address family confused the client. The document also includes the cases with Dual- stack server and both IPv4-only and IPv6-only clients, to test whether a single address family at client side works as anticipated and look at the transition case using NAT64. This document does not include any special scenarios for 464XLAT [RFC6877] and IPv6-Mostly [V6MOPS], as these architectures are from the client side indistinguishable from the Dual-stack or IPv6-only with NAT64 (IPv6-Mostly without CLAT). Tiesel, et al. Expires 19 May 2027 [Page 7] Internet-Draft ipv6-app-testing November 2026 MTU issues, as described in Section 7.4.5 of [V6MOPS], that may arise form these scenarios are covered in Section 3.5. This document also do not separate IPv4-only cases with and without NAT, despite that applications exist that assume NAT for IPv4 and do not work without, as these issues are also revealed by the IPv6 scenarios. For the IPv6-only data center case, where servers may be exposed to the IPv4-only Internet using NAT46, the case marked as IPv6-only-DC in Table 1 SHOULD also be considered. This case MAY be omitted for deployments targeting IPv6-only clients. The other combinations are unlikely to exhibit additional problems for 'client/server'-based applications and, therefore, are marked as extended in Table 1. For P2P applications and applications with complex connection handling like using Session Traversal Utilities for NAT (STUN) [RFC8489] or Traversal Using Relays around NAT (TURN) [RFC8656], skipping these scenarios is strongly discouraged. +======================+======================+================+ | Client | Server | Classification | +======================+======================+================+ | Dual-stack | IPv4-only | base | +----------------------+----------------------+----------------+ | Dual-stack | IPv6-only-strict | base | +----------------------+----------------------+----------------+ | IPv4-only | Dual-stack | base | +----------------------+----------------------+----------------+ | IPv6-only with NAT64 | IPv4-only | base | +----------------------+----------------------+----------------+ | IPv6-only-strict | Dual-stack | base | +----------------------+----------------------+----------------+ | IPv4-only | IPv6-only with NAT64 | IPv6-only-DC | +----------------------+----------------------+----------------+ | Dual-stack | Dual-stack | extended | +----------------------+----------------------+----------------+ | IPv4-only | IPv4-only | extended | +----------------------+----------------------+----------------+ | IPv6-only with NAT64 | IPv6-only-strict | extended | +----------------------+----------------------+----------------+ | IPv6-only-strict | IPv6-only-strict | extended | +----------------------+----------------------+----------------+ Table 1: Connectivity scenario combinations to consider Tiesel, et al. Expires 19 May 2027 [Page 8] Internet-Draft ipv6-app-testing November 2026 3.2. Testing with Intermediaries (e.g., Proxies) Many application protocols support communicating across intermediates, most commonly HTTP Connect [RFC7230], SOCKS [RFC1928], or MASQUE [MASQUE] proxies. P2P applications often support TURN [RFC8656] as an intermediary to traverse NAT and provide connectivity between IPv4-only and IPv6-only hosts. When testing connectivity scenarios for such an application, the additional test cases including a proxy MUST also be validated. As a proxy can convert between address families, all combinations shown in Table 2, consisting of base scenarios towards the proxy and (assuming the same scenarios on both sides of the proxy) the respective base scenarios from the proxy to the server, should be considered for testing. +======================+==================+==================+ | Client | Proxy | Server | +======================+==================+==================+ | Dual-stack | IPv4-only | Dual-stack | +----------------------+------------------+------------------+ | Dual-stack | IPv6-only-strict | Dual-stack | +----------------------+------------------+------------------+ | IPv4-only | Dual-stack | IPv4-only | +----------------------+------------------+------------------+ | IPv4-only | Dual-stack | IPv6-only-strict | +----------------------+------------------+------------------+ | IPv6-only with NAT64 | IPv4-only | Dual-stack | +----------------------+------------------+------------------+ | IPv6-only-strict | Dual-stack | IPv4-only | +----------------------+------------------+------------------+ | IPv6-only-strict | Dual-stack | IPv6-only-strict | +----------------------+------------------+------------------+ Table 2: Base scenario combinations including a proxy to consider for IPv6 testing 3.3. Testing Name Resolution Issues As most applications use name resolution to bootstrap their connectivity, it is necessary to consider name resolution aspects when testing IPv6 readiness. While some name resolution issues only manifest in certain connectivity scenarios or can be mitigated by using Happy Eyeballs [RFC8305], others will just map to different connectivity scenarios. This section lists name resolution issues to consider for testing. Tiesel, et al. Expires 19 May 2027 [Page 9] Internet-Draft ipv6-app-testing November 2026 3.3.1. Missing DNS Records While a server endpoint is intended to support Dual-stack connectivity, A or AAAA DNS resource records for the endpoint may be missing (e.g., due to misconfiguration or broken tooling) or does not reach the client endpoint (e.g., because it got filtered out by a middlebox or local resolver). The same can happen for names discovered and resolved through mDNS [RFC6762], for example. While deployment and integration testing should try to test for this kind of broken connectivity, this scenario is usually indistinguishable from an IPv4-only or an IPv6-only server endpoint, and, therefore, already addressed by testing the base scenarios above. 3.3.2. Incorrect DNS Resource Records Independent of the deployed server endpoint, there may be an A and AAAA resource record pointing somewhere else, e.g., to an old or planned deployment. For either IPv4-only or IPv6-only-strict clients, this scenario should always fail. For Dual-stack clients, it MUST be tested whether they can use the working IPv4-only or IPv6-only connectivity scenario, either by using Happy Eyeballs [RFC8305] or trying the next resolved address candidate after timeout. Especially for the latter, it is advisable to verify whether the connection delay is acceptable for the desired use case. IPv6-only clients with NAT64 are only expected to work with broken AAAA records when deployed with CLAT (should behave like Dual-stack as discussed in Section 3.1) or local NAT64 address (e.g., as when implementing Happy Eyeballs v2 [RFC8305]). IPv6-only clients with NAT64 that rely on DNS64 only are expected to fail as the presence of AAAA records prevents synthesis of DNS64 records. Testing with IPv4-Mapped IPv6 addresses [RFC4291] in AAAA resource records is also RECOMMENDED. While this makes zero sense, it has been seen in the wild and should not confuse the client. Tiesel, et al. Expires 19 May 2027 [Page 10] Internet-Draft ipv6-app-testing November 2026 3.3.3. DNS Delegation Issues Integration testing for cloud applications MUST verify that the necessary domain names are resolvable from IPv4-only or IPv6-only- strict DNS resolvers. [RFC10001] describes common misconfigurations breaking IPv4-only or IPv6-only-strict in detail and provides guidance how to avoid these. Applications providing endpoints SHOULD test against these misconfigurations. 3.3.4. Testing with IP Literals Most name resolution libraries support IP literals, i.e., textual representations of IP addresses. Applications SHOULD be tested to determine whether they work as expected with IPv4 literals and all IPv6 address representations described in [RFC4291]. Some applications (client or server) may not allow for IPv4 literals. If there is a use case for link-local communication using IP literals, it MUST be tested whether the zone identifier can be entered as described in [RFC9844] and work as expected. 3.3.5. Testing Reverse DNS Lookups Applications SHOULD be tested whether they correctly resolve and display reverse DNS lookups for all address families and deal correctly with missing DNS records if reverse DNS is used anywhere in the code or runtime environment. 3.3.6. Testing with Link-local Names A name such as example.local can resolve, e.g., through DNS-Based Service Discovery [RFC6763], to one or both of a link-local IPv4 address [RFC3927] and a link-local IPv6 address. The latter is incomplete and possibly ambiguous unless associated with the relevant zone identifier or zone index [RFC4007]. Applications SHOULD be tested to determine whether they work as expected with link-local names, particularly on a host with multiple network interfaces. 3.4. Testing with Different Transports Some applications can employ different transports or protocol variants for their communication flows. Typical examples include HTTP-based applications running over TCP or QUIC [RFC9114] (over UDP) and SIP-based applications that can do signaling over UDP, TCP, and SCTP. While Transport Layer Security (TLS) or similar security layers are used for most application flows today, they may be optional from an application protocol's point of view. IPv6-related issues that only arise with certain transports or protocol variants Tiesel, et al. Expires 19 May 2027 [Page 11] Internet-Draft ipv6-app-testing November 2026 are usually hard to identify and debug in production. Because TCP transport is usually implemented in the OS, while UDP/QUIC transport is usually implemented in the application or a library shipped with it, diverging behaviors and failures in IP-family-specific corner cases are more likely. Therefore, an IP connectivity testing strategy MUST also exercise all transport and protocol variants supported by the application and that might be available at the endpoints. Testers have to assess whether these test cases use the expected transport protocol (or variant) or fall back to a less preferable transport under specific forwarding conditions. 3.5. Testing with Partially Broken Connectivity, MTU, and Fragmentation Issues When multiple address families are available, IP packets may traverse different forwarding paths depending on the address family. Even when the same forwarding path is traversed, the path can exhibit distinct forwarding behaviors, especially in the presence of middleboxes, including: * Dropping all packets * Dropping particular packets, e.g., TCP vs. UDP packets, packets destined to different port numbers * Preventing the use of QUIC, specific port numbers, or encapsulation schemes * Behaving differently for the same values of ECN or DSCP fields * Exhibiting a different Path Maximum Transmission Unit (PMTU) * Dropping some ICMP messages and breaking PMTU discovery * Dropping fragmented packets * Blocking certain protocol features, e.g., certain extensions or ciphers in TLS handshake In such scenarios, clients restricted to a single address family -- such as IPv6-only-strict clients -- may experience complete loss of connectivity, while dual-stack clients often mask such failures by automatically falling back to another address family. Disabling either address family may therefore break a scenario that seems to function correctly at first glance. Testing applications against these scenarios can become a key enabler for users' acceptance of IPv6, especially during a transition phase where partially broken connectivity is expected more frequently. Tiesel, et al. Expires 19 May 2027 [Page 12] Internet-Draft ipv6-app-testing November 2026 While this document provides no comprehensive guide on how to test for these network issues, it is REQUIRED to check applications with dual-stack servers for partial blackholing and MTU issues by testing with IPv4-only and IPv6-only-strict clients during deployment and integration testing. Note that in some cases, connectivity issues may only become apparent late in the communication process, for example, after a successful TCP handshake / QUIC initial packet, but before a TLS handshake succeeds. Because these issues can occur outside the testers' control, it is advisable to simulate them and ensure the application's behavior supports detecting and analyzing these errors. 3.6. Testing without IPv4 Loopback Addresses (127.0.0.0/8) Some applications and services may assume the existence and reachability of the IPv4 loopback addresses (127.0.0.0/8) when binding to a socket or for communicating with other services on the same host. For example, a web server may explicitly listen on a 127.0.0.0/8 by default. For IPv6-only-strict scenarios, system administrators may choose to disable IPv4, including loopback. In such cases, applications may fail to operate correctly. Applications expecting to bind to an IPv4 loopback address may fail to start when these addresses are unavailable due to a bind failure. Applications expecting these addresses to be available for inter-service communication will result in these services being unable to communicate properly. Because of this, when testing applications for the IPv6-only-strict scenario, it is RECOMMENDED to test the application in an environment without IPv4 on the loopback interface. 3.7. Testing Lifecycle Function Considerations To cover the whole lifecycle of an application including installation, user interface, management, and update, it is recommended to test that the lifecycle functions defined in Section 2.3 are operational within the connectivity scenarios defined in Table 1. Testing the normal operations of the application is encompassed by the user interface lifecycle function. In particular, the following MUST be considered: * Installation: Installation may require communications with remote first-party services (e.g., activation/license server) or remote third-party services (e.g., package repositories). In these scenarios, the installer acts as the client, and the remote service acts as the server. In cases of remote third-party services, testing all server scenarios in Table 1 may not be Tiesel, et al. Expires 19 May 2027 [Page 13] Internet-Draft ipv6-app-testing November 2026 feasible, and impact the client scenarios that can be supported. For example, if a third-party service is IPv4-only, testing an IPv6-only-strict scenario will fail. * User Interface: User interfaces can be incredibly complex with numerous contexts, views, API endpoints, CLI commands, etc. When testing an application's user interface(s), the normal operations of the application should be verified. Additionally, when testing non-web-based user interfaces, it is recommended to test components of the interface that involve communications with remote services, and those that handle network configuration parameters. For example, a network configuration interface may only accept IPv4 address literals for certain parameters. For testing web-based user interfaces, see Section 3.9. * Management: Depending on the application, management functions may be provided via the user interface. However, the application may have additional management functions (Network Configuration Protocol (NETCONF) [RFC6124], RESTCONF [RFC8040], SNMP [STD62], Open Telemetry [RFC9232], syslog [RFC5424], etc.) that should be tested. As the source triggering application behavior is crucial for logging and auditing functionality, addresses recorded need to be verified to be represented correctly. See Section 3.10 about representation of addresses. * Update: Depending on the application, update functions may be exercised during installation. However, the application may have additional update functions (e.g., automatic updates or manual update mechanisms) that should be tested. 3.8. Testing Complex Cloud Applications and Applying Test Cases Complex applications and especially cloud applications typically involve many data flows into the application, across components, and towards external services. In such a system, an application or component may be considered as a server for some communication flows, while being a client in others. Therefore, test cases need to cover each data flow in all relevant scenarios. Tiesel, et al. Expires 19 May 2027 [Page 14] Internet-Draft ipv6-app-testing November 2026 As functional and integration tests are often defined as end-to-end test cases, they often involve several components, e.g., micro- services, load-balancers, application gateways, logging, authentication, and authorization services, which use IP-based protocols between the components. Therefore, an end-to-end test case breaks down to a series of flows between components, and for each of these flows, it MUST be determine whether it is necessary to apply the connectivity scenarios from Table 1 to it, or whether the connectivity scenarios are only controlled by the deployment of the application. For external flows (i.e., flows outside the application developers' control), all base scenarios from Section 3.1 MUST be accounted for. If one side of the flow is under administrative control, the number of scenario combinations can still be limited: For example, a cloud software provider choosing to deploy Dual-stack endpoints can skip all non-Dual-stack cases on the respective side of the communication. For internal flows, the relevant scenarios only depend on the applications' architecture, and only scenarios planned in the deployment need to be considered. From a networking perspective, flows between components are typically independent, as long as endpoints are not signaled inside of the protocol. There is no need to run the Cartesian product of scenarios x communications as long as all relevant scenarios for a given flow are tested. In addition to the data flows, an implementation may include metadata about the data flow when communicating with backend systems, e.g., for logging or authorization purposes. While the flows towards these backend systems themselves may be safe to ignore as outlined above, the functional correctness of the backend systems for all kinds of IP address MUST be verified as part of the test series. Ignoring IP addresses as data in the testing may result in malfunctions, like always denying access over IPv6, or security issues, like not logging access from IPv6 clients. 3.9. Special Considerations for Web-based Applications Web-based applications usually load resources from multiple parties, including Content Delivery Networks (CDNs) and analytic tools, involving data flows to all these parties. When facing the requirement to support IPv6-only-strict users, being unable to load some resources due to missing/defective IPv6 support at the respective parties can have effects from missing analytics insights or ad revenue to severe functional defects rendering the application unusable. Tiesel, et al. Expires 19 May 2027 [Page 15] Internet-Draft ipv6-app-testing November 2026 When testing such applications, it is not sufficient to only focus on the initial/main interactions, but it is REQUIRED to consider all resources and parties providing them. As Web browsers load these resources dynamically and third-party resources may themselves may request resources from more parties, this kind of testing usually requires an instrumented Web browser, e.g., using [Selenium]. 3.10. Considerations for Addresses as Data When applications process IP addresses as data (e.g., as part of logging or management functionality), this functionality MUST work for all possible address families and representations. One challenge to consider is that the textual representation of IPv4 and IPv6 addresses are not canonical. Although [RFC5952] recommends a canonical format, all implementations MUST accept and be able to handle any legitimate [RFC4291] address format. It allows several valid textual representations for the same address, which makes direct string comparison and arithmetic operations on addresses error-prone and slow. For example, the IPv6 address 2001:db8::1 can be written as 2001:db8:0:0:0:0:0:1, 2001:0db8::0.0.0.1, or in several other forms. While custom logic to check, parse and process addresses is often error-prone and should be validated thoroughly, modern environments and frameworks usually provide data structures that encapsulate the canonical binary representation and include methods for parsing the various textual representations, comparing addresses, performing subnet operations, and rendering addresses in a consistent format. For situations where textual representation of IPv6 addresses is needed -- such as in user interfaces, logging output, and text-based data formats like JSON, YAML, TOML, and XML -- [RFC5952] provides recommendations on which of the valid textual representations should be used. Applications MUST be tested whether they follow [RFC5952] when rendering IPv6 addresses in textual form, as required by national regulations like [US-NIST.SP.500-267Ar1], while accepting all valid representations defined in [RFC4291]. 4. Testing Strategies Naive IPv6 testing, based on end-to-end functional tests as outlined in Section 3, would require running a set of functional tests in various connectivity scenarios. In certain environments, setting up test cases for all scenarios can become forbiddingly expensive, especially for complex cloud applications, application platforms, or when dealing with corporate IT environments. Tiesel, et al. Expires 19 May 2027 [Page 16] Internet-Draft ipv6-app-testing November 2026 This section gives recommendations how to set up scenarios defined in Section 3.1 and present strategies to meet the relevant testing objective by modifying Dual-stack clients and servers to conclude the results for other scenario combinations (e.g., by tracing whether the right address family is used). 4.1. IPv6-only-strict Clients This is the most natural way to test whether IPv6-only-strict clients behave correctly. The client device is either placed in a network without IPv4 connectivity or the IPv4 stack is disabled on the device while it is in a Dual-stack network. While most desktop OSes allow disabling IPv4, mobile OSes, such as Android and iOS, do not. For mobiles OSes, an IPv6-only-strict environment is needed. In both cases, it has to be ensured that there is no way to access IPv4-only resources. In particular, fallback to NAT64 must be prevented by disabling CLAT [CLAT], making sure DNS resolution does not perform DNS64 address synthesis [RFC6147] and blocking the Well- known Prefix (WKP) [RFC6052] for these clients. In addition, VPN services including privacy services like [iCloud-Private-Relay] need to be disabled as they can provide connectivity towards the IPv4 Internet. A note on the applicability of disabling IPv4: Before disabling IPv4 make sure the environment supports IPv6-only operation. Many desktop virtualization environments become unusable because IPv4 is needed to access and manage the virtual machines. Some corporate environments may render the machines unusable as they require IPv4 connectivity for sign-on. 4.2. IPv6-only Servers IPv6-only servers are a good option when setting up an IPv6-only- strict client environment is infeasible and it is clear that clients only contact a single server or a small number of servers under the testers' control. Even if setting up an IPv6-only-strict server environment is infeasible, most testing is also achievable by setting up a dedicated DNS name only containing an AAAA resource record pointing to the IPv6 addresses of an otherwise Dual-stack server. 4.3. Client-based Tracing If the tester can't limit the available address families, the tester can still trace and verify whether the address family desired for the scenario is used. Tiesel, et al. Expires 19 May 2027 [Page 17] Internet-Draft ipv6-app-testing November 2026 Client-based tracing is especially useful when Dual-stack servers and clients are available and a conclusion for the IPv6-only-strict case is desired. By using the clients' logging/tracing/debugging functionality, the tester can verify that the actual data flows happen over IPv6, which is preferred by most network abstractions. If the client allows changing the preference between IPv6 and IPv4, IPv4-only testing is also possible. The most relevant case for this strategy is testing Web applications. By examining the Web browser performance log or using a plugin like [IPvFoo] that visualizes connectivity information, the tester can determine whether all resources are available using IPv6. 4.4. Server-based Tracing Analogue to tracing on the client side, it is also possible to look at the protocols used on the server side. While this is functionally equivalent for protocols where clients only communicate to a single server, this approach is not feasible for Web-based applications where a client usually needs flows towards many servers, where client or network based tracing are the only feasible alternatives to testing with an IPv6-only-strict client. 4.5. Network-based Tracing If the communication pattern of an application is known well enough, a packet tracer such as [Wireshark] can verify that an application in a Dual-stack environment uses IPv6 for all of its flows. If this can be verified, failures in IPv6-only-strict environments are unlikely. While this is the least invasive method of testing IPv6-only-strict scenarios in a Dual-stack setup, it is the most error-prone as it requires the tester to fully understand the network flows of the application and cross-check these expected flows with the flows shown in the packet trace. 5. Common Sources of IPv6 Related Failures and Misbehavior This section discusses special failure modes that can cause unexpected application behavior that is hard to debug. Some of these cases can be automatically mitigated, especially by using Happy Eyeballs [RFC8305] or similar techniques. In cases where this is not possible or where developers choose not to implement mitigation strategies, users and operators should be supported in manual resolution by providing detailed error or debug messages. Tiesel, et al. Expires 19 May 2027 [Page 18] Internet-Draft ipv6-app-testing November 2026 5.1. Enable IPv6 Feature Gates Some applications completely ignore IPv6 unless explicitly configured to enable IPv6. This adds another class of user or configuration errors, like deploying an application without enabled IPv6 support in an IPv6-only environment. As these feature gates are often buried deeply in the documentation and are often vendor, product, or component specific, every component needs to be checked to determine whether IPv6 support needs extra configuration. 5.2. Ignoring to Test Management and Control Interfaces Ignoring management and control interfaces when enabling and testing applications for IPv6-only operation turns out to be a common pattern. As already discussed in Section 3.7, special care should be taken to cover all of these flows and avoid setups that require Dual- stack deployment. 5.3. Destination Address Selection Preference and Address Filtering The destination address selection algorithm in [RFC6724] filters unavailable address families (Rule 1), de-prioritizes non-matching address families (Rule 2), and clearly prioritizes IPv6 GUA addresses over IPv4 addresses. Some OSes and alternative resolver libraries, such as [C-ARES], implement [RFC6724] correctly. However, at the time of writing this document, major operating systems are still implementing the old behavior from [RFC3484] -- if an application relies on behavior updated through [RFC6724] or [RFC6724-update], especially preference of ULA, integration testing against this behavior SHOULD be performed. Beyond that, there are several notable and widely used implementations that implement an address selection algorithm different from [RFC6724] or its predecessor [RFC3484], causing unexpected behavior and other hard-to-debug errors: * Most JAVA runtimes do the opposite and prefer IPv4 destinations over IPv6. To prefer IPv6 addresses over IPv4, one needs to set the system property java.net.preferIPv6Addresses=true. * Some applications only use the first address candidate from the getaddrinfo() and fail if the connection attempt to that one fails. * Applications composed of services built on different programming languages or runtimes may behave inconsistently with regard to choosing destination addresses. Tiesel, et al. Expires 19 May 2027 [Page 19] Internet-Draft ipv6-app-testing November 2026 * NGINX (at the time of writing, since at least version 1.6 and unchanged in 1.31) has its own user DNS resolver without address filtering; thus, adding a _AAAA_ resource record to a backend can render that backend unusable. After having resolved a _AAAA_ resource record, it is trying to open an IPv6 socket, even when the IPv6 stack is disabled. As socket creation failure is not expected, an internal server error is sent back to the client. [NGINX.trac-552] * Some resolvers ignore address families for which no default route exists or where the default-route is pointing to an unsupported/ ignored device. This becomes cumbersome especially in split-VPN use cases (e.g. when trying to contact IPv6-only endpoints via the VPN while having IPv4-only Internet connectivity). 5.4. Listening on IPv4 Only Many tutorials and programmer facing documentations have still not been updated to cover listening on multiple address families to accept connections from both IPv6 and IPv4. Listening code should be checked whether it supports distinct listening sockets for IPv6 and IPv4, or configures IPv6 sockets to also bind to IPv4. Listening code should also be able to deal with cases where IPv6 or IPv4 have been disabled in the OS. In deployments, it is recommended to always use tools like netstat or lsof (if available) to verify all relevant address families are listened on. 5.5. Input Validation and Output Rendering While most libraries and application frameworks have decent IPv6 support, there often is still application logic that prevents taking advantage of the IPv6 support by the underlying components. Checking whether user input is a valid IPv4 address or rendering output under the assumption that an address is always an IPv4 address are typical examples for this class of limitations. Even applications that have been adapted to IPv6 may have based their input validation on wrong assumptions, e.g., checking an IPv6 address is in 2000::/3. Therefore, test cases should include IPv6 addresses from GUA (2000::/3), ULA (fc00::/7), and NAT64 WKP (64:ff9b::/96), as well as link-local (fe80::/10) range. Tiesel, et al. Expires 19 May 2027 [Page 20] Internet-Draft ipv6-app-testing November 2026 The link-local range needs special attention as addresses are incomplete and possibly ambiguous unless associated with the relevant zone identifier or zone index [RFC4007]. Testing should verify that the zone identifier or zone index are correctly displayed and can be passed if endpoints may be link-local addresses. 5.6. Connectivity Checks Some applications perform connectivity checks to determine whether Internet access is available by trying to connect to one or more well-known endpoints. If the connectivity check endpoints differ from the actual endpoints used by the application, this approach can lead to incorrect conclusions - especially in IPv6-only environments when connectivity checks are IPv4-only or in environments with strict network polices or split-tunnel VPNs. Applications should prefer implementing appropriate error handling for connectivity issues than relying on connectivity pre-checks. 5.7. Address Bindings in Server Backends Some backend services use the remote IP address of previous requests as an additional security mechanism and prevent subsequent requests from different addresses. Address changes, e.g., through Happy Eyeballs implementations trying switching address family or carrier grade NAT64 implementations mapping subsequent request to a different source, may therefore break within a session on these events. 5.8. Misbehaving Middleboxes In practice, many IPv6-related regressions uncovered during testing turn out to be caused by hidden components outside of the application developers' control. Middleboxes (e.g., firewalls, virus scanners, and intrusion detection systems) can break end-to-end tests in surprising ways, like terminating TLS sessions over IPv6 with certain extensions in the _TLS client hello_ while correctly passing the same flow over IPv4. 6. Operational Considerations Lab testing of applications for IPv6 compliance should always have the next step in mind: Deploying the application and providing the users with decent IPv6 support. Therefore, end-to-end tests, especially of cloud applications, should also keep deployment steps, prerequisites, and risks in mind. This section discusses some issues to keep in mind when planning and executing IPv6 testing. Tiesel, et al. Expires 19 May 2027 [Page 21] Internet-Draft ipv6-app-testing November 2026 6.1. Operational Scope & Software Lifecycle Depending on the application and deployment model, the timing of deploying IPv6 support may be in control of the users' organization, the developers' organization, or neither of them. Based on this setup, certain combinations of IPv6-enabled clients, servers, and infrastructure in between may or may not be excluded from consideration. Therefore, it may be necessary to add test cases for old software versions with known and already fixed bugs against newly IPv6-enabled servers. If regressions and service disruptions cannot be ruled out by the tests, a per-user or per-customer tenant opt-in/opt-out/roll-back scheme for the IPv6 enablement SHOULD be considered. 6.2. Allow & Deny Lists Application-level IP allow and deny lists pose a special challenge for deploying IPv6 in a cloud application. As users may already have IPv6 connectivity, adding IPv6 support to the server may cause clients to use IPv6 immediately. Having no allow list entry for the users' IPv6 addresses results in service disruptions. Happy Eyeballs as defined in [RFC8305] does not solve the problem as allow list checks usually take place after the transport connection has already been established. To prevent unintended exposure of services and mitigate allow or deny lists causing service disruptions when enabling IPv6, it is RECOMMENDED to enable including IPv6 addresses in allow and deny lists way before rolling out IPv6 on the transport and communicated towards the users. To further limit the probability of service disruptions, generalizing Happy Eyeballs to re-try using IPv4 after certain error conditions should be evaluated. 6.3. Component and Service Reuse If components or cloud services can be reused in other products, special care needs to be taken when planning IPv6 deployment. The interaction contracts between the reusing parties and the service need to be checked whether IPv6 enablement of the services also affects the flows of these. Additional end-to-end tests, including the reusing parties, are recommended. This is often a recursive process. Tiesel, et al. Expires 19 May 2027 [Page 22] Internet-Draft ipv6-app-testing November 2026 6.4. Ownership of Software Components Sometimes enabling IPv6 requires touching components that are not actively maintained anymore. Operators have to be prepared for this and plan extra time or budget for updating or replacing these components. 7. Security Considerations The testing procedures described in this document do not create any new security implications. Some security-related issues that should be considered and ruled out by appropriate testing are discussed in Section 5. 8. IANA Considerations This document has no IANA actions. 9. References 9.1. Normative References [CLAT] Colitti, L., Linkova, J., and T. Jensen, "464XLAT Customer-side Translator (CLAT): Node Behavior and Recommendations", Work in Progress, Internet-Draft, draft- ietf-v6ops-claton-16, 5 March 2026, . [IPv6-ONLY] Martinez, J. P., "IPv6 Terminology Definitions", Work in Progress, Internet-Draft, draft-ietf-v6ops-ipv6-only-07, 15 November 2026, . [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, . [RFC4007] Deering, S., Haberman, B., Jinmei, T., Nordmark, E., and B. Zill, "IPv6 Scoped Address Architecture", RFC 4007, DOI 10.17487/RFC4007, March 2005, . [RFC4291] Hinden, R. and S. Deering, "IP Version 6 Addressing Architecture", RFC 4291, DOI 10.17487/RFC4291, February 2006, . Tiesel, et al. Expires 19 May 2027 [Page 23] Internet-Draft ipv6-app-testing November 2026 [RFC5952] Kawamura, S. and M. Kawashima, "A Recommendation for IPv6 Address Text Representation", RFC 5952, DOI 10.17487/RFC5952, August 2010, . [RFC6052] Bao, C., Huitema, C., Bagnulo, M., Boucadair, M., and X. Li, "IPv6 Addressing of IPv4/IPv6 Translators", RFC 6052, DOI 10.17487/RFC6052, October 2010, . [RFC6147] Bagnulo, M., Sullivan, A., Matthews, P., and I. van Beijnum, "DNS64: DNS Extensions for Network Address Translation from IPv6 Clients to IPv4 Servers", RFC 6147, DOI 10.17487/RFC6147, April 2011, . [RFC6724] Thaler, D., Ed., Draves, R., Matsumoto, A., and T. Chown, "Default Address Selection for Internet Protocol Version 6 (IPv6)", RFC 6724, DOI 10.17487/RFC6724, September 2012, . [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, May 2017, . [RFC8305] Schinazi, D. and T. Pauly, "Happy Eyeballs Version 2: Better Connectivity Using Concurrency", RFC 8305, DOI 10.17487/RFC8305, December 2017, . [RFC9844] Carpenter, B. and R. Hinden, "Entering IPv6 Zone Identifiers in User Interfaces", RFC 9844, DOI 10.17487/RFC9844, August 2025, . 9.2. Informative References [C-ARES] "C-ARES - a modern DNS (stub) resolver library, written in C", n.d., . [CN-CAC-2023] "2023 Work Arrangement for Further Promoting Large-scale IPv6 Deployment and Application", 27 April 2023, . [CZ-ENDv4] "Czech Republic sets IPv4 end date", 17 January 2024, . Tiesel, et al. Expires 19 May 2027 [Page 24] Internet-Draft ipv6-app-testing November 2026 [DE-BIT-2020-14] "Beschluss Nr. 2020/14 - Zukunftsfaehige Netzinfrastrukturen auf Basis von funktionsfiaehigem IPv6", Konferenz der IT-Beauftragten der Ressorts , 11 November 2020, . Original link is broken - cached copy available at https://raw.githubusercontent.com/ietf-wg-v6ops/draft- itef-v6ops-ipv6- app-testing/refs/tags/draft-ietf-v6ops- ipv6-app-testing-05/references/ DE-BIT-2020-14.pdf [iCloud-Private-Relay] "Apple iCLoud Private Relay (WWDC2021)", n.d., . [IPvFoo] Marks, P., "IPvFoo - a Chrome/Firefox extension that adds an icon to indicate whether the current page was fetched using IPv4 or IPv6.", n.d., . [MASQUE] Schinazi, D., "The MASQUE Architecture", Work in Progress, Internet-Draft, draft-schinazi-masque-proxy-09, 27 August 2026, . [NGINX.trac-552] "Nginx doesn't honor net.ipv6.conf.all.disable_ipv6", n.d., . [RFC1928] Leech, M., Ganis, M., Lee, Y., Kuris, R., Koblas, D., and L. Jones, "SOCKS Protocol Version 5", RFC 1928, DOI 10.17487/RFC1928, March 1996, . [RFC3484] Draves, R., "Default Address Selection for Internet Protocol version 6 (IPv6)", RFC 3484, DOI 10.17487/RFC3484, March 2003, . [RFC3927] Cheshire, S., Aboba, B., and E. Guttman, "Dynamic Configuration of IPv4 Link-Local Addresses", RFC 3927, DOI 10.17487/RFC3927, May 2005, . Tiesel, et al. Expires 19 May 2027 [Page 25] Internet-Draft ipv6-app-testing November 2026 [RFC5118] Gurbani, V., Boulton, C., and R. Sparks, "Session Initiation Protocol (SIP) Torture Test Messages for Internet Protocol Version 6 (IPv6)", RFC 5118, DOI 10.17487/RFC5118, February 2008, . [RFC5424] Gerhards, R., "The Syslog Protocol", RFC 5424, DOI 10.17487/RFC5424, March 2009, . [RFC6124] Sheffer, Y., Zorn, G., Tschofenig, H., and S. Fluhrer, "An EAP Authentication Method Based on the Encrypted Key Exchange (EKE) Protocol", RFC 6124, DOI 10.17487/RFC6124, February 2011, . [RFC6146-bis] Bagnulo, M., Matthews, P., and J. P. Martinez, "Stateful NAT64: Network Address and Protocol Translation from IPv6 Clients to IPv4 Servers", Work in Progress, Internet- Draft, draft-ietf-v6ops-rfc6146-bis-16, 4 September 2026, . [RFC6724-update] Buraglio, N., Chown, T., and J. Duncan, "Prioritizing known-local IPv6 ULAs through address selection policy", Work in Progress, Internet-Draft, draft-ietf-6man-rfc6724- update-25, 11 August 2025, . [RFC6762] Cheshire, S. and M. Krochmal, "Multicast DNS", RFC 6762, DOI 10.17487/RFC6762, February 2013, . [RFC6763] Cheshire, S. and M. Krochmal, "DNS-Based Service Discovery", RFC 6763, DOI 10.17487/RFC6763, February 2013, . [RFC6877] Mawatari, M., Kawashima, M., and C. Byrne, "464XLAT: Combination of Stateful and Stateless Translation", RFC 6877, DOI 10.17487/RFC6877, April 2013, . [RFC7084bis] Lencse, G., Martinez, J. P., Patton, B., and T. Winters, "Basic Requirements for IPv6 Customer Edge Routers", Work in Progress, Internet-Draft, draft-ietf-v6ops-rfc7084bis- Tiesel, et al. Expires 19 May 2027 [Page 26] Internet-Draft ipv6-app-testing November 2026 08, 1 November 2026, . [RFC7230] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing", RFC 7230, DOI 10.17487/RFC7230, June 2014, . [RFC7915] Bao, C., Li, X., Baker, F., Anderson, T., and F. Gont, "IP/ICMP Translation Algorithm", RFC 7915, DOI 10.17487/RFC7915, June 2016, . [RFC8040] Bierman, A., Bjorklund, M., and K. Watsen, "RESTCONF Protocol", RFC 8040, DOI 10.17487/RFC8040, January 2017, . [RFC8489] Petit-Huguenin, M., Salgueiro, G., Rosenberg, J., Wing, D., Mahy, R., and P. Matthews, "Session Traversal Utilities for NAT (STUN)", RFC 8489, DOI 10.17487/RFC8489, February 2020, . [RFC8504] Chown, T., Loughney, J., and T. Winters, "IPv6 Node Requirements", BCP 220, RFC 8504, DOI 10.17487/RFC8504, January 2019, . [RFC8656] Reddy, T., Ed., Johnston, A., Ed., Matthews, P., and J. Rosenberg, "Traversal Using Relays around NAT (TURN): Relay Extensions to Session Traversal Utilities for NAT (STUN)", RFC 8656, DOI 10.17487/RFC8656, February 2020, . [RFC8925] Colitti, L., Linkova, J., Richardson, M., and T. Mrugalski, "IPv6-Only Preferred Option for DHCPv4", RFC 8925, DOI 10.17487/RFC8925, October 2020, . [RFC9114] Bishop, M., Ed., "HTTP/3", RFC 9114, DOI 10.17487/RFC9114, June 2022, . [RFC9232] Song, H., Qin, F., Martinez-Julia, P., Ciavaglia, L., and A. Wang, "Network Telemetry Framework", RFC 9232, DOI 10.17487/RFC9232, May 2022, . Tiesel, et al. Expires 19 May 2027 [Page 27] Internet-Draft ipv6-app-testing November 2026 [RFC10001] Momoka and T. Fiebig, "Operational Guidelines for DNS Transport in Mixed IPv4/IPv6 Environments", BCP 91, RFC 10001, DOI 10.17487/RFC10001, August 2026, . [Selenium] "Selenium WebDriver", n.d., . [STD62] Internet Standard 62, . At the time of writing, this STD comprises the following: Harrington, D., Presuhn, R., and B. Wijnen, "An Architecture for Describing Simple Network Management Protocol (SNMP) Management Frameworks", STD 62, RFC 3411, DOI 10.17487/RFC3411, December 2002, . Case, J., Harrington, D., Presuhn, R., and B. Wijnen, "Message Processing and Dispatching for the Simple Network Management Protocol (SNMP)", STD 62, RFC 3412, DOI 10.17487/RFC3412, December 2002, . Levi, D., Meyer, P., and B. Stewart, "Simple Network Management Protocol (SNMP) Applications", STD 62, RFC 3413, DOI 10.17487/RFC3413, December 2002, . Blumenthal, U. and B. Wijnen, "User-based Security Model (USM) for version 3 of the Simple Network Management Protocol (SNMPv3)", STD 62, RFC 3414, DOI 10.17487/RFC3414, December 2002, . Wijnen, B., Presuhn, R., and K. McCloghrie, "View-based Access Control Model (VACM) for the Simple Network Management Protocol (SNMP)", STD 62, RFC 3415, DOI 10.17487/RFC3415, December 2002, . Presuhn, R., Ed., "Version 2 of the Protocol Operations for the Simple Network Management Protocol (SNMP)", STD 62, RFC 3416, DOI 10.17487/RFC3416, December 2002, . Tiesel, et al. Expires 19 May 2027 [Page 28] Internet-Draft ipv6-app-testing November 2026 Presuhn, R., Ed., "Transport Mappings for the Simple Network Management Protocol (SNMP)", STD 62, RFC 3417, DOI 10.17487/RFC3417, December 2002, . Presuhn, R., Ed., "Management Information Base (MIB) for the Simple Network Management Protocol (SNMP)", STD 62, RFC 3418, DOI 10.17487/RFC3418, December 2002, . [US-NIST.SP.500-267Ar1] "NIST Special Publication 500-267 Revision 1 - NIST IPv6 Profile", 23 November 2020, . [US-OMB-M-21-07] "M-21-07 - Completing the Transition to Internet Protocol Version 6 (IPv6)", United States of America Office of Management and Budget Memorandum for Heads of Executive Departments and Agencies, 19 November 2020, . [V6MOPS] Buraglio, N., Caletka, O., and J. Linkova, "IPv6-mostly Networks: Deployment and Operations Considerations", Work in Progress, Internet-Draft, draft-ietf-v6ops-6mops-12, 29 October 2026, . [Wireshark] "Wireshark packet tracer", n.d., . Acknowledgments Thanks to Andrew Yourtchenko, Axel Schemberg, Brian E Carpenter, Holger Fuessler, Jeremy Duncan, Jordi Palet, Michael Perscheid, Michael Richardson, Mohamed Boucadair, Nathan Sherrard, Sulabh Soneji, and Tommy Jensen for the discussions, the input, and all contribution. Special thanks to Jen Linkova and Timothy Winters for advise on how to shape the document and finding the right set of authors. Authors' Addresses Tiesel, et al. Expires 19 May 2027 [Page 29] Internet-Draft ipv6-app-testing November 2026 Philipp S. Tiesel SAP SE Email: philipp@tiesel.net, philipp.tiesel@sap.com Kyle Ouellette University of New Hampshire Interoperability Labs Email: kouellette@iol.unh.edu Ben Patton University of New Hampshire Interoperability Labs Email: bpatton@iol.unh.edu Tiesel, et al. Expires 19 May 2027 [Page 30]