#[cfg(test)]
use std::{cell::LazyCell, sync::LazyLock};
use std::collections::{BTreeSet, HashSet};

use dec_from_char::DecimalExtended;
#[cfg(test)]
use env_logger::Logger;
use log::trace;
use protobuf::{Message, MessageField};

use crate::{
    enums::{PhoneNumberFormat, PhoneNumberType, ValidNumberLenType},
    errors::{ParseError, ValidationResultErr},
    phonemetadata::{NumberFormat, PhoneMetadata, PhoneMetadataCollection, PhoneNumberDesc},
    phonenumber::{phone_number::CountryCodeSource, PhoneNumber},
    PhoneNumberUtil,
};

use super::region_code::RegionCode;
use crate::phonenumberutil::generated::test_metadata::TEST_METADATA;

fn get_phone_util() -> PhoneNumberUtil {
    let metadata = PhoneMetadataCollection::parse_from_bytes(&TEST_METADATA)
        .expect("Metadata should be valid");
    return PhoneNumberUtil::new_for_metadata(metadata);
}

#[test]
fn interchange_invalid_codepoints() {
    colog::default_builder()
        .filter_level(log::LevelFilter::Trace)
        .init();

    let phone_util = get_phone_util();

    let valid_inputs = vec![
        "+44\u{2013}2087654321", // U+2013, EN DASH
    ];
    for input in valid_inputs {
        assert_eq!(input, dec_from_char::normalize_decimals(input));
        assert!(phone_util.is_viable_phone_number(input));
        phone_util.parse(input, "GB").unwrap();
    }

    let invalid_inputs = vec![
        "+44\u{96}2087654321",     // Invalid sequence
        "+44\u{0096}2087654321", // U+0096
        "+44\u{fffe}2087654321", // U+FFFE
    ];
    for input in invalid_inputs {
        assert!(!phone_util.is_viable_phone_number(input));
        assert!(
            phone_util.parse(input, RegionCode::gb()).is_err_and(| err | matches!(err, ParseError::NotANumber(_)))
        );
    }
}

#[test]
fn get_supported_regions() {
    let phone_util = get_phone_util();
    assert!(phone_util
        .get_supported_regions()
        .count() > 0
    )
}

#[test]
fn get_supported_global_network_calling_codes() {
    let phone_util = get_phone_util();
    let calling_codes = phone_util
        .get_supported_global_network_calling_codes()
        .collect::<Vec<_>>();
    assert!(!calling_codes.is_empty());
    for &code in &calling_codes {
        assert!(code > 0);
        let region_code = phone_util.get_region_code_for_country_code(code);
        assert_eq!(RegionCode::un001(), region_code);
    }
}

#[test]
fn get_supported_calling_codes() {
    let phone_util = get_phone_util();
    let calling_codes = phone_util
        .get_supported_calling_codes()
        .collect::<Vec<_>>();
    assert!(!calling_codes.is_empty());
    for &code in &calling_codes {
        assert!(code > 0);
        let region_code = phone_util.get_region_code_for_country_code(code);
        assert_ne!(RegionCode::zz(), region_code);
    }
    let supported_global_network_calling_codes = phone_util
        .get_supported_global_network_calling_codes()
        .collect::<Vec<_>>();
    assert!(calling_codes.len() > supported_global_network_calling_codes.len());
    assert!(calling_codes.contains(&979));
}

#[test]
fn get_supported_types_for_region() {
    let phone_util = get_phone_util();
    let types = phone_util
        .get_supported_types_for_region(RegionCode::br())
        .expect("region should exist");
    assert!(types.contains(&PhoneNumberType::FixedLine));
    assert!(!types.contains(&PhoneNumberType::Mobile));
    assert!(!types.contains(&PhoneNumberType::Unknown));

    let types = phone_util
        .get_supported_types_for_region(RegionCode::us())
        .expect("region should exist");
    assert!(types.contains(&PhoneNumberType::FixedLine));
    assert!(types.contains(&PhoneNumberType::Mobile));
    assert!(!types.contains(&PhoneNumberType::FixedLineOrMobile));
    
    assert!(
        phone_util
        .get_supported_types_for_region(RegionCode::zz())
        .is_none()
    );
}

#[test]
fn get_supported_types_for_non_geo_entity() {
    let phone_util = get_phone_util();
    let types = phone_util.get_supported_types_for_non_geo_entity(999);
    assert!(types.is_none());

    let types = phone_util
        .get_supported_types_for_non_geo_entity(979)
        .expect("Code should exist");
    assert!(types.contains(&PhoneNumberType::PremiumRate));
    assert!(!types.contains(&PhoneNumberType::Mobile));
    assert!(!types.contains(&PhoneNumberType::Unknown));
}

#[test]
fn get_region_codes_for_country_calling_code() {
    let phone_util = get_phone_util();
    let expect_regions = |code| {
        phone_util
            .get_region_codes_for_country_calling_code(code)
            .expect("Codes should exist")
            .collect::<Vec<_>>()
    };

    let regions = expect_regions(1);
    assert!(regions.contains(&RegionCode::us()));
    assert!(regions.contains(&RegionCode::bs()));

    let regions = expect_regions(44);
    assert!(regions.contains(&RegionCode::gb()));

    let regions = expect_regions(49);
    assert!(regions.contains(&RegionCode::de()));

    let regions = expect_regions(800);
    assert!(regions.contains(&RegionCode::un001()));

    const INVALID_COUNTRY_CODE: i32 = 2;
    assert!(
        phone_util
            .get_region_codes_for_country_calling_code(INVALID_COUNTRY_CODE)
            .is_none()
    );
}

#[test]
fn get_instance_load_us_metadata() {
    let phone_util = get_phone_util();
    let metadata = phone_util.get_metadata_for_region(RegionCode::us()).unwrap();
    assert_eq!("US", metadata.id());
    assert_eq!(1, metadata.country_code());
    assert_eq!("011", metadata.international_prefix());
    assert!(metadata.has_national_prefix());
    assert_eq!(2, metadata.number_format.len());
    assert_eq!("(\\d{3})(\\d{3})(\\d{4})", metadata.number_format[1].pattern());
    assert_eq!("$1 $2 $3", metadata.number_format[1].format());
    assert_eq!("[13-689]\\d{9}|2[0-35-9]\\d{8}", metadata.general_desc.national_number_pattern());
    assert_eq!("[13-689]\\d{9}|2[0-35-9]\\d{8}", metadata.fixed_line.national_number_pattern());
    assert_eq!(1, metadata.general_desc.possible_length.len());
    assert_eq!(10, metadata.general_desc.possible_length[0]);
    assert_eq!(0, metadata.toll_free.possible_length.len());
    assert_eq!("900\\d{7}", metadata.premium_rate.national_number_pattern());
    assert!(!metadata.shared_cost.has_national_number_pattern());
}

#[test]
fn get_instance_load_de_metadata() {
    let phone_util = get_phone_util();
    let metadata = phone_util.get_metadata_for_region(RegionCode::de()).unwrap();
    assert_eq!("DE", metadata.id());
    assert_eq!(49, metadata.country_code());
    assert_eq!("00", metadata.international_prefix());
    assert_eq!("0", metadata.national_prefix());
    assert_eq!(6, metadata.number_format.len());
    assert_eq!(1, metadata.number_format[5].leading_digits_pattern.len());
    assert_eq!("900", metadata.number_format[5].leading_digits_pattern[0]);
    assert_eq!("(\\d{3})(\\d{3,4})(\\d{4})", metadata.number_format[5].pattern());
    assert_eq!(2, metadata.general_desc.possible_length_local_only.len());
    assert_eq!(8, metadata.general_desc.possible_length.len());
    assert_eq!(0, metadata.fixed_line.possible_length.len());
    assert_eq!(2, metadata.mobile.possible_length.len());
    assert_eq!("$1 $2 $3", metadata.number_format[5].format());
    assert_eq!("(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:0[2-9]|[1-9]\\d))\\d{1,8}", metadata.fixed_line.national_number_pattern());
    assert_eq!("30123456", metadata.fixed_line.example_number());
    assert_eq!(10, metadata.toll_free.possible_length[0]);
    assert_eq!("900([135]\\d{6}|9\\d{7})", metadata.premium_rate.national_number_pattern());
}

#[test]
fn get_instance_load_ar_metadata() {
    let phone_util = get_phone_util();
    let metadata = phone_util.get_metadata_for_region(RegionCode::ar()).unwrap();
    assert_eq!("AR", metadata.id());
    assert_eq!(54, metadata.country_code());
    assert_eq!("00", metadata.international_prefix());
    assert_eq!("0", metadata.national_prefix());
    assert_eq!("0(?:(11|343|3715)15)?", metadata.national_prefix_for_parsing());
    assert_eq!("9$1", metadata.national_prefix_transform_rule());
    assert_eq!(5, metadata.number_format.len());
    assert_eq!("$2 15 $3-$4", metadata.number_format[2].format());
    assert_eq!("(\\d)(\\d{4})(\\d{2})(\\d{4})", metadata.number_format[3].pattern());
    assert_eq!("(\\d)(\\d{4})(\\d{2})(\\d{4})", metadata.intl_number_format[3].pattern());
    assert_eq!("$1 $2 $3 $4", metadata.intl_number_format[3].format());
}


#[test]
fn get_national_significant_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    number.set_country_code(1);
    number.set_national_number(6502530000);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("6502530000", national_significant_number);

    number.clear();
    number.set_country_code(39);
    number.set_national_number(312345678);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("312345678", national_significant_number);

    number.clear();
    number.set_country_code(39);
    number.set_national_number(236618300);
    number.set_italian_leading_zero(true);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("0236618300", national_significant_number);

    number.clear();
    number.set_country_code(800);
    number.set_national_number(12345678);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("12345678", national_significant_number);
}

