Repository Public License
1// ORIX Secure2// File: Packages/ORIXNetworkLab/Tests/ORIXNetworkLabTests/LogicTests.swift3// Description: Deterministic tests: host name matching, address classification, latency statistics, DNS error mapping,4// change-log diffing, proxy/VPN interpretation, HSTS and endpoint parsing, Bonjour helpers.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import Foundation9import Network10@testable import ORIXNetworkLab11import ORIXSecureModel12import Testing1314@Suite("Host name matching (RFC 6125)")15struct HostnameMatcherTests {16 static let cases: [(host: String, pattern: String, expected: Bool)] = [17 ("example.com", "example.com", true),18 ("EXAMPLE.com", "example.COM", true),19 ("example.com.", "example.com", true),20 ("example.com", "example.com.", true),21 ("www.example.com", "example.com", false),22 ("example.com", "www.example.com", false),23 ("www.example.com", "*.example.com", true),24 ("WWW.Example.Com", "*.EXAMPLE.com", true),25 ("example.com", "*.example.com", false),26 ("a.b.example.com", "*.example.com", false),27 ("b.example.com", "*.b.example.com", false),28 ("a.b.example.com", "*.b.example.com", true),29 ("www.example.com", "w*.example.com", false),30 ("www.example.com", "*w.example.com", false),31 ("www.example.com", "www.*.com", false),32 ("www.example.com", "*.*.com", false),33 ("www.example.com", "*", false),34 ("example.com", "*.com", false),35 ("com", "*", false),36 ("foo.co.uk", "*.co.uk", false),37 ("foo.com.au", "*.com.au", false),38 ("foo.qc.ca", "*.qc.ca", false),39 ("shop.example.co.uk", "*.example.co.uk", true),40 ("xn--bcher-kva.example.com", "xn--bcher-kva.example.com", true),41 ("bücher.example.com", "xn--bcher-kva.example.com", true),42 ("xn--bcher-kva.example.com", "*.example.com", true),43 ("www.xn--bcher-kva.de", "*.xn--bcher-kva.de", true),44 ("www.example.com", "xn--*.example.com", false),45 ("192.168.1.1", "192.168.1.1", false),46 ("192.168.1.1", "*.168.1.1", false),47 ("1.example.com", "*.example.com", true),48 ("www.example.com", "", false),49 ("", "example.com", false),50 ("www..example.com", "*.example.com", false),51 ("www.example.com", "*.example.com.", true),52 ("www.example.com.", "*.example.com", true),53 ("evil.com", "*.example.com", false),54 ("wwwexample.com", "*.example.com", false),55 ("www.example.com\u{0}.evil.com", "*.evil.com", false),56 ("sub_domain.example.com", "*.example.com", true),57 ]5859 @Test func matchingTable() {60 #expect(Self.cases.count >= 25)61 for entry in Self.cases {62 let result = HostnameMatcher.matches(host: entry.host, pattern: entry.pattern)63 #expect(result == entry.expected, "host “\(entry.host)” against “\(entry.pattern)”")64 }65 }6667 @Test func coverageUsesIPSANsForAddressesOnly() {68 #expect(HostnameMatcher.covers(host: "192.0.2.10", dnsNames: ["192.0.2.10"], ipAddresses: []) == false)69 #expect(HostnameMatcher.covers(host: "192.0.2.10", dnsNames: [], ipAddresses: ["192.0.2.10"]))70 #expect(HostnameMatcher.covers(host: "192.0.2.11", dnsNames: [], ipAddresses: ["192.0.2.10"]) == false)71 #expect(HostnameMatcher.covers(host: "2001:DB8:0:0:0:0:0:10", dnsNames: [], ipAddresses: ["2001:db8::10"]))72 #expect(HostnameMatcher.covers(host: "[2001:db8::10]", dnsNames: [], ipAddresses: ["2001:db8::10"]))73 #expect(HostnameMatcher.covers(host: "::1", dnsNames: ["localhost"], ipAddresses: ["127.0.0.1"]) == false)74 #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: ["example.com", "*.example.com"], ipAddresses: []))75 #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: [], ipAddresses: ["192.0.2.10"]) == false)76 #expect(HostnameMatcher.covers(host: "www.example.com", dnsNames: [], ipAddresses: []) == false)77 }7879 @Test func normalization() {80 #expect(HostnameMatcher.normalize("Example.COM.") == "example.com")81 #expect(HostnameMatcher.normalize("bücher.example") == "xn--bcher-kva.example")82 #expect(HostnameMatcher.normalize("") == nil)83 #expect(HostnameMatcher.normalize("a..b") == nil)84 #expect(HostnameMatcher.normalize("a b.com") == nil)85 #expect(HostnameMatcher.normalize(String(repeating: "a", count: 64) + ".com") == nil)86 #expect(HostnameMatcher.isPublicSuffixLike("co.uk"))87 #expect(!HostnameMatcher.isPublicSuffixLike("example.com"))88 #expect(!HostnameMatcher.isPublicSuffixLike("example.co.uk"))89 }90}9192@Suite("Address classification")93struct AddressClassificationTests {94 static let cases: [(String, AddressFamily, AddressScope)] = [95 ("127.0.0.1", .ipv4, .loopback),96 ("127.255.255.254", .ipv4, .loopback),97 ("10.0.0.1", .ipv4, .privateRFC1918),98 ("10.255.255.255", .ipv4, .privateRFC1918),99 ("172.16.0.1", .ipv4, .privateRFC1918),100 ("172.31.255.255", .ipv4, .privateRFC1918),101 ("172.15.255.255", .ipv4, .global),102 ("172.32.0.1", .ipv4, .global),103 ("192.168.2.104", .ipv4, .privateRFC1918),104 ("192.169.0.1", .ipv4, .global),105 ("100.64.0.1", .ipv4, .carrierGradeNAT),106 ("100.127.255.255", .ipv4, .carrierGradeNAT),107 ("100.63.255.255", .ipv4, .global),108 ("100.128.0.1", .ipv4, .global),109 ("169.254.10.20", .ipv4, .linkLocal),110 ("224.0.0.251", .ipv4, .multicast),111 ("239.255.255.250", .ipv4, .multicast),112 ("255.255.255.255", .ipv4, .reserved),113 ("240.0.0.1", .ipv4, .reserved),114 ("0.0.0.0", .ipv4, .unspecified),115 ("192.0.2.1", .ipv4, .reserved),116 ("198.51.100.7", .ipv4, .reserved),117 ("203.0.113.9", .ipv4, .reserved),118 ("198.18.0.1", .ipv4, .reserved),119 ("8.8.8.8", .ipv4, .global),120 ("17.253.144.10", .ipv4, .global),121 ("::1", .ipv6, .loopback),122 ("::", .ipv6, .unspecified),123 ("fe80::1", .ipv6, .linkLocal),124 ("fe80::1%en0", .ipv6, .linkLocal),125 ("febf::1", .ipv6, .linkLocal),126 ("fec0::1", .ipv6, .reserved),127 ("fc00::1", .ipv6, .uniqueLocal),128 ("fd12:3456:789a::1", .ipv6, .uniqueLocal),129 ("ff02::fb", .ipv6, .multicast),130 ("2001:db8::1", .ipv6, .reserved),131 ("2607:f8b0:4004:800::200e", .ipv6, .global),132 ("2a01:b740:a41::10", .ipv6, .global),133 ("64:ff9b::808:808", .ipv6, .global),134 ("::ffff:192.168.1.1", .ipv6, .privateRFC1918),135 ("::ffff:8.8.8.8", .ipv6, .global),136 ("[2001:db8::1]", .ipv6, .reserved),137 ]138139 @Test func classificationTable() {140 for (text, family, scope) in Self.cases {141 let address = IPAddress(text)142 #expect(address != nil, "parse \(text)")143 #expect(address?.family == family, "family of \(text)")144 #expect(address?.scope == scope, "scope of \(text)")145 }146 }147148 @Test func parsingAndFormatting() {149 #expect(IPAddress("not an address") == nil)150 #expect(IPAddress("") == nil)151 #expect(IPAddress("256.1.1.1") == nil)152 #expect(IPAddress("1.2.3") == nil)153 #expect(IPAddress("example.com") == nil)154 #expect(IPAddress(bytes: [1, 2, 3]) == nil)155 #expect(IPAddress(bytes: [192, 168, 1, 20])?.description == "192.168.1.20")156 #expect(IPAddress("2001:0DB8:0000:0000:0000:0000:0000:0010")?.description == "2001:db8::10")157 #expect(IPAddress("2001:db8::10") == IPAddress("2001:DB8:0:0:0:0:0:10"))158 #expect(AddressScope.privateRFC1918.isRoutable && AddressScope.carrierGradeNAT.isRoutable && AddressScope.uniqueLocal.isRoutable && AddressScope.global.isRoutable)159 #expect(!AddressScope.linkLocal.isRoutable && !AddressScope.loopback.isRoutable && !AddressScope.multicast.isRoutable)160 }161162 @Test func prefixLengths() {163 #expect(InterfaceInspector.prefixLength(of: [255, 255, 255, 0]) == 24)164 #expect(InterfaceInspector.prefixLength(of: [255, 255, 240, 0]) == 20)165 #expect(InterfaceInspector.prefixLength(of: [255, 255, 255, 255]) == 32)166 #expect(InterfaceInspector.prefixLength(of: [0, 0, 0, 0]) == 0)167 #expect(InterfaceInspector.prefixLength(of: [255, 0, 255, 0]) == nil)168 #expect(InterfaceInspector.prefixLength(of: [255, 241, 0, 0]) == nil)169 #expect(InterfaceInspector.prefixLength(of: [UInt8](repeating: 255, count: 8) + [UInt8](repeating: 0, count: 8)) == 64)170 }171}172173@Suite("Latency statistics")174struct LatencyStatisticsTests {175 @Test func oddSampleCount() throws {176 let stats = try #require(LatencyStatistics(durations: [0.030, 0.010, 0.020, 0.050, 0.040]))177 #expect(stats.sampleCount == 5)178 #expect(stats.lossCount == 0)179 #expect(stats.minimum == 0.010)180 #expect(stats.maximum == 0.050)181 #expect(abs(stats.average - 0.030) < 1e-12)182 #expect(stats.median == 0.030)183 #expect(abs(stats.jitter - 0.0002.squareRoot()) < 1e-12)184 #expect(stats.lossFraction == 0)185 }186187 @Test func evenSampleCountWithLosses() throws {188 let stats = try #require(LatencyStatistics(durations: [0.100, nil, 0.200, 0.400, nil, 0.300]))189 #expect(stats.sampleCount == 6)190 #expect(stats.lossCount == 2)191 #expect(abs(stats.median - 0.250) < 1e-12)192 #expect(abs(stats.average - 0.250) < 1e-12)193 #expect(abs(stats.jitter - 0.0125.squareRoot()) < 1e-12)194 #expect(abs(stats.lossFraction - 1.0 / 3.0) < 1e-12)195 }196197 @Test func singleSampleAndNoSample() throws {198 let single = try #require(LatencyStatistics(durations: [0.042]))199 #expect(single.minimum == 0.042 && single.maximum == 0.042 && single.median == 0.042 && single.average == 0.042)200 #expect(single.jitter == 0)201 #expect(LatencyStatistics(durations: []) == nil)202 #expect(LatencyStatistics(durations: [nil, nil, nil]) == nil)203 let filtered = try #require(LatencyStatistics(durations: [0.010, .nan, -1, .infinity]))204 #expect(filtered.sampleCount == 4)205 #expect(filtered.lossCount == 3)206 #expect(filtered.average == 0.010)207 }208209 @Test func invalidInputIsReportedNotMeasured() async {210 let empty = await LatencyProbe.measure(host: "", samples: 2)211 #expect(empty.samples.isEmpty)212 #expect(empty.statistics.unavailability?.kind == .failed)213 let zeroPort = await LatencyProbe.measure(host: "apple.com", port: 0)214 #expect(!zeroPort.statistics.isMeasured)215 }216}217218@Suite("DNS error mapping")219struct DNSMappingTests {220 @Test func gaiCodes() {221 #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: true) == .notFound)222 #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: nil) == .notFound)223 #expect(DNSProbe.classify(gaiCode: EAI_NONAME, networkSatisfied: false) == .noNetwork)224 #expect(DNSProbe.classify(gaiCode: EAI_NODATA, networkSatisfied: true) == .notFound)225 #expect(DNSProbe.classify(gaiCode: EAI_AGAIN, networkSatisfied: true) == .temporaryFailure)226 #expect(DNSProbe.classify(gaiCode: EAI_AGAIN, networkSatisfied: false) == .noNetwork)227 #expect(DNSProbe.classify(gaiCode: EAI_FAIL, networkSatisfied: true) == .serverFailure)228 #expect(DNSProbe.classify(gaiCode: EAI_MEMORY, networkSatisfied: true) == .other)229 #expect(DNSProbe.classify(gaiCode: EAI_SYSTEM, networkSatisfied: false) == .other)230 }231232 @Test func everyKindHasAReadableReason() {233 for kind in DNSFailure.Kind.allCases {234 let failure = DNSProbe.failure(kind: kind, code: kind == .other ? EAI_MEMORY : nil)235 #expect(failure.kind == kind)236 #expect(failure.reason.count > 10)237 }238 }239240 @Test func invalidNamesAreRejectedWithoutALookup() async {241 for name in ["", " ", "two words.com", "a..b", ".leading.com", String(repeating: "a", count: 300), "tab\there.com"] {242 let result = await DNSProbe.resolve(name)243 #expect(result.failure?.kind == .invalidName, "“\(name.prefix(20))”")244 #expect(result.addresses.isEmpty)245 }246 #expect(DNSProbe.isPlausibleHostName("apple.com"))247 #expect(DNSProbe.isPlausibleHostName("bücher.example"))248 #expect(DNSProbe.isPlausibleHostName("_dmarc.example.com"))249 #expect(DNSProbe.normalized(" apple.com. ") == "apple.com")250 }251252 @Test func addressLiteralsResolveToThemselvesOffline() async {253 let v4 = await DNSProbe.resolve("127.0.0.1")254 #expect(v4.ipv4Addresses == ["127.0.0.1"])255 #expect(v4.addresses.first?.scope == .loopback)256 let v6 = await DNSProbe.resolve("::1")257 #expect(v6.ipv6Addresses == ["::1"])258 let localhost = await DNSProbe.resolve("localhost")259 #expect(localhost.succeeded)260 print("MEASURED DNS localhost: \(ORIXFormat.milliseconds(localhost.duration)), addresses \(localhost.addresses.map(\.address))")261 }262}263264@Suite("Connectivity snapshots and change log")265struct ChangeLogTests {266 let wifi = ConnectivitySnapshot(267 status: .satisfied, interfaceKinds: [.wifi], isExpensive: false, isConstrained: false, supportsIPv4: true, supportsIPv6: true, supportsDNS: true,268 availableInterfaces: [PathInterface(name: "en0", kind: .wifi, index: 4)], timestamp: Date(timeIntervalSince1970: 1000)269 )270271 @Test func firstSnapshotIsAnInitialEntry() {272 let change = NetworkChange.between(nil, wifi)273 #expect(change?.kinds == [.initial])274 #expect(change?.previous == nil)275 #expect(change?.current == wifi)276 #expect(change?.descriptions.count == 1)277 }278279 @Test func identicalSnapshotsProduceNoEntry() {280 var later = wifi281 later.timestamp = Date(timeIntervalSince1970: 2000)282 #expect(NetworkChange.between(wifi, later) == nil)283 }284285 @Test func wifiToCellularListsEveryDifference() throws {286 let cellular = ConnectivitySnapshot(287 status: .satisfied, interfaceKinds: [.cellular], isExpensive: true, isConstrained: true, supportsIPv4: true, supportsIPv6: false, supportsDNS: true,288 availableInterfaces: [PathInterface(name: "pdp_ip0", kind: .cellular, index: 3)], timestamp: Date(timeIntervalSince1970: 3000)289 )290 let change = try #require(NetworkChange.between(wifi, cellular))291 #expect(change.kinds == [.interfaceKinds, .expensive, .constrained, .ipv6, .availableInterfaces])292 #expect(change.descriptions.count == change.kinds.count)293 #expect(change.timestamp == cellular.timestamp)294 #expect(change.previous == wifi)295 }296297 @Test func goingOfflineReportsStatusAndReason() throws {298 let offline = ConnectivitySnapshot(status: .unsatisfied, unsatisfiedReason: .notAvailable, timestamp: Date(timeIntervalSince1970: 4000))299 let change = try #require(NetworkChange.between(wifi, offline))300 #expect(change.kinds.contains(.status))301 #expect(change.kinds.contains(.unsatisfiedReason))302 #expect(change.kinds.contains(.dns))303 #expect(change.kinds.contains(.ipv4))304 let back = try #require(NetworkChange.between(offline, wifi))305 #expect(back.kinds.contains(.status))306 #expect(back.kinds.contains(.unsatisfiedReason))307 }308309 @Test func theLogIsBoundedAndOrdered() {310 let monitor = ConnectivityMonitor(logCapacity: 5)311 var snapshot = wifi312 for index in 0..<20 {313 snapshot.isExpensive.toggle()314 snapshot.timestamp = Date(timeIntervalSince1970: TimeInterval(5000 + index))315 monitor.ingest(snapshot)316 }317 let log = monitor.changeLog318 #expect(log.count == 5)319 #expect(log.map(\.timestamp) == log.map(\.timestamp).sorted())320 #expect(log.last?.current == snapshot)321 #expect(log.contains { $0.kinds == [.initial] } == false)322 monitor.ingest(snapshot)323 #expect(monitor.changeLog.count == 5)324 monitor.clearChangeLog()325 #expect(monitor.changeLog.isEmpty)326 }327328 @Test func streamsDeliverIngestedSnapshots() async {329 let monitor = ConnectivityMonitor()330 monitor.ingest(wifi)331 let stream = monitor.snapshots()332 var iterator = stream.makeAsyncIterator()333 let first = await iterator.next()334 #expect(first != nil)335 var changed = wifi336 changed.isConstrained = true337 monitor.ingest(changed)338 var sawChange = first == changed339 for _ in 0..<5 where !sawChange {340 if let next = await iterator.next(), next == changed { sawChange = true }341 }342 #expect(sawChange)343 monitor.stop()344 #expect(!monitor.isActive)345 }346347 @Test func snapshotsRoundTripThroughCodable() throws {348 let data = try JSONEncoder().encode(wifi)349 let decoded = try JSONDecoder().decode(ConnectivitySnapshot.self, from: data)350 #expect(decoded == wifi)351 }352}353354@Suite("Proxy, VPN indicator and parsing helpers")355struct InterpretationTests {356 func address(_ name: String, _ text: String, up: Bool = true) -> InterfaceAddress {357 let parsed = IPAddress(text)358 let flags = InterfaceFlags(raw: up ? UInt32(IFF_UP | IFF_RUNNING) : 0)359 return InterfaceAddress(name: name, family: parsed?.family ?? .ipv4, address: text, flags: flags, scope: parsed?.scope ?? .reserved)360 }361362 @Test func proxySettingsParsing() {363 let none = InterfaceInspector.parseProxySettings(["HTTPEnable": 0, "HTTPProxy": "ignored.example", "HTTPPort": 8080])364 #expect(!none.isProxyConfigured)365 #expect(none.httpProxy == nil)366 let manual = InterfaceInspector.parseProxySettings([367 "HTTPEnable": 1, "HTTPProxy": "proxy.corp.example", "HTTPPort": 8080,368 "HTTPSEnable": 1, "HTTPSProxy": "10.0.0.5", "HTTPSPort": 3128,369 "ExceptionsList": ["*.local", "169.254/16"],370 "__SCOPED__": ["en0": ["HTTPEnable": 1], "utun4": [String: Any]()],371 ])372 #expect(manual.isProxyConfigured)373 #expect(manual.httpProxy == ProxyEndpoint(host: "proxy.corp.example", port: 8080))374 #expect(manual.httpsProxy?.display == "10.0.0.5:3128")375 #expect(manual.socksProxy == nil)376 #expect(manual.exceptions == ["*.local", "169.254/16"])377 #expect(manual.scopedInterfaces == ["en0", "utun4"])378 let pac = InterfaceInspector.parseProxySettings(["ProxyAutoConfigEnable": 1, "ProxyAutoConfigURLString": "http://wpad.example/proxy.pac", "ProxyAutoDiscoveryEnable": 1])379 #expect(pac.pacURL == "http://wpad.example/proxy.pac")380 #expect(pac.isProxyConfigured)381 #expect(pac.autoDiscoveryEnabled)382 let discoveryOnly = InterfaceInspector.parseProxySettings(["ProxyAutoDiscoveryEnable": 1])383 #expect(!discoveryOnly.isProxyConfigured)384 let hostile = InterfaceInspector.parseProxySettings(["HTTPEnable": 1, "HTTPProxy": "evil\u{0}\nhost", "HTTPPort": 99999, "SOCKSEnable": "yes", "ExceptionsList": 12])385 #expect(hostile.httpProxy == ProxyEndpoint(host: "evilhost", port: nil))386 #expect(hostile.socksProxy == nil)387 #expect(hostile.exceptions.isEmpty)388 }389390 @Test func tunnelInterfaceNames() {391 for name in ["utun0", "utun12", "ipsec0", "ppp0", "tap1", "tun3", "UTUN2"] {392 #expect(InterfaceInspector.isTunnelInterfaceName(name), "\(name)")393 }394 for name in ["en0", "pdp_ip0", "lo0", "awdl0", "bridge100", "tunnel", "utunx", "llw0", "anpi0"] {395 #expect(!InterfaceInspector.isTunnelInterfaceName(name), "\(name)")396 }397 }398399 @Test func vpnIndicatorHeuristic() {400 let systemOnly = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("utun0", "fe80::1"), address("utun1", "fe80::2")], proxy: nil)401 #expect(!systemOnly.isIndicated)402 #expect(systemOnly.systemOnlyTunnelInterfaces == ["utun0", "utun1"])403 #expect(systemOnly.confidence == .heuristic)404405 let vpn = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("utun0", "fe80::1"), address("utun3", "10.67.0.34"), address("utun3", "fe80::3")], proxy: ProxyConfiguration())406 #expect(vpn.isIndicated)407 #expect(vpn.tunnelInterfacesWithRoutableAddress == ["utun3"])408 #expect(vpn.systemOnlyTunnelInterfaces == ["utun0"])409410 let cgnat = InterfaceInspector.vpnIndicator(addresses: [address("utun5", "100.69.26.91")], proxy: nil)411 #expect(cgnat.isIndicated)412 let ula = InterfaceInspector.vpnIndicator(addresses: [address("ipsec0", "fd00::2")], proxy: nil)413 #expect(ula.isIndicated)414415 let down = InterfaceInspector.vpnIndicator(addresses: [address("utun3", "10.67.0.34", up: false)], proxy: nil)416 #expect(!down.isIndicated)417418 let scoped = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20")], proxy: ProxyConfiguration(scopedInterfaces: ["en0", "utun2", "ppp0"]))419 #expect(scoped.isIndicated)420 #expect(scoped.scopedTunnelInterfaces == ["ppp0", "utun2"])421422 let nothing = InterfaceInspector.vpnIndicator(addresses: [address("en0", "192.168.2.20"), address("pdp_ip0", "10.20.30.40")], proxy: ProxyConfiguration(scopedInterfaces: ["en0"]))423 #expect(!nothing.isIndicated)424 #expect(nothing.systemOnlyTunnelInterfaces.isEmpty)425 }426427 @Test func thisMachinesInterfacesAreReadable() throws {428 let addresses = try #require(InterfaceInspector.addresses().value)429 #expect(addresses.contains { $0.flags.isLoopback && $0.address == "127.0.0.1" && $0.scope == .loopback && $0.prefixLength == 8 })430 #expect(addresses.contains { $0.address == "::1" && $0.prefixLength == 128 })431 for entry in addresses {432 #expect(IPAddress(entry.address) != nil, "\(entry.name) \(entry.address)")433 #expect(!entry.name.isEmpty)434 }435 let proxy = InterfaceInspector.proxyConfiguration()436 #expect(proxy.isMeasured)437 let indicator = InterfaceInspector.vpnIndicator(addresses: addresses, proxy: proxy.value)438 print("MEASURED interfaces: \(addresses.count) addresses on \(Set(addresses.map(\.name)).count) interfaces; proxy configured: \(proxy.value?.isProxyConfigured ?? false); VPN indicator: \(indicator.isIndicated) \(indicator.tunnelInterfacesWithRoutableAddress)")439 }440441 @Test func hstsParsing() {442 let full = HSTSPolicy(header: "max-age=63072000; includeSubDomains; preload")443 #expect(full?.maxAge == 63_072_000)444 #expect(full?.includeSubDomains == true)445 #expect(full?.preload == true)446 #expect(full?.isEffective == true)447 let quoted = HSTSPolicy(header: " MAX-AGE=\"300\" ; INCLUDESUBDOMAINS ")448 #expect(quoted?.maxAge == 300)449 #expect(quoted?.includeSubDomains == true)450 #expect(quoted?.preload == false)451 let zero = HSTSPolicy(header: "max-age=0")452 #expect(zero?.isEffective == false)453 let broken = HSTSPolicy(header: "includeSubDomains; max-age=abc")454 #expect(broken?.maxAge == nil)455 #expect(broken?.isEffective == false)456 #expect(HSTSPolicy(header: "max-age=-5")?.maxAge == nil)457 #expect(HSTSPolicy(header: " ") == nil)458 }459460 @Test func tlsEndpointParsing() {461 #expect(TLSEndpoint(parsing: "apple.com") == TLSEndpoint(host: "apple.com", port: 443))462 #expect(TLSEndpoint(parsing: " apple.com:8443 ") == TLSEndpoint(host: "apple.com", port: 8443))463 #expect(TLSEndpoint(parsing: "apple.com.") == TLSEndpoint(host: "apple.com", port: 443))464 #expect(TLSEndpoint(parsing: "https://www.apple.com/iphone?x=1") == TLSEndpoint(host: "www.apple.com", port: 443))465 #expect(TLSEndpoint(parsing: "https://example.com:9443/") == TLSEndpoint(host: "example.com", port: 9443))466 #expect(TLSEndpoint(parsing: "192.0.2.10:993") == TLSEndpoint(host: "192.0.2.10", port: 993))467 #expect(TLSEndpoint(parsing: "[2001:db8::10]:8443") == TLSEndpoint(host: "2001:db8::10", port: 8443))468 #expect(TLSEndpoint(parsing: "[2001:db8::10]") == TLSEndpoint(host: "2001:db8::10", port: 443))469 #expect(TLSEndpoint(parsing: "2001:db8::10") == TLSEndpoint(host: "2001:db8::10", port: 443))470 #expect(TLSEndpoint(parsing: "2001:db8::10")?.display == "[2001:db8::10]:443")471 #expect(TLSEndpoint(parsing: "2001:db8::10")?.isIPAddress == true)472 for invalid in ["", " ", "apple.com:0", "apple.com:99999", "apple.com:abc", "[2001:db8::10", "[::1]x", "two words", "host/path", "https://"] {473 #expect(TLSEndpoint(parsing: invalid) == nil, "“\(invalid)”")474 }475 }476477 @Test func tlsVersionAndCipherNames() {478 #expect(TLSProtocolVersion(code: 0x0301) == .tls10)479 #expect(TLSProtocolVersion(code: 0x0302) == .tls11)480 #expect(TLSProtocolVersion(code: 0x0303) == .tls12)481 #expect(TLSProtocolVersion(code: 0x0304) == .tls13)482 #expect(TLSProtocolVersion(code: 0x0300) == .unknown)483 #expect(TLSProtocolVersion.tls10.isDeprecated && TLSProtocolVersion.tls11.isDeprecated)484 #expect(!TLSProtocolVersion.tls12.isDeprecated && !TLSProtocolVersion.tls13.isDeprecated)485 #expect(TLSCipherSuite(code: 0x1301).name == "TLS_AES_128_GCM_SHA256")486 #expect(TLSCipherSuite(code: 0xc02f).name == "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256")487 #expect(TLSCipherSuite(code: 0xabcd).name == "0xabcd")488 }489490 @Test func bonjourHelpers() {491 #expect(LocalNetworkBrowser.defaultServiceTypes.count == 14)492 #expect(Set(LocalNetworkBrowser.defaultServiceTypes).count == 14)493 for type in LocalNetworkBrowser.defaultServiceTypes {494 #expect(LocalNetworkBrowser.isValidServiceType(type), "\(type)")495 #expect(LocalNetworkBrowser.label(forServiceType: type) != type)496 }497 for invalid in ["", "http", "_http", "_http._tcp.", "_http._sctp", "http._tcp", "_._tcp", "_averyveryverylongname._tcp", "_ht tp._tcp", "_http._tcp.local"] {498 #expect(!LocalNetworkBrowser.isValidServiceType(invalid), "“\(invalid)”")499 }500 let denied = LocalNetworkBrowser.unavailability(for: NWError.dns(-65570))501 #expect(denied.kind == .permissionRequired)502 let other = LocalNetworkBrowser.unavailability(for: NWError.dns(-65563))503 #expect(other.kind == .failed)504 let posix = LocalNetworkBrowser.unavailability(for: NWError.posix(.ENETDOWN))505 #expect(posix.kind == .failed)506 }507508 @Test func browsingWithNoValidTypeIsUnavailable() async {509 let result = await LocalNetworkBrowser.summary(serviceTypes: ["nonsense", "_bad._sctp"], duration: .seconds(1))510 #expect(result.unavailability?.kind == .failed)511 }512}513