XANNYANAXIUM FILE MANAGER

Navigate and manage your files

Current Directory
Upload File
Standard Upload
Advanced Upload

Status: No file selected

Create New
Name Type Size Modified Permission Actions
/ .. Directory — 2025-05-23 05:57:18 0755
/ wp-admin Directory — 2026-08-24 09:01:10 0755
/ wp-content Directory — 2026-09-23 15:34:11 0755
/ wp-includes Directory — 2026-09-23 15:34:04 0755
.htaccess HTACCESS 1.92 KB 2026-05-07 22:43:39 0644
.htaccess.bk BK 1.15 KB 2025-11-21 07:04:52 0644
.htaccess_old HTACCESS_OLD 1.80 KB 2025-11-21 07:14:55 0644
.user.ini INI 9 bytes 2026-01-05 06:16:59 0644
atomlib.php PHP 0 bytes 2026-09-22 09:09:48 0644
default.php PHP 15.99 KB 2025-05-23 12:16:32 0644
edits.php PHP 0 bytes 2026-09-22 08:49:13 0644
index.php PHP 1.30 KB 2026-09-22 06:21:28 0644
license.txt TXT 19.44 KB 2026-08-20 12:39:46 0644
phpinfo.php PHP 20 bytes 2025-05-23 05:57:32 0644
readme.html HTML 7.23 KB 2026-09-18 01:39:40 0644
robots.txt TXT 405 bytes 2026-09-22 07:12:19 0644
wp-activate.php PHP 7.54 KB 2026-08-20 12:39:46 0644
wp-blog-header.php PHP 351 bytes 2025-05-23 12:16:32 0644
wp-comments-post.php PHP 2.27 KB 2025-05-23 12:16:32 0644
wp-config-sample.php PHP 46 bytes 2026-09-23 15:34:06 0644
wp-config.php PHP 3.53 KB 2025-11-21 07:39:35 0644
wp-cron.php PHP 5.49 KB 2025-05-23 12:16:32 0644
wp-links-opml.php PHP 2.43 KB 2025-12-03 12:55:28 0644
wp-load.php PHP 3.84 KB 2025-05-23 12:16:32 0644
wp-login.php PHP 51.30 KB 2026-08-20 12:39:46 0644
wp-mail.php PHP 8.52 KB 2025-12-03 12:55:30 0644
wp-postnews.php PHP 12.59 KB 2026-09-23 09:22:15 0644
wp-settings.php PHP 32.38 KB 2026-08-20 12:39:46 0644
wp-signup.php PHP 34.26 KB 2026-08-20 12:39:46 0644
wp-sx9a.php PHP 0 bytes 2026-09-22 08:49:04 0644
wp-trackback.php PHP 5.27 KB 2026-08-20 12:39:46 0644
xmlrpc.php PHP 3.13 KB 2025-05-23 12:16:32 0644

Dir : /opt/go/pkg/mod/github.com/hashicorp/go-sockaddr@v1.0.6/
Server: Linux in-mum-web1754.main-hosting.eu 5.14.0-611.55.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue May 19 15:19:29 EDT 2026 x86_64
IP: 77.37.46.203
Choose File :
Url:
Dir : //opt/go/pkg/mod/github.com/hashicorp/go-sockaddr@v1.0.6/ipaddrs_test.go

package sockaddr_test

import (
	"fmt"
	"sort"
	"testing"

	"github.com/hashicorp/go-sockaddr"
)

type GoodTestIPAddrTest struct {
	sockAddrs               sockaddr.SockAddrs
	sortedBySpecificMasklen sockaddr.SockAddrs
	sortedByBroadMasklen    sockaddr.SockAddrs
	sortedByNetwork         sockaddr.SockAddrs
}
type GoodTestIPAddrTests []*GoodTestIPAddrTest