#[test]
fn get_national_significant_number_many_leading_zeros() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    number.set_country_code(1);
    number.set_national_number(650);
    number.set_italian_leading_zero(true);
    number.set_number_of_leading_zeros(2);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("00650", national_significant_number);

    number.set_number_of_leading_zeros(-3);
    let national_significant_number = phone_util.get_national_significant_number(&number);
    assert_eq!("650", national_significant_number);
}

#[test]
fn get_example_number() {
    let phone_util = get_phone_util();
    let mut de_number = PhoneNumber::new();
    de_number.set_country_code(49);
    de_number.set_national_number(30123456);
    let test_number = phone_util.get_example_number(RegionCode::de()).unwrap();
    assert_eq!(de_number, test_number);

    let test_number = phone_util.get_example_number_for_type_and_region_code(RegionCode::de(), PhoneNumberType::FixedLine).unwrap();
    assert_eq!(de_number, test_number);
    
    let test_number = phone_util.get_example_number_for_type_and_region_code(RegionCode::de(), PhoneNumberType::FixedLineOrMobile).unwrap();
    assert_eq!(de_number, test_number);

    phone_util.get_example_number_for_type_and_region_code(RegionCode::de(), PhoneNumberType::Mobile).unwrap();
    
    let test_number = phone_util.get_example_number_for_type_and_region_code(RegionCode::us(), PhoneNumberType::VoiceMail);
    assert!(test_number.is_err());

    let test_number = phone_util
        .get_example_number_for_type_and_region_code(RegionCode::us(), PhoneNumberType::FixedLine);
    assert!(test_number.is_ok());
    assert_ne!(&PhoneNumber::new(), test_number.as_ref().unwrap());
    
    let test_number = phone_util
        .get_example_number_for_type_and_region_code(RegionCode::us(), PhoneNumberType::Mobile);
    assert!(test_number.is_ok());
    assert_ne!(&PhoneNumber::new(), test_number.as_ref().unwrap());

    assert!(phone_util.get_example_number_for_type_and_region_code(RegionCode::cs(), PhoneNumberType::Mobile).is_err());

    assert!(phone_util.get_example_number(RegionCode::un001()).is_err());
}

#[test]
fn get_invalid_example_number() {
    let phone_util = get_phone_util();
    assert!(phone_util.get_invalid_example_number(RegionCode::un001()).is_err());
    assert!(phone_util.get_invalid_example_number(RegionCode::cs()).is_err());
    
    let test_number = phone_util.get_invalid_example_number(RegionCode::us()).unwrap();
    assert_eq!(1, test_number.country_code());
    assert!(test_number.national_number() != 0);
}

#[test]
fn get_example_number_for_non_geo_entity() {
    let phone_util = get_phone_util();
    
    let mut toll_free_number = PhoneNumber::new();
    toll_free_number.set_country_code(800);
    toll_free_number.set_national_number(12345678);
    let test_number = phone_util.get_example_number_for_non_geo_entity(800).unwrap();
    assert_eq!(toll_free_number, test_number);
    
    let mut universal_premium_rate = PhoneNumber::new();
    universal_premium_rate.set_country_code(979);
    universal_premium_rate.set_national_number(123456789);
    let test_number = phone_util.get_example_number_for_non_geo_entity(979).unwrap();
    assert_eq!(universal_premium_rate, test_number);
}

#[test]
fn format_us_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(1);
    test_number.set_national_number(6502530000);
    assert_eq!("650 253 0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 650 253 0000", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(8002530000);
    assert_eq!("800 253 0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 800 253 0000", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(9002530000);
    assert_eq!("900 253 0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 900 253 0000", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("tel:+1-900-253-0000", phone_util.format(&test_number, PhoneNumberFormat::RFC3966).unwrap());

    test_number.set_national_number(0);
    assert_eq!("0", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());

    test_number.set_raw_input("000-000-0000".to_owned());
    assert_eq!("000-000-0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
}

#[test]
fn format_bs_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(1);
    test_number.set_national_number(2421234567);
    assert_eq!("242 123 4567", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 242 123 4567", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(8002530000);
    assert_eq!("800 253 0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 800 253 0000", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(9002530000);
    assert_eq!("900 253 0000", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+1 900 253 0000", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
}

#[test]
fn format_gb_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(44);
    test_number.set_national_number(2087389353);
    assert_eq!("(020) 8738 9353", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+44 20 8738 9353", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    
    test_number.set_national_number(7912345678);
    assert_eq!("(07912) 345 678", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+44 7912 345 678", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
}

#[test]
fn format_de_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(49);

    test_number.set_national_number(301234);
    assert_eq!("030/1234", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 30/1234", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("tel:+49-30-1234", phone_util.format(&test_number, PhoneNumberFormat::RFC3966).unwrap());

    test_number.set_national_number(291123);
    assert_eq!("0291 123", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 291 123", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(29112345678);
    assert_eq!("0291 12345678", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 291 12345678", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(9123123);
    assert_eq!("09123 123", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 9123 123", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(80212345);
    assert_eq!("08021 2345", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 8021 2345", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());

    test_number.set_national_number(1234);
    assert_eq!("1234", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+49 1234", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
}

#[test]
fn format_it_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(39);
    
    test_number.set_national_number(236618300);
    test_number.set_italian_leading_zero(true);
    assert_eq!("02 3661 8300", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+39 02 3661 8300", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+390236618300", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());

    test_number.set_national_number(345678901);
    test_number.set_italian_leading_zero(false);
    assert_eq!("345 678 901", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+39 345 678 901", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+39345678901", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
}

#[test]
fn format_au_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(61);
    
    test_number.set_national_number(236618300);
    assert_eq!("02 3661 8300", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+61 2 3661 8300", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+61236618300", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
    
    test_number.set_national_number(1800123456);
    assert_eq!("1800 123 456", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+61 1800 123 456", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+611800123456", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
}

#[test]
fn format_ar_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(54);
    
    test_number.set_national_number(1187654321);
    assert_eq!("011 8765-4321", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+54 11 8765-4321", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+541187654321", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
    
    test_number.set_national_number(91187654321);
    assert_eq!("011 15 8765-4321", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+54 9 11 8765 4321", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+5491187654321", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
}

#[test]
fn format_mx_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(52);
    
    test_number.set_national_number(12345678900);
    assert_eq!("045 234 567 8900", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+52 1 234 567 8900", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+5212345678900", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
    
    test_number.set_national_number(15512345678);
    assert_eq!("045 55 1234 5678", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+52 1 55 1234 5678", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+5215512345678", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());

    test_number.set_national_number(3312345678);
    assert_eq!("01 33 1234 5678", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+52 33 1234 5678", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+523312345678", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());

    test_number.set_national_number(8211234567);
    assert_eq!("01 821 123 4567", phone_util.format(&test_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("+52 821 123 4567", phone_util.format(&test_number, PhoneNumberFormat::International).unwrap());
    assert_eq!("+528211234567", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
}

#[test]
fn format_out_of_country_calling_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();

    test_number.set_country_code(1);
    test_number.set_national_number(9002530000);
    assert_eq!("00 1 900 253 0000", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::de()).unwrap());

    test_number.set_national_number(6502530000);
    assert_eq!("1 650 253 0000", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::bs()).unwrap());
    assert_eq!("00 1 650 253 0000", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::pl()).unwrap());

    test_number.set_country_code(44);
    test_number.set_national_number(7912345678);
    assert_eq!("011 44 7912 345 678", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::us()).unwrap());

    test_number.set_country_code(49);
    test_number.set_national_number(1234);
    assert_eq!("00 49 1234", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::gb()).unwrap());
    assert_eq!("1234", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::de()).unwrap());

    test_number.set_country_code(39);
    test_number.set_national_number(236618300);
    test_number.set_italian_leading_zero(true);
    assert_eq!("011 39 02 3661 8300", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::us()).unwrap());
    assert_eq!("02 3661 8300", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::it()).unwrap());
    assert_eq!("+39 02 3661 8300", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::sg()).unwrap());

    test_number.set_country_code(65);
    test_number.set_national_number(94777892);
    test_number.set_italian_leading_zero(false);
    assert_eq!("9477 7892", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::sg()).unwrap());

    test_number.set_country_code(800);
    test_number.set_national_number(12345678);
    assert_eq!("011 800 1234 5678", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::us()).unwrap());

    test_number.set_country_code(54);
    test_number.set_national_number(91187654321);
    assert_eq!("011 54 9 11 8765 4321", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::us()).unwrap());

    test_number.set_extension("1234".to_owned());
    assert_eq!("011 54 9 11 8765 4321 ext. 1234", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::us()).unwrap());
    assert_eq!("0011 54 9 11 8765 4321 ext. 1234", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::au()).unwrap());
    assert_eq!("011 15 8765-4321 ext. 1234", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::ar()).unwrap());
}

#[test]
fn format_out_of_country_keeping_alpha_chars() {
    let phone_util = get_phone_util();
    let mut alpha_numeric_number = phone_util.parse_and_keep_raw_input("1800 six-flag", RegionCode::us()).unwrap();
    
    let formatted_number = phone_util.format_out_of_country_keeping_alpha_chars(&alpha_numeric_number, RegionCode::au()).unwrap();
    assert_eq!("0011 1 800 SIX-FLAG", formatted_number);

    // Formatting from within the NANPA region.
    let formatted_number = phone_util.format_out_of_country_keeping_alpha_chars(&alpha_numeric_number, RegionCode::us()).unwrap();
    assert_eq!("1 800 SIX-FLAG", formatted_number);

    // Testing a number with extension.
    let alpha_numeric_number_with_extn = phone_util.parse_and_keep_raw_input("800 SIX-flag ext. 1234", RegionCode::us()).unwrap();
    let formatted_number = phone_util.format_out_of_country_keeping_alpha_chars(&alpha_numeric_number_with_extn, RegionCode::au()).unwrap();
    assert_eq!("0011 1 800 SIX-FLAG extn. 1234", formatted_number);

    // Testing that if the raw input doesn't exist, it is formatted using FormatOutOfCountryCallingNumber.
    alpha_numeric_number.clear_raw_input();
    let formatted_number = phone_util.format_out_of_country_keeping_alpha_chars(&alpha_numeric_number, RegionCode::de()).unwrap();
    assert_eq!("00 1 800 749 3524", formatted_number);
}

