bdrck 0.22.5

// Copyright 2015 Axel Rasmussen
//
// Licensed 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.

use crate::net::*;
use std::net::IpAddr;

macro_rules! ip {
    ($e:expr_2021) => {
        $e.parse::<IpAddr>().unwrap()
    };
}

macro_rules! mac {
    ($e:expr_2021) => {
        $e.parse::<HardwareAddr>().unwrap()
    };
}

macro_rules! net {
    ($e:expr_2021) => {
        $e.parse::<IpNet>().unwrap()
    };
}

#[test]
fn test_increment_ip() {
    crate::init().unwrap();

    assert_eq!(Some(ip!("10.0.0.1")), increment_ip(ip!("10.0.0.0")));
    assert_eq!(Some(ip!("10.10.10.11")), increment_ip(ip!("10.10.10.10")));
    assert_eq!(Some(ip!("10.0.1.0")), increment_ip(ip!("10.0.0.255")));
    assert_eq!(None, increment_ip(ip!("255.255.255.255")));
}

#[test]
fn test_min_max_ip() {
    crate::init().unwrap();

    assert_eq!(
        Some(ip!("10.0.0.1")),
        min_ip(ip!("10.0.0.2"), ip!("10.0.0.1"))
    );
    assert_eq!(
        Some(ip!("10.0.0.2")),
        max_ip(ip!("10.0.0.2"), ip!("10.0.0.1"))
    );
    assert_eq!(None, min_ip(ip!("10.0.0.1"), ip!("::1")));
    assert_eq!(None, max_ip(ip!("10.0.0.1"), ip!("::1")));
}

#[test]
fn test_hardware_addr_string_round_trip() {
    crate::init().unwrap();

    assert_eq!("0c:c4:7a:7f:b6:32", mac!("0c:c4:7a:7f:b6:32").to_string());
    assert_eq!("0c:c4:7a:7f:b6:32", mac!("0c-c4-7a-7f-b6-32").to_string());
    assert_eq!("0c:c4:7a:7f:b6:32", mac!("0cc4.7a7f.b632").to_string());
}

#[test]
fn test_hardware_addr_parse_error() {
    crate::init().unwrap();

    assert!("00:00:00:00:00:00:00".parse::<HardwareAddr>().is_err());
    assert!("00:00:00:00:00".parse::<HardwareAddr>().is_err());
    assert!("00_00_00_00_00_00".parse::<HardwareAddr>().is_err());
    assert!("xx:xx:xx:xx:xx:xx".parse::<HardwareAddr>().is_err());
}

#[test]
fn test_hardware_addr_string_bit_order() {
    crate::init().unwrap();

    let parsed = mac!("12-34-56-78-9A-BC");
    assert_eq!(
        &[0x12_u8, 0x34_u8, 0x56_u8, 0x78_u8, 0x9a_u8, 0xbc_u8],
        parsed.as_bytes()
    );
    assert_eq!("12:34:56:78:9a:bc", parsed.to_string());
}

#[test]
fn test_ip_net_string_round_trip() {
    crate::init().unwrap();

    assert_eq!("10.0.0.0/24", net!("10.0.0.0/24").to_string());
    assert_eq!("10.0.0.0/14", net!("10.0.0.0/14").to_string());
    assert_eq!("10.0.0.0/14", net!("10.0.0.0/fffc0000").to_string());
}

#[test]
fn test_ip_net_bit_order() {
    crate::init().unwrap();

    assert_eq!(
        [
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0x00,
        ],
        net!("10.0.0.0/24").get_mask()
    );
    assert_eq!(
        [
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc,
            0x00, 0x00,
        ],
        net!("10.0.0.0/14").get_mask()
    );
    assert_eq!(
        [
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x37,
            0x50, 0x4e,
        ],
        net!("10.0.0.0/0a37504e").get_mask()
    );
    assert_eq!(
        [
            0x4e, 0xd6, 0x2c, 0x4b, 0x1f, 0xb2, 0xbb, 0x41, 0x80, 0x80, 0x1d, 0xe9, 0xcf, 0x77,
            0xd1, 0x6e,
        ],
        net!("::1/4ed62c4b1fb2bb4180801de9cf77d16e").get_mask()
    );
}

#[test]
fn test_ip_net_netmask() {
    crate::init().unwrap();

    assert_eq!(ip!("255.255.0.0"), net!("10.10.0.0/16").netmask());
    assert_eq!(ip!("255.255.255.0"), net!("10.10.0.0/24").netmask());
    assert_eq!(ip!("255.255.240.0"), net!("10.10.0.0/20").netmask());
}

