cloudstack/resource_cloudstack_network_unit_test.go - cloudstack-terraform-provider - Git at Google

 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //

 package cloudstack

 import (
 	"net"
 	"strings"
 	"testing"

 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )

 func TestParseCIDRv6_DefaultGateway(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/64",
 	})

 	result, err := parseCIDRv6(d, false)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// Default gateway should be network address + 1
 	expectedGateway := "2001:db8::1"
 	if result["ip6gateway"] != expectedGateway {
 		t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
 	}

 	// When specifyiprange is false, startipv6 and endipv6 should not be set
 	if _, ok := result["startipv6"]; ok {
 		t.Errorf("startipv6 should not be set when specifyiprange is false")
 	}
 	if _, ok := result["endipv6"]; ok {
 		t.Errorf("endipv6 should not be set when specifyiprange is false")
 	}
 }

 func TestParseCIDRv6_CustomGateway(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr":    "2001:db8::/64",
 		"ip6gateway": "2001:db8::1",
 	})

 	result, err := parseCIDRv6(d, false)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	expectedGateway := "2001:db8::1"
 	if result["ip6gateway"] != expectedGateway {
 		t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
 	}
 }

 func TestParseCIDRv6_WithIPRange(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/64",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// Check gateway (should be network address + 1)
 	expectedGateway := "2001:db8::1"
 	if result["ip6gateway"] != expectedGateway {
 		t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
 	}

 	// Check start IP (should be network address + 2)
 	expectedStartIP := "2001:db8::2"
 	if result["startipv6"] != expectedStartIP {
 		t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
 	}

 	// Check end IP (should be the last address in the /64 range)
 	expectedEndIP := "2001:db8::ffff:ffff:ffff:ffff"
 	if result["endipv6"] != expectedEndIP {
 		t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
 	}
 }

 func TestParseCIDRv6_CustomIPRange(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr":   "2001:db8:1::/64",
 		"startipv6": "2001:db8:1::100",
 		"endipv6":   "2001:db8:1::200",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// Check that custom values are used
 	if result["startipv6"] != "2001:db8:1::100" {
 		t.Errorf("Expected custom start IP 2001:db8:1::100, got %s", result["startipv6"])
 	}
 	if result["endipv6"] != "2001:db8:1::200" {
 		t.Errorf("Expected custom end IP 2001:db8:1::200, got %s", result["endipv6"])
 	}
 }

 func TestParseCIDRv6_SmallerPrefix(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/48",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// For a /48, the end IP should have the last 80 bits set to 1
 	expectedEndIP := "2001:db8:0:ffff:ffff:ffff:ffff:ffff"
 	if result["endipv6"] != expectedEndIP {
 		t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
 	}
 }

 func TestParseCIDRv6_RejectsIPv4(t *testing.T) {
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "10.0.0.0/24",
 	})

 	_, err := parseCIDRv6(d, false)
 	if err == nil {
 		t.Fatal("parseCIDRv6 should reject IPv4 CIDR")
 	}

 	expectedError := "ip6cidr must be an IPv6 CIDR, got IPv4"
 	if !strings.HasPrefix(err.Error(), expectedError) {
 		t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
 	}
 }

 func TestParseCIDRv6_Prefix128_NoIPRange(t *testing.T) {
 	// /128 is a single address - should fail even without IP range
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::1/128",
 	})

 	_, err := parseCIDRv6(d, false)
 	if err == nil {
 		t.Fatal("parseCIDRv6 should reject /128 prefix (single address)")
 	}

 	expectedError := "ip6cidr prefix /128 is too small"
 	if !strings.HasPrefix(err.Error(), expectedError) {
 		t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
 	}
 }

 func TestParseCIDRv6_Prefix127_NoIPRange(t *testing.T) {
 	// /127 has 2 addresses - should work without IP range (only needs gateway)
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/127",
 	})

 	result, err := parseCIDRv6(d, false)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 should accept /127 prefix without IP range: %v", err)
 	}

 	// Should have gateway
 	if _, ok := result["ip6gateway"]; !ok {
 		t.Error("Expected ip6gateway to be set")
 	}

 	// Should not have start/end IP
 	if _, ok := result["startipv6"]; ok {
 		t.Error("startipv6 should not be set when specifyiprange is false")
 	}
 }

 func TestParseCIDRv6_Prefix127_WithIPRange(t *testing.T) {
 	// /127 has only 2 addresses - should fail with IP range (needs 3+ addresses)
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/127",
 	})

 	_, err := parseCIDRv6(d, true)
 	if err == nil {
 		t.Fatal("parseCIDRv6 should reject /127 prefix with IP range (only 2 addresses)")
 	}

 	expectedError := "ip6cidr prefix /127 is too small for automatic IP range generation"
 	if !strings.HasPrefix(err.Error(), expectedError) {
 		t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
 	}
 }

 func TestParseCIDRv6_Prefix126_WithIPRange(t *testing.T) {
 	// /126 has 4 addresses - should work with IP range
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::/126",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 should accept /126 prefix with IP range: %v", err)
 	}

 	// Should have gateway, start, and end
 	if _, ok := result["ip6gateway"]; !ok {
 		t.Error("Expected ip6gateway to be set")
 	}
 	if _, ok := result["startipv6"]; !ok {
 		t.Error("Expected startipv6 to be set")
 	}
 	if _, ok := result["endipv6"]; !ok {
 		t.Error("Expected endipv6 to be set")
 	}

 	// Verify the end IP is correct for /126 (last 2 bits set to 1)
 	expectedEndIP := "2001:db8::3"
 	if result["endipv6"] != expectedEndIP {
 		t.Errorf("Expected end IP %s for /126, got %s", expectedEndIP, result["endipv6"])
 	}
 }

 func TestParseCIDRv6_NonZeroNetworkAddress(t *testing.T) {
 	// Test with a CIDR where the network address doesn't end in ::0
 	// This tests the fix for proper IPv6 address arithmetic with carry
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::4/126",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// For 2001:db8::4/126, the network is 2001:db8::4
 	// Gateway should be network + 1 = 2001:db8::5
 	expectedGateway := "2001:db8::5"
 	if result["ip6gateway"] != expectedGateway {
 		t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
 	}

 	// Start IP should be network + 2 = 2001:db8::6
 	expectedStartIP := "2001:db8::6"
 	if result["startipv6"] != expectedStartIP {
 		t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
 	}

 	// End IP should be network + 3 = 2001:db8::7 (last address in /126)
 	expectedEndIP := "2001:db8::7"
 	if result["endipv6"] != expectedEndIP {
 		t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
 	}
 }

 func TestParseCIDRv6_NonAlignedPrefix(t *testing.T) {
 	// Test with a /124 prefix where network address has non-zero low-order bits
 	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
 		"ip6cidr": "2001:db8::f0/124",
 	})

 	result, err := parseCIDRv6(d, true)
 	if err != nil {
 		t.Fatalf("parseCIDRv6 failed: %v", err)
 	}

 	// For 2001:db8::f0/124, the network is 2001:db8::f0
 	// Gateway should be network + 1 = 2001:db8::f1
 	expectedGateway := "2001:db8::f1"
 	if result["ip6gateway"] != expectedGateway {
 		t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
 	}

 	// Start IP should be network + 2 = 2001:db8::f2
 	expectedStartIP := "2001:db8::f2"
 	if result["startipv6"] != expectedStartIP {
 		t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
 	}

 	// End IP should be 2001:db8::ff (last address in /124)
 	expectedEndIP := "2001:db8::ff"
 	if result["endipv6"] != expectedEndIP {
 		t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
 	}
 }

 func TestAddToIPv6_CarryAcrossBytes(t *testing.T) {
 	// Exercise addToIPv6 directly with addresses that force a carry from the
 	// low byte into higher bytes (which a masked network address never would).
 	cases := []struct {
 		name     string
 		input    string
 		offset   uint64
 		expected string
 	}{
 		{"carry into next byte", "2001:db8::ff", 1, "2001:db8::100"},
 		{"carry across two bytes", "2001:db8::ffff", 1, "2001:db8::1:0"},
 		{"offset of two with carry", "2001:db8::ff", 2, "2001:db8::101"},
 		{"no carry", "2001:db8::", 1, "2001:db8::1"},
 	}

 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			got := addToIPv6(net.ParseIP(tc.input), tc.offset).String()
 			if got != tc.expected {
 				t.Errorf("addToIPv6(%s, %d) = %s, expected %s", tc.input, tc.offset, got, tc.expected)
 			}
 		})
 	}
 }
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//

	package cloudstack

	import (
	"net"
	"strings"
	"testing"

	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
	)

	func TestParseCIDRv6_DefaultGateway(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/64",
	})

	result, err := parseCIDRv6(d, false)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// Default gateway should be network address + 1
	expectedGateway := "2001:db8::1"
	if result["ip6gateway"] != expectedGateway {
	t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
	}

	// When specifyiprange is false, startipv6 and endipv6 should not be set
	if _, ok := result["startipv6"]; ok {
	t.Errorf("startipv6 should not be set when specifyiprange is false")
	}
	if _, ok := result["endipv6"]; ok {
	t.Errorf("endipv6 should not be set when specifyiprange is false")
	}
	}

	func TestParseCIDRv6_CustomGateway(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/64",
	"ip6gateway": "2001:db8::1",
	})

	result, err := parseCIDRv6(d, false)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	expectedGateway := "2001:db8::1"
	if result["ip6gateway"] != expectedGateway {
	t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
	}
	}

	func TestParseCIDRv6_WithIPRange(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/64",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// Check gateway (should be network address + 1)
	expectedGateway := "2001:db8::1"
	if result["ip6gateway"] != expectedGateway {
	t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
	}

	// Check start IP (should be network address + 2)
	expectedStartIP := "2001:db8::2"
	if result["startipv6"] != expectedStartIP {
	t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
	}

	// Check end IP (should be the last address in the /64 range)
	expectedEndIP := "2001:db8::ffff:ffff:ffff:ffff"
	if result["endipv6"] != expectedEndIP {
	t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
	}
	}

	func TestParseCIDRv6_CustomIPRange(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8:1::/64",
	"startipv6": "2001:db8:1::100",
	"endipv6": "2001:db8:1::200",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// Check that custom values are used
	if result["startipv6"] != "2001:db8:1::100" {
	t.Errorf("Expected custom start IP 2001:db8:1::100, got %s", result["startipv6"])
	}
	if result["endipv6"] != "2001:db8:1::200" {
	t.Errorf("Expected custom end IP 2001:db8:1::200, got %s", result["endipv6"])
	}
	}

	func TestParseCIDRv6_SmallerPrefix(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/48",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// For a /48, the end IP should have the last 80 bits set to 1
	expectedEndIP := "2001:db8:0:ffff:ffff:ffff:ffff:ffff"
	if result["endipv6"] != expectedEndIP {
	t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
	}
	}

	func TestParseCIDRv6_RejectsIPv4(t *testing.T) {
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "10.0.0.0/24",
	})

	_, err := parseCIDRv6(d, false)
	if err == nil {
	t.Fatal("parseCIDRv6 should reject IPv4 CIDR")
	}

	expectedError := "ip6cidr must be an IPv6 CIDR, got IPv4"
	if !strings.HasPrefix(err.Error(), expectedError) {
	t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
	}
	}

	func TestParseCIDRv6_Prefix128_NoIPRange(t *testing.T) {
	// /128 is a single address - should fail even without IP range
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::1/128",
	})

	_, err := parseCIDRv6(d, false)
	if err == nil {
	t.Fatal("parseCIDRv6 should reject /128 prefix (single address)")
	}

	expectedError := "ip6cidr prefix /128 is too small"
	if !strings.HasPrefix(err.Error(), expectedError) {
	t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
	}
	}

	func TestParseCIDRv6_Prefix127_NoIPRange(t *testing.T) {
	// /127 has 2 addresses - should work without IP range (only needs gateway)
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/127",
	})

	result, err := parseCIDRv6(d, false)
	if err != nil {
	t.Fatalf("parseCIDRv6 should accept /127 prefix without IP range: %v", err)
	}

	// Should have gateway
	if _, ok := result["ip6gateway"]; !ok {
	t.Error("Expected ip6gateway to be set")
	}

	// Should not have start/end IP
	if _, ok := result["startipv6"]; ok {
	t.Error("startipv6 should not be set when specifyiprange is false")
	}
	}

	func TestParseCIDRv6_Prefix127_WithIPRange(t *testing.T) {
	// /127 has only 2 addresses - should fail with IP range (needs 3+ addresses)
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/127",
	})

	_, err := parseCIDRv6(d, true)
	if err == nil {
	t.Fatal("parseCIDRv6 should reject /127 prefix with IP range (only 2 addresses)")
	}

	expectedError := "ip6cidr prefix /127 is too small for automatic IP range generation"
	if !strings.HasPrefix(err.Error(), expectedError) {
	t.Errorf("Expected error message to start with '%s', got '%s'", expectedError, err.Error())
	}
	}

	func TestParseCIDRv6_Prefix126_WithIPRange(t *testing.T) {
	// /126 has 4 addresses - should work with IP range
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::/126",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 should accept /126 prefix with IP range: %v", err)
	}

	// Should have gateway, start, and end
	if _, ok := result["ip6gateway"]; !ok {
	t.Error("Expected ip6gateway to be set")
	}
	if _, ok := result["startipv6"]; !ok {
	t.Error("Expected startipv6 to be set")
	}
	if _, ok := result["endipv6"]; !ok {
	t.Error("Expected endipv6 to be set")
	}

	// Verify the end IP is correct for /126 (last 2 bits set to 1)
	expectedEndIP := "2001:db8::3"
	if result["endipv6"] != expectedEndIP {
	t.Errorf("Expected end IP %s for /126, got %s", expectedEndIP, result["endipv6"])
	}
	}

	func TestParseCIDRv6_NonZeroNetworkAddress(t *testing.T) {
	// Test with a CIDR where the network address doesn't end in ::0
	// This tests the fix for proper IPv6 address arithmetic with carry
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::4/126",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// For 2001:db8::4/126, the network is 2001:db8::4
	// Gateway should be network + 1 = 2001:db8::5
	expectedGateway := "2001:db8::5"
	if result["ip6gateway"] != expectedGateway {
	t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
	}

	// Start IP should be network + 2 = 2001:db8::6
	expectedStartIP := "2001:db8::6"
	if result["startipv6"] != expectedStartIP {
	t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
	}

	// End IP should be network + 3 = 2001:db8::7 (last address in /126)
	expectedEndIP := "2001:db8::7"
	if result["endipv6"] != expectedEndIP {
	t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
	}
	}

	func TestParseCIDRv6_NonAlignedPrefix(t *testing.T) {
	// Test with a /124 prefix where network address has non-zero low-order bits
	d := schema.TestResourceDataRaw(t, resourceCloudStackNetwork().Schema, map[string]interface{}{
	"ip6cidr": "2001:db8::f0/124",
	})

	result, err := parseCIDRv6(d, true)
	if err != nil {
	t.Fatalf("parseCIDRv6 failed: %v", err)
	}

	// For 2001:db8::f0/124, the network is 2001:db8::f0
	// Gateway should be network + 1 = 2001:db8::f1
	expectedGateway := "2001:db8::f1"
	if result["ip6gateway"] != expectedGateway {
	t.Errorf("Expected gateway %s, got %s", expectedGateway, result["ip6gateway"])
	}

	// Start IP should be network + 2 = 2001:db8::f2
	expectedStartIP := "2001:db8::f2"
	if result["startipv6"] != expectedStartIP {
	t.Errorf("Expected start IP %s, got %s", expectedStartIP, result["startipv6"])
	}

	// End IP should be 2001:db8::ff (last address in /124)
	expectedEndIP := "2001:db8::ff"
	if result["endipv6"] != expectedEndIP {
	t.Errorf("Expected end IP %s, got %s", expectedEndIP, result["endipv6"])
	}
	}

	func TestAddToIPv6_CarryAcrossBytes(t *testing.T) {
	// Exercise addToIPv6 directly with addresses that force a carry from the
	// low byte into higher bytes (which a masked network address never would).
	cases := []struct {
	name string
	input string
	offset uint64
	expected string
	}{
	{"carry into next byte", "2001:db8::ff", 1, "2001:db8::100"},
	{"carry across two bytes", "2001:db8::ffff", 1, "2001:db8::1:0"},
	{"offset of two with carry", "2001:db8::ff", 2, "2001:db8::101"},
	{"no carry", "2001:db8::", 1, "2001:db8::1"},
	}

	for _, tc := range cases {
	t.Run(tc.name, func(t *testing.T) {
	got := addToIPv6(net.ParseIP(tc.input), tc.offset).String()
	if got != tc.expected {
	t.Errorf("addToIPv6(%s, %d) = %s, expected %s", tc.input, tc.offset, got, tc.expected)
	}
	})
	}
	}