#[test]
fn format_with_carrier_code() {
    let phone_util = get_phone_util();
    
    let mut ar_number = PhoneNumber::new();
    ar_number.set_country_code(54);
    ar_number.set_national_number(91234125678);

    let formatted = phone_util.format(&ar_number, PhoneNumberFormat::National).unwrap();
    assert_eq!("01234 12-5678", formatted);

    let formatted = phone_util.format_national_number_with_carrier_code(&ar_number, "15").unwrap();
    assert_eq!("01234 15 12-5678", formatted);
    
    let formatted = phone_util.format_national_number_with_carrier_code(&ar_number, "").unwrap();
    assert_eq!("01234 12-5678", formatted);

    let formatted = phone_util.format(&ar_number, PhoneNumberFormat::E164).unwrap();
    assert_eq!("+5491234125678", formatted);

    let mut us_number = PhoneNumber::new();
    us_number.set_country_code(1);
    us_number.set_national_number(4241231234);

    let formatted = phone_util.format(&us_number, PhoneNumberFormat::National).unwrap();
    assert_eq!("424 123 1234", formatted);
    
    let formatted = phone_util.format_national_number_with_carrier_code(&us_number, "15").unwrap();
    assert_eq!("424 123 1234", formatted);

    let mut invalid_number = PhoneNumber::new();
    invalid_number.set_country_code(0);
    invalid_number.set_national_number(12345);
    
    let formatted = phone_util.format_national_number_with_carrier_code(&invalid_number, "89").unwrap();
    assert_eq!("12345", formatted);
}

// Весь код, который написан - корректен и компилируется
#[test]
fn format_with_preferred_carrier_code() {
    let phone_util = get_phone_util();
    let mut ar_number = PhoneNumber::new();
    ar_number.set_country_code(54);
    ar_number.set_national_number(91234125678);

    // Тестируем форматирование без предпочтительного кода оператора в самом номере.
    let formatted = phone_util.format_national_number_with_preferred_carrier_code(&ar_number, "15").unwrap();
    assert_eq!("01234 15 12-5678", formatted);

    let formatted = phone_util.format_national_number_with_preferred_carrier_code(&ar_number, "").unwrap();
    assert_eq!("01234 12-5678", formatted);

    // Тестируем форматирование с установленным предпочтительным кодом оператора.
    ar_number.set_preferred_domestic_carrier_code("19".to_string());
    let formatted = phone_util.format(&ar_number, PhoneNumberFormat::National).unwrap();
    assert_eq!("01234 12-5678", formatted);

    let formatted = phone_util
        .format_national_number_with_preferred_carrier_code(&ar_number, "15").unwrap();
    assert_eq!("01234 19 12-5678", formatted);

    let formatted = phone_util
        .format_national_number_with_preferred_carrier_code(&ar_number, "").unwrap();
    assert_eq!("01234 19 12-5678", formatted);

    // Если preferred_domestic_carrier_code присутствует (даже если это просто пробел),
    // используется он, а не код оператора по умолчанию.
    ar_number.set_preferred_domestic_carrier_code(" ".to_string());
    let formatted = phone_util.format_national_number_with_preferred_carrier_code(&ar_number, "15").unwrap();
    assert_eq!("01234   12-5678", formatted);

    // Если preferred_domestic_carrier_code присутствует, но пуст, он игнорируется,
    // и используется код оператора по умолчанию.
    ar_number.set_preferred_domestic_carrier_code("".to_string());
    let formatted = phone_util.format_national_number_with_preferred_carrier_code(&ar_number, "15").unwrap();
    assert_eq!("01234 15 12-5678", formatted);

    // Для США эта функция не поддерживается, поэтому изменений быть не должно.
    let mut us_number = PhoneNumber::new();
    us_number.set_country_code(1);
    us_number.set_national_number(4241231234);
    us_number.set_preferred_domestic_carrier_code("99".to_string());

    let formatted = phone_util.format(&us_number, PhoneNumberFormat::National).unwrap();
    assert_eq!("424 123 1234", formatted);

    let formatted = phone_util.format_national_number_with_preferred_carrier_code(&us_number, "15").unwrap();
    assert_eq!("424 123 1234", formatted);
}