func makeTestIPAddrs(t *testing.T) GoodTestIPAddrTests {
	goodTestInputs := []struct {
		sockAddrs               []string
		sortedBySpecificMasklen []string
		sortedByBroadMasklen    []string
		sortedByNetwork         []string
	}{
		{
			sockAddrs: []string{
				"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
			sortedBySpecificMasklen: []string{
				"128.95.120.1/32",
				"192.168.1.10/24",
				"192.168.0.0/16",
				"172.16.1.3/12",
				"10.0.0.0/8",
				"240.0.0.1/4",
			},
			sortedByBroadMasklen: []string{
				"240.0.0.1/4",
				"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"192.168.1.10/24",
				"128.95.120.1/32",
			},
			sortedByNetwork: []string{
				"10.0.0.0/8",
				"128.95.120.1/32",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
		},
	}
	gfs := make(GoodTestIPAddrTests, 0, len(goodTestInputs))
	for idx, gfi := range goodTestInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			gf := new(GoodTestIPAddrTest)
			gf.sockAddrs = make(sockaddr.SockAddrs, 0, len(gfi.sockAddrs))
			for _, n := range gfi.sockAddrs {
				sa, err := sockaddr.NewSockAddr(n)
				if err != nil {
					t.Fatalf("Expected valid network")
				}
				gf.sockAddrs = append(gf.sockAddrs, sa)
			}

			gf.sortedBySpecificMasklen = make(sockaddr.SockAddrs, 0, len(gfi.sortedBySpecificMasklen))
			for _, n := range gfi.sortedBySpecificMasklen {
				na, err := sockaddr.NewSockAddr(n)
				if err != nil {
					t.Fatalf("Expected valid network")
				}
				gf.sortedBySpecificMasklen = append(gf.sortedBySpecificMasklen, na)
			}

			if len(gf.sockAddrs) != len(gf.sortedBySpecificMasklen) {
				t.Fatalf("Expected same number of sortedBySpecificMasklen networks")
			}

			gf.sortedByBroadMasklen = make(sockaddr.SockAddrs, 0, len(gfi.sortedByBroadMasklen))
			for _, n := range gfi.sortedByBroadMasklen {
				na, err := sockaddr.NewSockAddr(n)
				if err != nil {
					t.Fatalf("Expected valid network")
				}
				gf.sortedByBroadMasklen = append(gf.sortedByBroadMasklen, na)
			}

			if len(gf.sockAddrs) != len(gf.sortedByBroadMasklen) {
				t.Fatalf("Expected same number of sortedByBroadMasklen networks")
			}

			gf.sortedByNetwork = make(sockaddr.SockAddrs, 0, len(gfi.sortedByNetwork))
			for _, n := range gfi.sortedByNetwork {
				na, err := sockaddr.NewSockAddr(n)
				if err != nil {
					t.Fatalf("Expected valid network")
				}
				gf.sortedByNetwork = append(gf.sortedByNetwork, na)
			}

			if len(gf.sockAddrs) != len(gf.sortedByNetwork) {
				t.Fatalf("Expected same number of sortedByNetwork networks")
			}
		})
	}

	return gfs
}

func TestSockAddr_IPAddrs_BySpecificMaskLen(t *testing.T) {
	testInputs := sockAddrStringInputs{
		{
			inputAddrs: []string{"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
			sortedAddrs: []string{
				"128.95.120.1/32",
				"192.168.1.10/24",
				"192.168.0.0/16",
				"172.16.1.3/12",
				"10.0.0.0/8",
				"240.0.0.1/4",
			},
		},
	}

	for idx, test := range testInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			inputAddrs := convertToSockAddrs(t, test.inputAddrs)
			sortedAddrs := convertToSockAddrs(t, test.sortedAddrs)
			sockaddrs := append(sockaddr.SockAddrs(nil), inputAddrs...)
			filteredAddrs, _ := sockaddrs.FilterByType(sockaddr.TypeIPv4)
			ipv4Addrs := make([]sockaddr.IPv4Addr, 0, len(filteredAddrs))
			for _, x := range filteredAddrs {
				switch v := x.(type) {
				case sockaddr.IPv4Addr:
					ipv4Addrs = append(ipv4Addrs, v)
				default:
					t.Fatalf("invalid type")
				}
			}

			ipAddrs := make([]sockaddr.IPAddr, 0, len(filteredAddrs))
			for _, x := range filteredAddrs {
				ipAddr, ok := x.(sockaddr.IPAddr)
				if !ok {
					t.Fatalf("Unable to typecast to IPAddr")
				}
				ipAddrs = append(ipAddrs, ipAddr)
			}
			sort.Sort(sockaddr.SortIPAddrsBySpecificMaskLen{ipAddrs})

			var lastLen int = 32
			for i, netaddr := range ipAddrs {
				maskLen := netaddr.Maskbits()
				if lastLen < maskLen {
					t.Fatalf("Sort by specific mask length failed")
				}
				lastLen = maskLen

				if sortedAddrs[i] != netaddr {
					t.Errorf("Expected %s, received %s in iteration %d", sortedAddrs[i], netaddr, i)
				}
			}
		})
	}
}