#[test]
fn test_ip_net_broadcast() {
    crate::init().unwrap();

    assert_eq!(ip!("10.10.255.255"), net!("10.10.0.0/16").broadcast());
    assert_eq!(ip!("10.10.10.255"), net!("10.10.10.0/24").broadcast());
    assert_eq!(ip!("172.31.255.255"), net!("172.16.0.0/12").broadcast());
}

#[test]
fn test_ip_net_contains() {
    crate::init().unwrap();

    assert_eq!(
        true,
        net!("10.10.10.0/24").contains(ip!("10.10.10.123"), false)
    );
    assert_eq!(
        false,
        net!("10.10.10.0/24").contains(ip!("10.10.0.123"), false)
    );
    assert_eq!(
        true,
        net!("10.10.10.0/24").contains(ip!("10.10.10.0"), false)
    );
    assert_eq!(
        false,
        net!("10.10.10.0/24").contains(ip!("10.10.10.0"), true)
    );
    assert_eq!(
        true,
        net!("10.10.10.0/24").contains(ip!("10.10.10.255"), false)
    );
    assert_eq!(
        false,
        net!("10.10.10.0/24").contains(ip!("10.10.10.255"), true)
    );
}

#[test]
fn test_ip_net_first_address() {
    crate::init().unwrap();

    assert_eq!(Some(ip!("10.10.10.1")), net!("10.10.10.0/24").first());
    assert_eq!(Some(ip!("10.10.0.1")), net!("10.10.0.0/16").first());
}

#[test]
fn test_ip_net_last_address() {
    crate::init().unwrap();

    assert_eq!(ip!("10.10.10.254"), net!("10.10.10.0/24").last());
    assert_eq!(ip!("10.10.255.254"), net!("10.10.0.0/16").last());
}

#[test]
fn test_ip_net_first_single_host() {
    crate::init().unwrap();

    // /32 IPv4: the only address in the network is self.ip.
    assert_eq!(Some(ip!("10.0.0.5")), net!("10.0.0.5/32").first());
    assert_eq!(Some(ip!("192.168.1.0")), net!("192.168.1.0/32").first());

    // /128 IPv6: the only address in the network is self.ip.
    assert_eq!(Some(ip!("2001:db8::1")), net!("2001:db8::1/128").first());
    assert_eq!(Some(ip!("::")), net!("::/128").first());
}

#[test]
fn test_ip_net_first_point_to_point() {
    crate::init().unwrap();

    // /31 IPv4: per RFC 3021 both addresses are usable; first() returns self.ip.
    assert_eq!(Some(ip!("10.0.0.0")), net!("10.0.0.0/31").first());

    // /127 IPv6: per RFC 6164 both addresses are usable; first() returns self.ip.
    assert_eq!(Some(ip!("2001:db8::")), net!("2001:db8::/127").first());
}

#[test]
fn test_ip_net_last_single_host() {
    crate::init().unwrap();

    // /32 IPv4: broadcast is self.ip itself; subtracting from a zero last byte
    // would have previously underflowed. We should simply return self.ip.
    assert_eq!(ip!("10.0.0.0"), net!("10.0.0.0/32").last());
    assert_eq!(ip!("192.168.1.0"), net!("192.168.1.0/32").last());

    // /128 IPv6: same shape, different family.
    assert_eq!(ip!("2001:db8::"), net!("2001:db8::/128").last());
    assert_eq!(ip!("::"), net!("::/128").last());
}