#[test]
fn format_in_original_format() {
    let phone_util = get_phone_util();

    let mut phone_number = phone_util.parse_and_keep_raw_input("+442087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("+44 20 8765 4321", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("02087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("(020) 8765 4321", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("011442087654321", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("011 44 20 8765 4321", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("442087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("44 20 8765 4321", formatted_number);

    // Если номер парсится без сохранения исходного ввода, `format_in_original_format`
    // должен вернуться к стандартному национальному формату.
    phone_number = phone_util.parse("+442087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("(020) 8765 4321", formatted_number);

    // Невалидные номера, для которых есть шаблон форматирования, должны быть отформатированы
    // правильно. Примечание: коды регионов, начинающиеся с 7, намеренно исключены
    // из тестовых метаданных для целей тестирования.
    phone_number = phone_util.parse_and_keep_raw_input("7345678901", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("734 567 8901", formatted_number);

    // США не является страной с ведущим нулём, и его наличие
    // заставляет нас форматировать номер с использованием raw_input.
    phone_number = phone_util.parse_and_keep_raw_input("0734567 8901", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("0734567 8901", formatted_number);

    // Этот номер валиден, но у нас нет для него шаблона форматирования.
    // Возвращаемся к исходному вводу.
    phone_number = phone_util.parse_and_keep_raw_input("02-4567-8900", "KR").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "KR").unwrap();
    assert_eq!("02-4567-8900", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("01180012345678", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("011 800 1234 5678", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("+80012345678", "KR").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "KR").unwrap();
    assert_eq!("+800 1234 5678", formatted_number);

    // Местные номера США форматируются корректно, так как у нас есть для них шаблоны.
    phone_number = phone_util.parse_and_keep_raw_input("2530000", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("253 0000", formatted_number);

    // Номер с национальным префиксом в США.
    phone_number = phone_util.parse_and_keep_raw_input("18003456789", "US").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("1 800 345 6789", formatted_number);

    // Номер без национального префикса в Великобритании.
    phone_number = phone_util.parse_and_keep_raw_input("2087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("20 8765 4321", formatted_number);

    // Убедимся, что метаданные не были изменены в результате предыдущего вызова.
    phone_number = phone_util.parse("+442087654321", "GB").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "GB").unwrap();
    assert_eq!("(020) 8765 4321", formatted_number);

    // Номер с национальным префиксом в Мексике.
    phone_number = phone_util.parse_and_keep_raw_input("013312345678", "MX").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "MX").unwrap();
    assert_eq!("01 33 1234 5678", formatted_number);

    // Номер без национального префикса в Мексике.
    phone_number = phone_util.parse_and_keep_raw_input("3312345678", "MX").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "MX").unwrap();
    assert_eq!("33 1234 5678", formatted_number);

    // Итальянский стационарный номер.
    phone_number = phone_util.parse_and_keep_raw_input("0212345678", "IT").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "IT").unwrap();
    assert_eq!("02 1234 5678", formatted_number);

    // Номер с национальным префиксом в Японии.
    phone_number = phone_util.parse_and_keep_raw_input("00777012", "JP").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "JP").unwrap();
    assert_eq!("0077-7012", formatted_number);

    // Номер без национального префикса в Японии.
    phone_number = phone_util.parse_and_keep_raw_input("0777012", "JP").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "JP").unwrap();
    assert_eq!("0777012", formatted_number);

    // Номер с кодом оператора в Бразилии.
    phone_number = phone_util.parse_and_keep_raw_input("012 3121286979", "BR").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "BR").unwrap();
    assert_eq!("012 3121286979", formatted_number);

    // Национальный префикс по умолчанию в этом случае — 045. Когда вводится номер
    // с префиксом 044, мы возвращаем исходный ввод, так как не хотим менять введенный номер.
    phone_number = phone_util.parse_and_keep_raw_input("044(33)1234-5678", "MX").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "MX").unwrap();
    assert_eq!("044(33)1234-5678", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("045(33)1234-5678", "MX").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "MX").unwrap();
    assert_eq!("045 33 1234 5678", formatted_number);

    // Международный префикс по умолчанию в этом случае — 0011. Когда вводится номер
    // с префиксом 0012, мы возвращаем исходный ввод.
    phone_number = phone_util.parse_and_keep_raw_input("0012 16502530000", "AU").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "AU").unwrap();
    assert_eq!("0012 16502530000", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("0011 16502530000", "AU").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "AU").unwrap();
    assert_eq!("0011 1 650 253 0000", formatted_number);

    // Проверяем, что знак звёздочки (*) не удаляется и не добавляется к исходному вводу.
    phone_number = phone_util.parse_and_keep_raw_input("*1234", "JP").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "JP").unwrap();
    assert_eq!("*1234", formatted_number);

    phone_number = phone_util.parse_and_keep_raw_input("1234", "JP").unwrap();
    let formatted_number = phone_util.format_in_original_format(&phone_number, "JP").unwrap();
    assert_eq!("1234", formatted_number);

    // Проверяем, что невалидный национальный номер без исходного ввода просто
    // форматируется как национальный номер.
    let mut phone_number = PhoneNumber::new();
    phone_number.set_country_code_source(CountryCodeSource::FROM_DEFAULT_COUNTRY);
    phone_number.set_country_code(1);
    phone_number.set_national_number(650253000);
    let formatted_number = phone_util.format_in_original_format(&phone_number, "US").unwrap();
    assert_eq!("650253000", formatted_number);
}

#[test]
fn parse_and_keep_raw() {
    let phone_util = get_phone_util();
    let mut alpha_numeric_number = PhoneNumber::new();
    alpha_numeric_number.set_country_code(1);
    alpha_numeric_number.set_national_number(80074935247);
    alpha_numeric_number.set_raw_input("800 six-flags".to_string());
    alpha_numeric_number.set_country_code_source(CountryCodeSource::FROM_DEFAULT_COUNTRY);

    let test_number = phone_util.parse_and_keep_raw_input("800 six-flags", "US").unwrap();
    assert_eq!(alpha_numeric_number, test_number);
    
    alpha_numeric_number.set_national_number(8007493524);
    alpha_numeric_number.set_raw_input("1800 six-flag".to_string());
    alpha_numeric_number.set_country_code_source(CountryCodeSource::FROM_NUMBER_WITHOUT_PLUS_SIGN);
    let test_number = phone_util.parse_and_keep_raw_input("1800 six-flag", "US").unwrap();
    assert_eq!(alpha_numeric_number, test_number);

    alpha_numeric_number.set_raw_input("+1800 six-flag".to_string());
    alpha_numeric_number.set_country_code_source(CountryCodeSource::FROM_NUMBER_WITH_PLUS_SIGN);
    let test_number = phone_util.parse_and_keep_raw_input("+1800 six-flag", "CN").unwrap();
    assert_eq!(alpha_numeric_number, test_number);

    alpha_numeric_number.set_raw_input("001800 six-flag".to_string());
    alpha_numeric_number.set_country_code_source(CountryCodeSource::FROM_NUMBER_WITH_IDD);
    let test_number = phone_util.parse_and_keep_raw_input("001800 six-flag", "NZ").unwrap();
    assert_eq!(alpha_numeric_number, test_number);

    // Попробуем с невалидным регионом - ожидаем ошибку.
    let result = phone_util.parse("123 456 7890", "CS");
    assert!(result.is_err());
    
    let mut korean_number = PhoneNumber::new();
    korean_number.set_country_code(82);
    korean_number.set_national_number(22123456);
    korean_number.set_raw_input("08122123456".to_string());
    korean_number.set_country_code_source(CountryCodeSource::FROM_DEFAULT_COUNTRY);
    korean_number.set_preferred_domestic_carrier_code("81".to_string());
    let test_number = phone_util.parse_and_keep_raw_input("08122123456", "KR").unwrap();
    assert_eq!(korean_number, test_number);
}

#[test]
fn parse_italian_leading_zeros() {
    let phone_util = get_phone_util();
    let mut zeros_number = PhoneNumber::new();
    zeros_number.set_country_code(61);

    // Тестируем номер "011".
    zeros_number.set_national_number(11);
    zeros_number.set_italian_leading_zero(true);
    // `number_of_leading_zeros` по умолчанию равен 1, поэтому его не устанавливаем.
    let test_number = phone_util.parse("011", "AU").unwrap();
    assert_eq!(zeros_number, test_number);

    // Тестируем номер "001".
    zeros_number.set_national_number(1);
    zeros_number.set_italian_leading_zero(true);
    zeros_number.set_number_of_leading_zeros(2);
    let test_number = phone_util.parse("001", "AU").unwrap();
    assert_eq!(zeros_number, test_number);

    // Тестируем номер "000". Этот номер имеет 2 ведущих нуля.
    zeros_number.set_national_number(0);
    zeros_number.set_italian_leading_zero(true);
    zeros_number.set_number_of_leading_zeros(2);
    let test_number = phone_util.parse("000", "AU").unwrap();
    assert_eq!(zeros_number, test_number);

    // Тестируем номер "0000". Этот номер имеет 3 ведущих нуля.
    zeros_number.set_national_number(0);
    zeros_number.set_italian_leading_zero(true);
    zeros_number.set_number_of_leading_zeros(3);
    let test_number = phone_util.parse("0000", "AU").unwrap();
    assert_eq!(zeros_number, test_number);
}

#[test]
fn maybe_strip_national_prefix_and_carrier_code() {
    let phone_util = get_phone_util();
    let mut metadata = PhoneMetadata::new();
    let general_desc = PhoneNumberDesc::new();
    metadata.general_desc = MessageField::some(general_desc);
    metadata.general_desc
        .as_mut()
        .map(| m | m.set_national_number_pattern("\\d{4,8}".to_string()));
    
    metadata.set_national_prefix_for_parsing("34".to_string());
    let mut number_to_strip = "34356778".to_string();
    let phone_number_and_carrier_code = phone_util
        .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
        .unwrap();

    assert_eq!("356778", phone_number_and_carrier_code.0, "Should have had national prefix stripped.");
    assert_eq!(None, phone_number_and_carrier_code.1, "Should have had no carrier code stripped.");

    // Повторная попытка удаления - теперь номер не должен начинаться с национального префикса,
    // поэтому дальнейшее удаление не должно происходить.
    let phone_number_and_carrier_code = phone_util
        .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
        .unwrap();

    assert_eq!("356778", phone_number_and_carrier_code.0, "Should have had no change - no national prefix present.");

    // В некоторых странах нет национального префикса. Повторяем тест без указания префикса.
    metadata.clear_national_prefix_for_parsing();
        let phone_number_and_carrier_code = phone_util
        .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
        .unwrap();

    assert!(phone_number_and_carrier_code.1.is_none(), "Should have had no change - empty national prefix.");

    // Если результирующий номер не соответствует национальному правилу, он не должен быть удален.
    metadata.set_national_prefix_for_parsing("3".to_string());
    let mut number_to_strip = "3123".to_string();
    let phone_number_and_carrier_code = phone_util
        .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
        .unwrap();
    assert_eq!("3123", phone_number_and_carrier_code.0, "Should have had no change - after stripping, it wouldn't have matched the national rule.");

    // Тестируем извлечение кода выбора оператора.
    metadata.set_national_prefix_for_parsing("0(81)?".to_string());
    let mut number_to_strip = "08122123456".to_string();
let phone_number_and_carrier_code = phone_util
        .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
        .unwrap();
    assert_eq!(Some("81"), phone_number_and_carrier_code.1, "Should have had carrier code stripped.");
    assert_eq!("22123456", phone_number_and_carrier_code.0, "Should have had national prefix and carrier code stripped.");

    // Если было правило преобразования, проверяем, что оно было применено.
    // There is a regex difference how transform do works in rust and cpp.
    // Since patterns in metadata.xml only ends with $\d and no rules like this appears
    // we can do this. But this should be handled on any changes
    metadata.set_national_prefix_transform_rule("5${1}5".to_string());
    // Обратите внимание, что здесь присутствует захватывающая группа.
    metadata.set_national_prefix_for_parsing("0(\\d{2})".to_string());
    let mut number_to_strip = "031123".to_string();
    let phone_number_and_carrier_code = phone_util
            .maybe_strip_national_prefix_and_carrier_code(&metadata, &number_to_strip)
            .unwrap();
            
    assert_eq!("5315123", phone_number_and_carrier_code.0, "Was not successfully transformed.");
}

#[test]
fn format_out_of_country_with_invalid_region() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(1);
    test_number.set_national_number(6502530000);
    // AQ/Antarctica is invalid, fall back to international format.
    assert_eq!("+1 650 253 0000", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::aq()).unwrap());
    // For region 001, fall back to international format.
    assert_eq!("+1 650 253 0000", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::un001()).unwrap());
}

#[test]
fn format_out_of_country_with_preferred_intl_prefix() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(39);
    test_number.set_national_number(236618300);
    test_number.set_italian_leading_zero(true);

    // Should use 0011, preferred for AU.
    assert_eq!("0011 39 02 3661 8300", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::au()).unwrap());
    
    // Testing preferred international prefixes with ~ (wait).
    assert_eq!("8~10 39 02 3661 8300", phone_util.format_out_of_country_calling_number(&test_number, RegionCode::uz()).unwrap());
}