func TestSockAddr_IPAddrs_ByBroadMaskLen(t *testing.T) {
	testInputs := sockAddrStringInputs{
		{
			inputAddrs: []string{"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
			sortedAddrs: []string{
				"240.0.0.1/4",
				"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"192.168.1.10/24",
				"128.95.120.1/32",
			},
		},
	}

	for idx, test := range testInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			inputAddrs := convertToSockAddrs(t, test.inputAddrs)
			sortedAddrs := convertToSockAddrs(t, test.sortedAddrs)
			sockaddrs := append(sockaddr.SockAddrs(nil), inputAddrs...)
			filteredAddrs, _ := sockaddrs.FilterByType(sockaddr.TypeIP)
			ipAddrs := make([]sockaddr.IPAddr, 0, len(filteredAddrs))
			for _, x := range filteredAddrs {
				ipAddr, ok := x.(sockaddr.IPAddr)
				if !ok {
					t.Fatalf("Unable to typecast to IPAddr")
				}
				ipAddrs = append(ipAddrs, ipAddr)
			}
			sort.Sort(sockaddr.SortIPAddrsByBroadMaskLen{ipAddrs})

			var lastLen int
			for i, netaddr := range ipAddrs {
				maskLen := netaddr.Maskbits()
				if lastLen > maskLen {
					t.Fatalf("Sort by specific mask length failed")
				}
				lastLen = maskLen

				if sortedAddrs[i] != netaddr {
					t.Errorf("Expected %s, received %s in iteration %d", sortedAddrs[i], netaddr, i)
				}
			}
		})
	}
}

func TestSockAddr_IPAddrs_IPAddrsByNetwork(t *testing.T) {
	testInputs := sockAddrStringInputs{
		{
			inputAddrs: []string{
				"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
			sortedAddrs: []string{
				"10.0.0.0/8",
				"128.95.120.1/32",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"192.168.1.10/24",
				"240.0.0.1/4",
			},
		},
	}

	for idx, test := range testInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			inputAddrs := convertToSockAddrs(t, test.inputAddrs)
			sortedAddrs := convertToSockAddrs(t, test.sortedAddrs)
			sockaddrs := append(sockaddr.SockAddrs(nil), inputAddrs...)
			ipaddrs, _ := sockaddrs.FilterByType(sockaddr.TypeIP)
			sockaddr.OrderedAddrBy(sockaddr.AscAddress).Sort(ipaddrs)

			var lastIpUint sockaddr.IPv4Address
			for i, sa := range ipaddrs {
				ipv4 := *sockaddr.ToIPv4Addr(sa)
				if lastIpUint > ipv4.Address {
					t.Fatalf("Sort by network failed")
				}
				lastIpUint = ipv4.Address

				if !ipv4.Equal(sortedAddrs[i]) {
					t.Errorf("[%d] Sort equality failed: expected %s, received %s", i, sortedAddrs[i], ipv4)
				}
			}
		})
	}
}

func TestSockAddr_IPAddrs_IPAddrsByNetworkSize(t *testing.T) {
	testInputs := sockAddrStringInputs{
		{
			inputAddrs: []string{
				"10.0.0.0/8",
				"172.16.1.3/12",
				"128.95.120.2:53",
				"128.95.120.2/32",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"128.95.120.2:8600",
				"240.0.0.1/4",
			},
			sortedAddrs: []string{
				"128.95.120.1/32",
				"128.95.120.2:53",
				"128.95.120.2:8600",
				"128.95.120.2/32",
				"192.168.1.10/24",
				"192.168.0.0/16",
				"172.16.1.3/12",
				"10.0.0.0/8",
				"240.0.0.1/4",
			},
		},
	}

	for idx, test := range testInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			inputAddrs := convertToSockAddrs(t, test.inputAddrs)
			sortedAddrs := convertToSockAddrs(t, test.sortedAddrs)

			sockaddrs := append(sockaddr.SockAddrs(nil), inputAddrs...)
			filteredAddrs, _ := sockaddrs.FilterByType(sockaddr.TypeIP)
			ipAddrs := make([]sockaddr.IPAddr, 0, len(filteredAddrs))
			for _, x := range filteredAddrs {
				ipAddr, ok := x.(sockaddr.IPAddr)
				if !ok {
					t.Fatalf("Unable to typecast to IPAddr")
				}
				ipAddrs = append(ipAddrs, ipAddr)
			}
			sort.Sort(sockaddr.SortIPAddrsByNetworkSize{ipAddrs})

			// var prevAddr sockaddr.IPAddr
			for i, ipAddr := range ipAddrs {
				// if i == 0 {
				// 	prevAddr = ipAddr
				// 	continue
				// }

				// if prevAddr.Cmp(ipAddr) > 0 {
				// 	t.Logf("[%d] Prev:\t%v", i, prevAddr)
				// 	t.Logf("[%d] ipAddr:\t%v", i, ipAddr)
				// 	t.Fatalf("Sort by network failed")
				// }
				// prevAddr = ipAddr

				if !ipAddr.Equal(sortedAddrs[i]) {
					t.Errorf("[%d] Sort equality failed: expected %s, received %s", i, sortedAddrs[i], ipAddr)
				}
			}
		})
	}
}