#[test]
fn test_increment_ip_v6() {
    crate::init().unwrap();

    // Basic increment.
    assert_eq!(Some(ip!("::1")), increment_ip(ip!("::")));
    // Carry across the low group boundary.
    assert_eq!(Some(ip!("::1:0")), increment_ip(ip!("::ffff")));
    // Carry across multiple group boundaries.
    assert_eq!(
        Some(ip!("::1:0:0:0")),
        increment_ip(ip!("::ffff:ffff:ffff"))
    );
    // Full overflow.
    assert_eq!(
        None,
        increment_ip(ip!("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))
    );
}

#[test]
fn test_ip_net_netmask_v6() {
    crate::init().unwrap();

    assert_eq!(ip!("ffff:ffff::"), net!("2001:db8::/32").netmask());
    assert_eq!(
        ip!("ffff:ffff:ffff:ffff::"),
        net!("2001:db8::/64").netmask()
    );
    assert_eq!(
        ip!("ffff:ffff:ffff:ffff:ffff:ffff::"),
        net!("2001:db8::/96").netmask()
    );
    assert_eq!(
        ip!("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
        net!("2001:db8::1/128").netmask()
    );
}

#[test]
fn test_ip_net_broadcast_v6() {
    crate::init().unwrap();

    assert_eq!(
        ip!("2001:db8:ffff:ffff:ffff:ffff:ffff:ffff"),
        net!("2001:db8::/32").broadcast()
    );
    assert_eq!(
        ip!("2001:db8::ffff:ffff:ffff:ffff"),
        net!("2001:db8::/64").broadcast()
    );
}

#[test]
fn test_ip_net_last_address_v6() {
    crate::init().unwrap();

    assert_eq!(
        ip!("2001:db8::ffff:ffff:ffff:fffe"),
        net!("2001:db8::/64").last()
    );
}

#[test]
fn test_ip_net_contains_v6() {
    crate::init().unwrap();

    let n = net!("2001:db8::/32");
    assert!(n.contains(ip!("2001:db8:1::"), false));
    assert!(n.contains(ip!("2001:db8::1"), false));
    assert!(!n.contains(ip!("2001:db7::"), false));
    // The broadcast IP is not "within" when strict.
    assert!(!n.contains(ip!("2001:db8:ffff:ffff:ffff:ffff:ffff:ffff"), true));
    // The network IP is not "within" when strict.
    assert!(!n.contains(ip!("2001:db8::"), true));
    // A middle host IP is within when strict.
    assert!(n.contains(ip!("2001:db8::1"), true));
}

#[test]
fn test_ip_net_increment_in() {
    crate::init().unwrap();

    let n = net!("10.0.0.0/24");
    // Inside the network.
    assert_eq!(
        Some(ip!("10.0.0.2")),
        n.increment_in(ip!("10.0.0.1"), false)
    );
    // Inside when not strict, even at the broadcast address.
    assert_eq!(
        Some(ip!("10.0.0.255")),
        n.increment_in(ip!("10.0.0.254"), false)
    );
    // Crosses the network boundary.
    assert_eq!(None, n.increment_in(ip!("10.0.0.255"), false));
    // Strict mode: incrementing to broadcast returns None.
    assert_eq!(None, n.increment_in(ip!("10.0.0.254"), true));
    // Strict mode inside still works.
    assert_eq!(Some(ip!("10.0.0.2")), n.increment_in(ip!("10.0.0.1"), true));
    // v6 path.
    let n6 = net!("2001:db8::/64");
    assert_eq!(
        Some(ip!("2001:db8::2")),
        n6.increment_in(ip!("2001:db8::1"), false)
    );
    // increment_ip returning None (overflow) bubbles up.
    assert_eq!(None, n.increment_in(ip!("255.255.255.255"), false));
}

#[test]
fn test_ip_net_from_str_out_of_range() {
    crate::init().unwrap();

    // IPv4 prefix too large.
    assert!("10.0.0.0/33".parse::<IpNet>().is_err());
    assert!("10.0.0.0/200".parse::<IpNet>().is_err());
    // IPv6 prefix too large.
    assert!("::/129".parse::<IpNet>().is_err());
    // Non-numeric masks that aren't the hex length are parse errors.
    assert!("10.0.0.0/abc".parse::<IpNet>().is_err());
}

#[test]
fn test_ip_net_from_str_missing_slash() {
    crate::init().unwrap();

    assert!("10.0.0.0".parse::<IpNet>().is_err());
    assert!("".parse::<IpNet>().is_err());
}

#[test]
fn test_ip_net_from_str_bad_ip() {
    crate::init().unwrap();

    // A malformed IP component yields a parse error.
    assert!("not-an-ip/24".parse::<IpNet>().is_err());
}

#[test]
fn test_hardware_addr_serde_round_trip() {
    crate::init().unwrap();

    let addr = mac!("12:34:56:78:9a:bc");
    let s = serde_json::to_string(&addr).unwrap();
    assert_eq!("\"12:34:56:78:9a:bc\"", s);
    let back: HardwareAddr = serde_json::from_str(&s).unwrap();
    assert_eq!(addr, back);

    // Invalid string deserialization surfaces as an error.
    assert!(serde_json::from_str::<HardwareAddr>("\"nope\"").is_err());
}

#[test]
fn test_ip_net_serde_round_trip() {
    crate::init().unwrap();

    let n = net!("10.0.0.0/24");
    let s = serde_json::to_string(&n).unwrap();
    assert_eq!("\"10.0.0.0/24\"", s);
    let back: IpNet = serde_json::from_str(&s).unwrap();
    assert_eq!(n, back);

    // IPv6 path too.
    let n6 = net!("2001:db8::/32");
    let s6 = serde_json::to_string(&n6).unwrap();
    let back6: IpNet = serde_json::from_str(&s6).unwrap();
    assert_eq!(n6, back6);

    // Malformed input surfaces as a deserialize error.
    assert!(serde_json::from_str::<IpNet>("\"not-a-net\"").is_err());
}