#[test]
fn format_e164_number() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    
    test_number.set_country_code(1);
    test_number.set_national_number(6502530000);
    assert_eq!("+16502530000", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
    
    test_number.set_country_code(49);
    test_number.set_national_number(301234);
    assert_eq!("+49301234", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
    
    test_number.set_country_code(800);
    test_number.set_national_number(12345678);
    assert_eq!("+80012345678", phone_util.format(&test_number, PhoneNumberFormat::E164).unwrap());
}

#[test]
fn format_number_with_extension() {
    let phone_util = get_phone_util();
    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    nz_number.set_extension("1234".to_owned());
    assert_eq!("03-331 6005 ext. 1234", phone_util.format(&nz_number, PhoneNumberFormat::National).unwrap());
    assert_eq!("tel:+64-3-331-6005;ext=1234", phone_util.format(&nz_number, PhoneNumberFormat::RFC3966).unwrap());

    let mut us_number_with_extension = PhoneNumber::new();
    us_number_with_extension.set_country_code(1);
    us_number_with_extension.set_national_number(6502530000);
    us_number_with_extension.set_extension("4567".to_owned());
    assert_eq!("650 253 0000 extn. 4567", phone_util.format(&us_number_with_extension, PhoneNumberFormat::National).unwrap());
}

#[test]
fn is_valid_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();

    number.set_country_code(1);
    number.set_national_number(6502530000);
    assert!(phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(39);
    number.set_national_number(236618300);
    number.set_italian_leading_zero(true);
    assert!(phone_util.is_valid_number(&number).unwrap());
    
    number.clear();
    number.set_country_code(44);
    number.set_national_number(7912345678);
    assert!(phone_util.is_valid_number(&number).unwrap());
    
    number.clear();
    number.set_country_code(64);
    number.set_national_number(21387835);
    assert!(phone_util.is_valid_number(&number).unwrap());
    
    number.clear();
    number.set_country_code(800);
    number.set_national_number(12345678);
    assert!(phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(979);
    number.set_national_number(123456789);
    assert!(phone_util.is_valid_number(&number).unwrap());
}

#[test]
fn is_valid_number_for_region() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    number.set_country_code(1);
    number.set_national_number(2423232345);
    assert!(phone_util.is_valid_number(&number).unwrap());
    assert!(phone_util.is_valid_number_for_region(&number, RegionCode::bs()));
    assert!(!phone_util.is_valid_number_for_region(&number, RegionCode::us()));
    
    // Now an invalid number for BS
    number.set_national_number(2421232345);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    // La Mayotte and Réunion
    let mut re_number = PhoneNumber::new();
    re_number.set_country_code(262);
    re_number.set_national_number(262123456);
    assert!(phone_util.is_valid_number(&re_number).unwrap());
    assert!(phone_util.is_valid_number_for_region(&re_number, RegionCode::re()));
    assert!(!phone_util.is_valid_number_for_region(&re_number, RegionCode::yt()));
    
    re_number.set_national_number(269601234);
    assert!(phone_util.is_valid_number_for_region(&re_number, RegionCode::yt()));
    assert!(!phone_util.is_valid_number_for_region(&re_number, RegionCode::re()));

    // This number is valid in both.
    re_number.set_national_number(800123456);
    assert!(phone_util.is_valid_number_for_region(&re_number, RegionCode::yt()));
    assert!(phone_util.is_valid_number_for_region(&re_number, RegionCode::re()));

    let mut intl_toll_free = PhoneNumber::new();
    intl_toll_free.set_country_code(800);
    intl_toll_free.set_national_number(12345678);
    assert!(phone_util.is_valid_number_for_region(&intl_toll_free, RegionCode::un001()));
    assert!(!phone_util.is_valid_number_for_region(&intl_toll_free, RegionCode::us()));
    assert!(!phone_util.is_valid_number_for_region(&intl_toll_free, RegionCode::zz()));

    let mut invalid_number = PhoneNumber::new();
    invalid_number.set_country_code(3923);
    invalid_number.set_national_number(2366);
    assert!(!phone_util.is_valid_number_for_region(&invalid_number, RegionCode::zz()));
    assert!(!phone_util.is_valid_number_for_region(&invalid_number, RegionCode::un001()));
    
    invalid_number.set_country_code(0);
    assert!(!phone_util.is_valid_number_for_region(&invalid_number, RegionCode::un001()));
    assert!(!phone_util.is_valid_number_for_region(&invalid_number, RegionCode::zz()));
}

#[test]
fn is_not_valid_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    
    number.set_country_code(1);
    number.set_national_number(2530000);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(39);
    number.set_national_number(23661830000);
    number.set_italian_leading_zero(true);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(44);
    number.set_national_number(791234567);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(49);
    number.set_national_number(1234);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(64);
    number.set_national_number(3316005);
    assert!(!phone_util.is_valid_number(&number).unwrap());

    number.clear();
    number.set_country_code(3923);
    number.set_national_number(2366);
    assert!(!phone_util.is_valid_number(&number).unwrap());
    
    number.set_country_code(0);
    assert!(!phone_util.is_valid_number(&number).unwrap());
    
    number.clear();
    number.set_country_code(800);
    number.set_national_number(123456789);
    assert!(!phone_util.is_valid_number(&number).unwrap());
}

#[test]
fn get_region_code_for_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    
    number.set_country_code(1);
    number.set_national_number(2423232345);
    assert_eq!(RegionCode::bs(), phone_util.get_region_code_for_number(&number).unwrap());
    
    number.set_national_number(4241231234);
    assert_eq!(RegionCode::us(), phone_util.get_region_code_for_number(&number).unwrap());
    
    number.set_country_code(44);
    number.set_national_number(7912345678);
    assert_eq!(RegionCode::gb(), phone_util.get_region_code_for_number(&number).unwrap());
    
    number.set_country_code(800);
    number.set_national_number(12345678);
    assert_eq!(RegionCode::un001(), phone_util.get_region_code_for_number(&number).unwrap());
    
    number.set_country_code(979);
    number.set_national_number(123456789);
    assert_eq!(RegionCode::un001(), phone_util.get_region_code_for_number(&number).unwrap());
}


#[test]
fn is_possible_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    number.set_country_code(1);
    number.set_national_number(6502530000);
    assert!(phone_util.is_possible_number(&number));
    number.set_national_number(2530000);
    assert!(phone_util.is_possible_number(&number));
    
    number.set_country_code(44);
    number.set_national_number(2070313000);
    assert!(phone_util.is_possible_number(&number));
    
    number.set_country_code(800);
    number.set_national_number(12345678);
    assert!(phone_util.is_possible_number(&number));

    assert!(phone_util.is_possible_number_for_string("+1 650 253 0000", RegionCode::us()));
    assert!(phone_util.is_possible_number_for_string("+1 650 GOO OGLE", RegionCode::us()));
    assert!(phone_util.is_possible_number_for_string("(650) 253-0000", RegionCode::us()));
    assert!(phone_util.is_possible_number_for_string("253-0000", RegionCode::us()));
    assert!(phone_util.is_possible_number_for_string("+1 650 253 0000", RegionCode::gb()));
    assert!(phone_util.is_possible_number_for_string("+44 20 7031 3000", RegionCode::gb()));
    assert!(phone_util.is_possible_number_for_string("(020) 7031 300", RegionCode::gb()));
    assert!(phone_util.is_possible_number_for_string("7031 3000", RegionCode::gb()));
    assert!(phone_util.is_possible_number_for_string("3331 6005", RegionCode::nz()));
    assert!(phone_util.is_possible_number_for_string("+800 1234 5678", RegionCode::un001()));
}

#[test]
fn is_not_possible_number() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    
    number.set_country_code(1);
    number.set_national_number(65025300000);
    assert!(!phone_util.is_possible_number(&number));
    
    number.set_country_code(800);
    number.set_national_number(123456789);
    assert!(!phone_util.is_possible_number(&number));

    number.set_country_code(1);
    number.set_national_number(253000);
    assert!(!phone_util.is_possible_number(&number));

    number.set_country_code(44);
    number.set_national_number(300);
    assert!(!phone_util.is_possible_number(&number));

    assert!(!phone_util.is_possible_number_for_string("+1 650 253 00000", RegionCode::us()));
    assert!(!phone_util.is_possible_number_for_string("(650) 253-00000", RegionCode::us()));
    assert!(!phone_util.is_possible_number_for_string("I want a Pizza", RegionCode::us()));
    assert!(!phone_util.is_possible_number_for_string("253-000", RegionCode::us()));
    assert!(!phone_util.is_possible_number_for_string("1 3000", RegionCode::gb()));
    assert!(!phone_util.is_possible_number_for_string("+44 300", RegionCode::gb()));
    assert!(!phone_util.is_possible_number_for_string("+800 1234 5678 9", RegionCode::un001()));
}


#[test]
fn is_possible_number_with_reason() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();

    number.set_country_code(1);
    number.set_national_number(6502530000);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_with_reason(&number));

    number.set_national_number(2530000);
    assert_eq!(Ok(ValidNumberLenType::IsPossibleLocalOnly), phone_util.is_possible_number_with_reason(&number));
    
    number.set_country_code(0);
    assert_eq!(Err(ValidationResultErr::InvalidCountryCode), phone_util.is_possible_number_with_reason(&number));

    number.set_country_code(1);
    number.set_national_number(253000);
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_with_reason(&number));

    number.set_national_number(65025300000);
    assert_eq!(Err(ValidationResultErr::TooLong), phone_util.is_possible_number_with_reason(&number));

    number.set_country_code(44);
    number.set_national_number(2070310000);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_with_reason(&number));

    number.set_country_code(49);
    number.set_national_number(30123456);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_with_reason(&number));

    number.set_country_code(65);
    number.set_national_number(1234567890);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_with_reason(&number));

    number.set_country_code(800);
    number.set_national_number(123456789);
    assert_eq!(Err(ValidationResultErr::TooLong), phone_util.is_possible_number_with_reason(&number));
}

#[test]
fn is_possible_number_for_type_with_reason() {
    let phone_util = get_phone_util();
    let mut ar_number = PhoneNumber::new();
    ar_number.set_country_code(54);

    ar_number.set_national_number(12345);
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::Unknown));
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::FixedLine));

    ar_number.set_national_number(123456);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::Unknown));
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::FixedLine));
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::Mobile));
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::TollFree));

    ar_number.set_national_number(12345678901);
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::Unknown));
    assert_eq!(Err(ValidationResultErr::TooLong), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::FixedLine));
    assert_eq!(Ok(ValidNumberLenType::IsPossible), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::Mobile));
    assert_eq!(Err(ValidationResultErr::TooLong), phone_util.is_possible_number_for_type_with_reason(&ar_number, PhoneNumberType::TollFree));
    
    let mut de_number = PhoneNumber::new();
    de_number.set_country_code(49);
    de_number.set_national_number(12);
    assert_eq!(Ok(ValidNumberLenType::IsPossibleLocalOnly), phone_util.is_possible_number_for_type_with_reason(&de_number, PhoneNumberType::Unknown));
    assert_eq!(Ok(ValidNumberLenType::IsPossibleLocalOnly), phone_util.is_possible_number_for_type_with_reason(&de_number, PhoneNumberType::FixedLine));
    assert_eq!(Err(ValidationResultErr::TooShort), phone_util.is_possible_number_for_type_with_reason(&de_number, PhoneNumberType::Mobile));

    let mut br_number = PhoneNumber::new();
    br_number.set_country_code(55);
    br_number.set_national_number(12345678);
    assert_eq!(Err(ValidationResultErr::InvalidLength), phone_util.is_possible_number_for_type_with_reason(&br_number, PhoneNumberType::Mobile));
    assert_eq!(Ok(ValidNumberLenType::IsPossibleLocalOnly), phone_util.is_possible_number_for_type_with_reason(&br_number, PhoneNumberType::FixedLineOrMobile));
}