// func TestSockAddr_IPAddrs_IPAddrsByCmp(t *testing.T) {
// 	testInputs := testIPAddrsInputs{
// 		{
// 			sockAddrs: []string{
// 				"10.0.0.0/8",
// 				"172.16.1.3/12",
// 				"128.95.120.2:53",
// 				"128.95.120.2/32",
// 				"192.168.0.0/16",
// 				"128.95.120.1/32",
// 				"192.168.1.10/24",
// 				"128.95.120.2:8600",
// 				"240.0.0.1/4",
// 			},
// 			sortedSockAddrs: []string{
// 				"128.95.120.1/32",
// 				"128.95.120.2:53",
// 				"128.95.120.2:8600",
// 				"128.95.120.2/32",
// 				"192.168.1.10/24",
// 				"192.168.0.0/16",
// 				"172.16.1.3/12",
// 				"10.0.0.0/8",
// 				"240.0.0.1/4",
// 			},
// 		},
// 	}

// 	for _, test := range makeTestsFromInput(t, testInputs) {
// 		sockaddrs := append(sockaddr.SockAddrs(nil), test.sockAddrs...)
// 		ipAddrs := sockaddrs.FilterByTypeIPAddr()
// 		sort.Sort(sockaddr.SortIPAddrsByCmp{ipAddrs})
// 		t.Logf("Here: %+v", ipAddrs)

// 		var prevAddr sockaddr.IPAddr
// 		for i, ipAddr := range ipAddrs {
// 			if i == 0 {
// 				prevAddr = ipAddr
// 				continue
// 			}

// 			if prevAddr.Cmp(ipAddr) > 0 {
// 				t.Logf("[%d] Prev:\t%v", i, prevAddr)
// 				t.Logf("[%d] ipAddr:\t%v", i, ipAddr)
// 				t.Fatalf("Sort by network failed")
// 			}
// 			prevAddr = ipAddr

// 			if !ipAddr.Equal(test.sortedSockAddrs[i]) {
// 				t.Errorf("[%d] Sort equality failed: expected %s, received %s", i, test.sortedSockAddrs[i], ipAddr)
// 			}
// 		}
// 	}
// }

func TestSockAddr_IPAddrs_IPAddrsByCmp(t *testing.T) {
	testInputs := sockAddrStringInputs{
		{
			inputAddrs: []string{
				"10.0.0.0/8",
				"172.16.1.3/12",
				"128.95.120.2:53",
				"128.95.120.2:53",
				"128.95.120.2/32",
				"192.168.0.0/16",
				"128.95.120.1/32",
				"192.168.1.10/24",
				"128.95.120.2:8600",
				"0:0:0:0:0:0:0:0",
				"0:0:0:0:0:0:0:1",
				"2607:f0d0:1002:0051:0000:0000:0000:0004",
				"2607:f0d0:1002:0051:0000:0000:0000:0003",
				"2607:f0d0:1002:0051:0000:0000:0000:0005",
				"[2607:f0d0:1002:0051:0000:0000:0000:0004]:8600",
				"240.0.0.1/4",
			},
			sortedAddrs: []string{
				"10.0.0.0/8",
				"172.16.1.3/12",
				"192.168.0.0/16",
				"192.168.1.10/24",
				"240.0.0.1/4",
				"128.95.120.1/32",
				"128.95.120.2/32",
				"128.95.120.2:53",
				"128.95.120.2:53",
				"128.95.120.2:8600",
				"0:0:0:0:0:0:0:0",
				"0:0:0:0:0:0:0:1",
				"2607:f0d0:1002:0051:0000:0000:0000:0003",
				"2607:f0d0:1002:0051:0000:0000:0000:0004",
				"[2607:f0d0:1002:0051:0000:0000:0000:0004]:8600",
				"2607:f0d0:1002:0051:0000:0000:0000:0005",
			},
		},
	}

	for idx, test := range testInputs {
		t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			shuffleStrings(test.inputAddrs)

			inputAddrs := convertToSockAddrs(t, test.inputAddrs)
			sortedAddrs := convertToSockAddrs(t, test.sortedAddrs)

			sockaddr.OrderedAddrBy(sockaddr.AscType, sockaddr.AscPrivate, sockaddr.AscAddress, sockaddr.AscPort).Sort(inputAddrs)

			for i, sockAddr := range inputAddrs {
				if !sockAddr.Equal(sortedAddrs[i]) {
					t.Errorf("[%d] Sort equality failed: expected %s, received %s", i, sortedAddrs[i], sockAddr)
				}
			}
		})
	}
}