#[test]
fn truncate_too_long_number() {
    let phone_util = get_phone_util();

    let mut too_long_number = phone_util.parse("+165025300001", RegionCode::us()).unwrap();
    let valid_number = phone_util.parse("+16502530000", RegionCode::us()).unwrap();
    assert!(phone_util.truncate_too_long_number(&mut too_long_number).unwrap());
    assert_eq!(valid_number, too_long_number);
    
    let mut valid_number_copy = valid_number.clone();
    assert!(phone_util.truncate_too_long_number(&mut valid_number_copy).unwrap());
    assert_eq!(valid_number, valid_number_copy);

    let mut too_short_number = phone_util.parse("+11234", RegionCode::us()).unwrap();
    let too_short_number_copy = too_short_number.clone();
    assert!(!phone_util.truncate_too_long_number(&mut too_short_number).unwrap());
    assert_eq!(too_short_number_copy, too_short_number);
}

#[test]
fn normalise_remove_punctuation() {
    let phone_util = get_phone_util();
    let input_number = "034-56&+#2\u{ad}34".to_string();
    let normalized_number = phone_util.normalize(&input_number);
    let expected_output = "03456234";
    assert_eq!(expected_output, normalized_number, "Conversion did not correctly remove punctuation");
}

#[test]
fn normalise_replace_alpha_characters() {
    let phone_util = get_phone_util();
    let input_number = "034-I-am-HUNGRY".to_string();
    let normalized_number = phone_util.normalize(&input_number);
    let expected_output = "034426486479";
    assert_eq!(expected_output, normalized_number, "Conversion did not correctly replace alpha characters");
}

#[test]
fn normalise_other_digits() {
    let phone_util = get_phone_util();
    // Full-width 2, Arabic-indic 5
    let input = "\u{ff12}5\u{0665}"; // "２5٥"
    assert_eq!("255", phone_util.normalize(&input));
    
    // Eastern-Arabic 5 and 0
    let input = "\u{06f5}2\u{06f0}"; // "۵2۰"
    assert_eq!("520", phone_util.normalize(&input));
}

#[test]
fn normalise_strip_alpha_characters() {
    let phone_util = get_phone_util();
    let input_number = "034-56&+a#234".to_string();
    let normalized_number = phone_util.normalize_digits_only(&input_number);
    let expected_output = "03456234";
    assert_eq!(expected_output, normalized_number, "Conversion did not correctly remove alpha characters");
}


#[test]
fn maybe_strip_extension() {
    let phone_util = get_phone_util();
    let number = "1234576 ext. 1234";
    let expected_extension = "1234";
    let stripped_number = "1234576";
    let (number, extension) = phone_util.maybe_strip_extension(number);
    assert!(extension.is_some());
    assert_eq!(stripped_number, number);
    assert_eq!(expected_extension, extension.unwrap());
}

#[test]
fn get_number_type() {
    let phone_util = get_phone_util();
    let mut number = PhoneNumber::new();
    
    // PREMIUM_RATE
    number.set_country_code(1); number.set_national_number(9004433030);
    assert_eq!(PhoneNumberType::PremiumRate, phone_util.get_number_type(&number).unwrap());
    number.set_country_code(44); number.set_national_number(9187654321);
    assert_eq!(PhoneNumberType::PremiumRate, phone_util.get_number_type(&number).unwrap());

    // TOLL_FREE
    number.set_country_code(1); number.set_national_number(8881234567);
    assert_eq!(PhoneNumberType::TollFree, phone_util.get_number_type(&number).unwrap());
    number.set_country_code(44); number.set_national_number(8012345678);
    assert_eq!(PhoneNumberType::TollFree, phone_util.get_number_type(&number).unwrap());
    number.set_country_code(800); number.set_national_number(12345678);
    assert_eq!(PhoneNumberType::TollFree, phone_util.get_number_type(&number).unwrap());

    // MOBILE
    number.set_country_code(1); number.set_national_number(2423570000);
    assert_eq!(PhoneNumberType::Mobile, phone_util.get_number_type(&number).unwrap());
    number.set_country_code(44); number.set_national_number(7912345678);
    assert_eq!(PhoneNumberType::Mobile, phone_util.get_number_type(&number).unwrap());

    // FIXED_LINE
    number.set_country_code(1); number.set_national_number(2423651234);
    assert_eq!(PhoneNumberType::FixedLine, phone_util.get_number_type(&number).unwrap());
    number.clear(); number.set_country_code(39); number.set_national_number(236618300); number.set_italian_leading_zero(true);
    assert_eq!(PhoneNumberType::FixedLine, phone_util.get_number_type(&number).unwrap());
    number.clear(); number.set_country_code(44); number.set_national_number(2012345678);
    assert_eq!(PhoneNumberType::FixedLine, phone_util.get_number_type(&number).unwrap());

    // FIXED_LINE_OR_MOBILE
    number.clear(); number.set_country_code(1); number.set_national_number(6502531111);
    assert_eq!(PhoneNumberType::FixedLineOrMobile, phone_util.get_number_type(&number).unwrap());
    
    // SHARED_COST
    number.clear(); number.set_country_code(44); number.set_national_number(8431231234);
    assert_eq!(PhoneNumberType::SharedCost, phone_util.get_number_type(&number).unwrap());
    
    // VOIP
    number.clear(); number.set_country_code(44); number.set_national_number(5631231234);
    assert_eq!(PhoneNumberType::VoIP, phone_util.get_number_type(&number).unwrap());
    
    // PERSONAL_NUMBER
    number.clear(); number.set_country_code(44); number.set_national_number(7031231234);
    assert_eq!(PhoneNumberType::PersonalNumber, phone_util.get_number_type(&number).unwrap());
    
    // UNKNOWN
    number.clear(); number.set_country_code(1); number.set_national_number(65025311111);
    assert_eq!(PhoneNumberType::Unknown, phone_util.get_number_type(&number).unwrap());
}

#[test]
fn parse_national_number() {
    let phone_util = get_phone_util();

    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    
    // С национальным префиксом.
    let test_number = phone_util.parse("033316005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Без национального префикса.
    let test_number = phone_util.parse("33316005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // С национальным префиксом и форматированием.
    let test_number = phone_util.parse("03-331 6005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("03 331 6005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Тестирование парсинга формата RFC3966 с phone-context.
    let test_number = phone_util.parse("tel:03-331-6005;phone-context=+64", "NZ").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("tel:331-6005;phone-context=+64-3", "NZ").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("tel:331-6005;phone-context=+64-3", "US").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("My number is tel:03-331-6005;phone-context=+64", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Тестирование парсинга RFC3966 с опциональными параметрами.
    let test_number = phone_util.parse("tel:03-331-6005;phone-context=+64;a=%A1", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Тестирование парсинга RFC3966 с ISDN-субадресом.
    let test_number = phone_util.parse("tel:03-331-6005;isub=12345;phone-context=+64", "NZ").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("tel:+64-3-331-6005;isub=12345", "US").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("03-331-6005;phone-context=+64", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Тестирование международных префиксов.
    // Код страны должен быть удалён.
    let test_number = phone_util.parse("0064 3 d331 6005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Попробуем снова, но на этот раз с международным номером для региона US.
    // Код страны должен быть распознан и обработан корректно.
    let test_number = phone_util.parse("01164 3 331 6005", "US").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("+64 3 331 6005", "US").unwrap();
    assert_eq!(nz_number, test_number);

    // Ведущий плюс должен игнорироваться, т.к. за ним следует не код страны, а IDD для США.
    let test_number = phone_util.parse("+01164 3 331 6005", "US").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("+0064 3 331 6005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);
    let test_number = phone_util.parse("+ 00 64 3 331 6005", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let mut us_local_number = PhoneNumber::new();
    us_local_number.set_country_code(1);
    us_local_number.set_national_number(2530000);
    let test_number = phone_util.parse("tel:253-0000;phone-context=www.google.com", "US").unwrap();
    assert_eq!(us_local_number, test_number);
    let test_number = phone_util.parse("tel:253-0000;isub=12345;phone-context=www.google.com", "US").unwrap();
    assert_eq!(us_local_number, test_number);
    let test_number = phone_util.parse("tel:2530000;isub=12345;phone-context=1234.com", "US").unwrap();
    assert_eq!(us_local_number, test_number);

    // Тест для http://b/issue?id=2247493
    let mut nz_number_issue = PhoneNumber::new();
    nz_number_issue.set_country_code(64);
    nz_number_issue.set_national_number(64123456);
    let test_number = phone_util.parse("+64(0)64123456", "US").unwrap();
    assert_eq!(nz_number_issue, test_number);

    // Проверка, что "/" в номере телефона обрабатывается корректно.
    let mut de_number = PhoneNumber::new();
    de_number.set_country_code(49);
    de_number.set_national_number(12345678);
    let test_number = phone_util.parse("123/45678", "DE").unwrap();
    assert_eq!(de_number, test_number);

    let mut us_number = PhoneNumber::new();
    us_number.set_country_code(1);
    // Проверка, что '1' не используется как код страны при парсинге, если номер уже валиден.
    us_number.set_national_number(1234567890);
    let test_number = phone_util.parse("123-456-7890", "US").unwrap();
    assert_eq!(us_number, test_number);

    // Тестирование номеров со звездочкой.
    let mut star_number = PhoneNumber::new();
    star_number.set_country_code(81);
    star_number.set_national_number(2345);
    let test_number = phone_util.parse("+81 *2345", "JP").unwrap();
    assert_eq!(star_number, test_number);

    let mut short_number = PhoneNumber::new();
    short_number.set_country_code(64);
    short_number.set_national_number(12);
    let test_number = phone_util.parse("12", "NZ").unwrap();
    assert_eq!(short_number, test_number);

    // Тест для короткого номера с ведущим нулём для страны, где 0 - национальный префикс.
    // Убедиться, что он не интерпретируется как национальный префикс, если
    // оставшаяся длина номера соответствует только местному номеру.
    let mut short_number = PhoneNumber::new();
    short_number.set_country_code(44);
    short_number.set_national_number(123456);
    short_number.set_italian_leading_zero(true);
    let test_number = phone_util.parse("0123456", "GB").unwrap();
    assert_eq!(short_number, test_number);
}

#[test]
fn parse_with_phone_context() {
    fn assert_throws_for_invalid_phone_context(phone_util: &PhoneNumberUtil, number_to_parse: &str) {
        let result = phone_util.parse(number_to_parse, "ZZ");
        assert!(result.is_err(), "Expected an error for: {}", number_to_parse);
    }
    let phone_util = get_phone_util();
    let mut expected_number = PhoneNumber::new();
    expected_number.set_country_code(64);
    expected_number.set_national_number(33316005);
    
    // context    = ";phone-context=" descriptor
    // descriptor = domainname / global-number-digits
    
    // Валидные global-phone-digits
    let mut actual_number = phone_util.parse("tel:033316005;phone-context=+64", "ZZ").unwrap();
    assert_eq!(expected_number, actual_number);

    actual_number = phone_util.parse("tel:033316005;phone-context=+64;{this isn't part of phone-context anymore!}", "ZZ").unwrap();
    assert_eq!(expected_number, actual_number);

    expected_number.set_national_number(3033316005);
    actual_number = phone_util.parse("tel:033316005;phone-context=+64-3", "ZZ").unwrap();
    assert_eq!(expected_number, actual_number);
    
    expected_number.set_country_code(55);
    expected_number.set_national_number(5033316005);
    actual_number = phone_util.parse("tel:033316005;phone-context=+(555)", "ZZ").unwrap();
    assert_eq!(expected_number, actual_number);

    expected_number.set_country_code(1);
    expected_number.set_national_number(23033316005);
    actual_number = phone_util.parse("tel:033316005;phone-context=+-1-2.3()", "ZZ").unwrap();
    assert_eq!(expected_number, actual_number);

    // Валидный domainname
    expected_number.set_country_code(64);
    expected_number.set_national_number(33316005);
    actual_number = phone_util.parse("tel:033316005;phone-context=abc.nz", "NZ").unwrap();
    assert_eq!(expected_number, actual_number);

    actual_number = phone_util.parse("tel:033316005;phone-context=www.PHONE-numb3r.com", "NZ").unwrap();
    assert_eq!(expected_number, actual_number);

    actual_number = phone_util.parse("tel:033316005;phone-context=a", "NZ").unwrap();
    assert_eq!(expected_number, actual_number);

    actual_number = phone_util.parse("tel:033316005;phone-context=3phone.J.", "NZ").unwrap();
    assert_eq!(expected_number, actual_number);
    
    actual_number = phone_util.parse("tel:033316005;phone-context=a--z", "NZ").unwrap();
    assert_eq!(expected_number, actual_number);

    // Невалидный descriptor
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=+");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=64");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=++64");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=+abc");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=.");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=3phone");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=a-.nz");
    assert_throws_for_invalid_phone_context(&phone_util, "tel:033316005;phone-context=a{b}c");
}

#[test]
fn failed_parse_on_invalid_numbers() {
    let phone_util = get_phone_util();

    // Проверяем, что парсинг невалидных номеров завершается ошибкой.
    assert!(matches!(
        phone_util.parse("This is not a phone number", "NZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert!(matches!(
        phone_util.parse("1 Still not a number", "NZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert!(matches!(
        phone_util.parse("1 MICROSOFT", "NZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert!(matches!(
        phone_util.parse("12 MICROSOFT", "NZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert_eq!(
        phone_util.parse("01495 72553301873 810104", "GB").unwrap_err(),
        ParseError::TooLongNsn
    );
    assert!(matches!(
        phone_util.parse("+---", "DE").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert!(matches!(
        phone_util.parse("+***", "DE").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert!(matches!(
        phone_util.parse("+*******91", "DE").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    assert_eq!(
        phone_util.parse("+49 0", "DE").unwrap_err(),
        ParseError::TooShortNsn
    );
    assert_eq!(
        phone_util.parse("+210 3456 56789", "NZ").unwrap_err(),
        ParseError::InvalidCountryCode
    );
    // 00 - правильный МНН, но 210 - невалидный код страны.
    assert_eq!(
        phone_util.parse("+ 00 210 3 331 6005", "NZ").unwrap_err(),
        ParseError::InvalidCountryCode
    );
    assert_eq!(
        phone_util.parse("123 456 7890", "ZZ").unwrap_err(),
        ParseError::InvalidCountryCode
    );
    assert_eq!(
        phone_util.parse("123 456 7890", "CS").unwrap_err(),
        ParseError::InvalidCountryCode
    );
    assert_eq!(
        phone_util.parse("0044-----", "GB").unwrap_err(),
        ParseError::TooShortAfterIdd
    );
    assert_eq!(
        phone_util.parse("0044", "GB").unwrap_err(),
        ParseError::TooShortAfterIdd
    );
    assert_eq!(
        phone_util.parse("011", "US").unwrap_err(),
        ParseError::TooShortAfterIdd
    );
    assert_eq!(
        phone_util.parse("0119", "US").unwrap_err(),
        ParseError::TooShortAfterIdd
    );
    // RFC3966 phone-context является веб-сайтом.
    assert_eq!(
        phone_util.parse("tel:555-1234;phone-context=www.google.com", "ZZ").unwrap_err(),
        ParseError::InvalidCountryCode
    );
    // Это невалидно, так как отсутствует знак "+" в phone-context.
    assert!(matches!(
        phone_util.parse("tel:555-1234;phone-context=1-331", "ZZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
    // Присутствует только символ phone-context, но нет данных.
    assert!(matches!(
        phone_util.parse(";phone-context=", "ZZ").unwrap_err(),
        ParseError::NotANumber(_)
    ));
}

#[test]
fn parse_numbers_with_plus_with_no_region() {
    let phone_util = get_phone_util();
    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    // "ZZ" (неизвестный регион) разрешен только если номер начинается с "+",
    // тогда код страны можно определить.
    let mut result_proto = phone_util.parse("+64 3 331 6005", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);

    // Тестируем с полноширинным плюсом.
    result_proto = phone_util.parse("\u{FF0B}64 3 331 6005", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);
    // Тестируем с обычным плюсом, но с начальными символами, которые нужно удалить.
    result_proto = phone_util.parse("  +64 3 331 6005", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);

    let mut toll_free_number = PhoneNumber::new();
    toll_free_number.set_country_code(800);
    toll_free_number.set_national_number(12345678);
    result_proto = phone_util.parse("+800 1234 5678", "ZZ").unwrap();
    assert_eq!(toll_free_number, result_proto);

    let mut universal_premium_rate = PhoneNumber::new();
    universal_premium_rate.set_country_code(979);
    universal_premium_rate.set_national_number(123456789);
    result_proto = phone_util.parse("+979 123 456 789", "ZZ").unwrap();
    assert_eq!(universal_premium_rate, result_proto);

    // Тестируем парсинг формата RFC3966 с phone context.
    result_proto = phone_util.parse("tel:03-331-6005;phone-context=+64", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);

    result_proto = phone_util.parse("  tel:03-331-6005;phone-context=+64", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);
    
    result_proto = phone_util.parse("tel:03-331-6005;isub=12345;phone-context=+64", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);

    nz_number.set_raw_input("+64 3 331 6005".to_string());
    nz_number.set_country_code_source(CountryCodeSource::FROM_NUMBER_WITH_PLUS_SIGN);
    result_proto = phone_util.parse_and_keep_raw_input("+64 3 331 6005", "ZZ").unwrap();
    assert_eq!(nz_number, result_proto);
}

#[test]
fn parse_number_too_short_if_national_prefix_stripped() {
    let phone_util = get_phone_util();

    // Тестируем, что у номера, первые цифры которого совпадают с национальным префиксом,
    // они не удаляются, если это приведет к тому, что номер станет слишком коротким,
    // чтобы быть возможным (стандартной длины) телефонным номером для этого региона.
    let mut by_number = PhoneNumber::new();
    by_number.set_country_code(375);
    by_number.set_national_number(8123);
    let mut test_number = phone_util.parse("8123", "BY").unwrap();
    assert_eq!(by_number, test_number);

    by_number.set_national_number(81234);
    test_number = phone_util.parse("81234", "BY").unwrap();
    assert_eq!(by_number, test_number);

    // Префикс не удаляется, так как ввод является валидным 6-значным номером,
    // в то время как результат удаления - всего 5 цифр.
    by_number.set_national_number(812345);
    test_number = phone_util.parse("812345", "BY").unwrap();
    assert_eq!(by_number, test_number);

    // Префикс удаляется, так как возможны только 6-значные номера.
    by_number.set_national_number(123456);
    test_number = phone_util.parse("8123456", "BY").unwrap();
    assert_eq!(by_number, test_number);
}

#[test]
fn parse_extensions() {
    let phone_util = get_phone_util();

    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    nz_number.set_extension("3456".to_string());

    let mut test_number = phone_util.parse("03 331 6005 ext 3456", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03 331 6005x3456", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03-331 6005 int.3456", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03 331 6005 #3456", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Тестируем, что следующие номера не извлекают добавочные номера:
    let mut non_extn_number = PhoneNumber::new();
    non_extn_number.set_country_code(1);
    non_extn_number.set_national_number(80074935247);

    test_number = phone_util.parse("1800 six-flags", "US").unwrap();
    assert_eq!(non_extn_number, test_number);

    test_number = phone_util.parse("1800 SIX-FLAGS", "US").unwrap();
    assert_eq!(non_extn_number, test_number);

    test_number = phone_util.parse("0~0 1800 7493 5247", "PL").unwrap();
    assert_eq!(non_extn_number, test_number);

    test_number = phone_util.parse("(1800) 7493.5247", "US").unwrap();
    assert_eq!(non_extn_number, test_number);

    // Проверяем, что соответствует последний экземпляр токена расширения.
    let mut extn_number = PhoneNumber::new();
    extn_number.set_country_code(1);
    extn_number.set_national_number(80074935247);
    extn_number.set_extension("1234".to_string());
    test_number = phone_util.parse("0~0 1800 7493 5247 ~1234", "PL").unwrap();
    assert_eq!(extn_number, test_number);

    // Проверяем исправление ошибки, когда последняя цифра номера ранее опускалась,
    // если это был 0 при извлечении расширения. Также проверяем несколько различных
    // случаев расширений.
    let mut uk_number = PhoneNumber::new();
    uk_number.set_country_code(44);
    uk_number.set_national_number(2034567890);
    uk_number.set_extension("456".to_string());

    test_number = phone_util.parse("+44 2034567890x456", "NZ").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890x456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890 x456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890 X456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890 X 456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890 X   456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890 x 456  ", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44 2034567890  X 456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("+44-2034567890;ext=456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    test_number = phone_util.parse("tel:2034567890;ext=456;phone-context=+44", "ZZ").unwrap();
    assert_eq!(uk_number, test_number);

    // Полноширинное расширение, только "extn".
    test_number = phone_util.parse("+442034567890ｅｘｔｎ456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    // Только "xtn".
    test_number = phone_util.parse("+44-2034567890ｘｔｎ456", "GB").unwrap();
    assert_eq!(uk_number, test_number);
    // Только "xt".
    test_number = phone_util.parse("+44-2034567890ｘｔ456", "GB").unwrap();
    assert_eq!(uk_number, test_number);

    let mut us_with_extension = PhoneNumber::new();
    us_with_extension.set_country_code(1);
    us_with_extension.set_national_number(8009013355);
    us_with_extension.set_extension("7246433".to_string());

    test_number = phone_util.parse("(800) 901-3355 x 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 , ext 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 ; 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    // Тестирование символа расширения без окружающих пробелов.
    test_number = phone_util.parse("(800) 901-3355;7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 ,extension 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 ,extensión 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    // Повтор с маленькой буквой o с акутом, созданной с помощью комбинированных символов.
    test_number = phone_util.parse("(800) 901-3355 ,extensión 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 , 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    test_number = phone_util.parse("(800) 901-3355 ext: 7246433", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
    // Тестирование русского расширения "доб" с вариантами, найденными в интернете.
    let mut ru_with_extension = PhoneNumber::new();
    ru_with_extension.set_country_code(7);
    ru_with_extension.set_national_number(4232022511);
    ru_with_extension.set_extension("100".to_string());
    test_number = phone_util.parse("8 (423) 202-25-11, доб. 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    test_number = phone_util.parse("8 (423) 202-25-11 доб. 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    test_number = phone_util.parse("8 (423) 202-25-11, доб 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    test_number = phone_util.parse("8 (423) 202-25-11 доб 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    test_number = phone_util.parse("8 (423) 202-25-11доб 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    // В верхнем регистре
    test_number = phone_util.parse("8 (423) 202-25-11 ДОБ 100", "RU").unwrap();
    assert_eq!(ru_with_extension, test_number);
    
    // Тестируем, что если у номера два расширения, мы игнорируем второе.
    let mut us_with_two_extensions_number = PhoneNumber::new();
    us_with_two_extensions_number.set_country_code(1);
    us_with_two_extensions_number.set_national_number(2121231234);
    us_with_two_extensions_number.set_extension("508".to_string());

    test_number = phone_util.parse("(212)123-1234 x508/x1234", "US").unwrap();
    assert_eq!(us_with_two_extensions_number, test_number);
    test_number = phone_util.parse("(212)123-1234 x508/ x1234", "US").unwrap();
    assert_eq!(us_with_two_extensions_number, test_number);
    test_number = phone_util.parse("(212)123-1234 x508\\x1234", "US").unwrap();
    assert_eq!(us_with_two_extensions_number, test_number);

    // Тестируем парсинг номеров вида (645) 123-1234-910#, где последние 3 цифры
    // перед # - это расширение.
    us_with_extension.clear();
    us_with_extension.set_country_code(1);
    us_with_extension.set_national_number(6451231234);
    us_with_extension.set_extension("910".to_string());
    test_number = phone_util.parse("+1 (645) 123 1234-910#", "US").unwrap();
    assert_eq!(us_with_extension, test_number);
}

#[test]
fn test_parse_handles_long_extensions_with_explicit_labels() {
    let phone_util = get_phone_util();
    // Тестируем верхние и нижние пределы длины добавочного номера для каждого типа метки.
    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    
    // Сначала в формате RFC: ext_limit_after_explicit_label
    nz_number.set_extension("0".to_string());
    let test_number = phone_util.parse("tel:+6433316005;ext=0", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    nz_number.set_extension("01234567890123456789".to_string());
    let test_number = phone_util.parse("tel:+6433316005;ext=01234567890123456789", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Слишком длинное расширение.
    let result = phone_util.parse("tel:+6433316005;ext=012345678901234567890", "NZ");
    assert!(result.is_err());

    // Явная метка расширения: ext_limit_after_explicit_label
    nz_number.set_extension("1".to_string());
    let test_number = phone_util.parse("03 3316005ext:1", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    nz_number.set_extension("12345678901234567890".to_string());
    let test_number = phone_util.parse("03 3316005 xtn:12345678901234567890", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let test_number = phone_util.parse("03 3316005 extension\t12345678901234567890", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let test_number = phone_util.parse("03 3316005 xtensio:12345678901234567890", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let test_number = phone_util.parse("03 3316005 xtensión, 12345678901234567890#", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let test_number = phone_util.parse("03 3316005extension.12345678901234567890", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let test_number = phone_util.parse("03 3316005 доб:12345678901234567890", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    // Слишком длинное расширение.
    let result = phone_util.parse("03 3316005 extension 123456789012345678901", "NZ");
    assert!(result.is_err());
}


#[test]
fn test_parse_handles_long_extensions_with_auto_dialling_labels() {
    let phone_util = get_phone_util();
    // Во-вторых, случаи автодозвона и других стандартных меток добавочных номеров:
    // ext_limit_after_likely_label
    let mut us_number_user_input = PhoneNumber::new();
    us_number_user_input.set_country_code(1);
    us_number_user_input.set_national_number(2679000000);
    us_number_user_input.set_extension("123456789012345".to_string());

    let mut test_number = phone_util.parse("+12679000000,,123456789012345#", "US").unwrap();
    assert_eq!(us_number_user_input, test_number);

    test_number = phone_util.parse("+12679000000;123456789012345#", "US").unwrap();
    assert_eq!(us_number_user_input, test_number);

    let mut uk_number_user_input = PhoneNumber::new();
    uk_number_user_input.set_country_code(44);
    uk_number_user_input.set_national_number(2034000000);
    uk_number_user_input.set_extension("123456789".to_string());

    let test_number = phone_util.parse("+442034000000,,123456789#", "GB").unwrap();
    assert_eq!(uk_number_user_input, test_number);

    // Слишком длинное расширение.
    let result = phone_util.parse("+12679000000,,1234567890123456#", "US");
    assert!(result.is_err());
}

#[test]
fn test_parse_handles_short_extensions_with_ambiguous_char() {
    let phone_util = get_phone_util();
    // В-третьих, для единичных и нестандартных случаев: ext_limit_after_ambiguous_char
    let mut nz_number = PhoneNumber::new();
    nz_number.set_country_code(64);
    nz_number.set_national_number(33316005);
    nz_number.set_extension("123456789".to_string());

    let mut test_number = phone_util.parse("03 3316005 x 123456789", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03 3316005 x. 123456789", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03 3316005 #123456789#", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    test_number = phone_util.parse("03 3316005 ~ 123456789", "NZ").unwrap();
    assert_eq!(nz_number, test_number);

    let result = phone_util.parse("03 3316005 ~ 1234567890", "NZ");
    assert!(result.is_err());
}

#[test]
fn test_parse_handles_short_extensions_when_not_sure_of_label() {
    let phone_util = get_phone_util();
    // В-третьих, когда нет явной метки расширения, но оно обозначено
    // конечным #: ext_limit_when_not_sure
    let mut us_number = PhoneNumber::new();
    us_number.set_country_code(1);
    us_number.set_national_number(1234567890);
    us_number.set_extension("666666".to_string());

    let mut test_number = phone_util.parse("+1123-456-7890 666666#", "US").unwrap();
    assert_eq!(us_number, test_number);

    us_number.set_extension("6".to_string());
    test_number = phone_util.parse("+11234567890-6#", "US").unwrap();
    assert_eq!(us_number, test_number);

    // Слишком длинное расширение.
    let result = phone_util.parse("+1123-456-7890 7777777#", "US");
    assert!(result.is_err());
}

#[test]
fn can_be_internationally_dialled() {
    let phone_util = get_phone_util();
    let mut test_number = PhoneNumber::new();
    test_number.set_country_code(1);

    // Toll-free in test metadata is marked as not internationally diallable.
    test_number.set_national_number(8002530000);
    assert!(!phone_util.can_be_internationally_dialled(&test_number).unwrap());

    // Regular US number.
    test_number.set_national_number(6502530000);
    assert!(phone_util.can_be_internationally_dialled(&test_number).unwrap());

    // No data for NZ, should default to true.
    test_number.set_country_code(64);
    test_number.set_national_number(33316005);
    assert!(phone_util.can_be_internationally_dialled(&test_number).unwrap());
}

#[test]
fn is_alpha_number() {
    let phone_util = get_phone_util();
    assert!(phone_util.is_alpha_number("1800 six-flags"));
    assert!(phone_util.is_alpha_number("1800 six-flags ext. 1234"));
    assert!(phone_util.is_alpha_number("+800 six-flags"));
    assert!(!phone_util.is_alpha_number("1800 123-1234"));
    assert!(!phone_util.is_alpha_number("1 six-flags"));
}