//! CSS properties for fonts, such as font-family, font-size, font-weight, and font-style.

//!

//! Also contains `FontRef` (reference-counted handle to parsed font data),

//! `FontMetrics` (OpenType font metrics from head/hhea/os2 tables), and

//! `Panose` (font classification).

use alloc::{

    boxed::Box,

    string::{String, ToString},

    vec::Vec,

};

use core::{

    cmp::Ordering,

    ffi::c_void,

    fmt,

    hash::{Hash, Hasher},

    num::ParseIntError,

    sync::atomic::{AtomicU64, AtomicUsize, Ordering as AtomicOrdering},

};

#[cfg(feature = "parser")]

use crate::props::basic::parse::{strip_quotes, UnclosedQuotesError};

use crate::system::SystemFontType;

use crate::{

    corety::{AzString, U8Vec},

    codegen::format::{FormatAsRustCode, GetHash},

    props::{

        basic::{

            error::{InvalidValueErr, InvalidValueErrOwned},

            pixel::{

                parse_pixel_value, CssPixelValueParseError, CssPixelValueParseErrorOwned,

                PixelValue,

            },

        },

        formatter::PrintAsCssValue,

    },

};

// --- Font Weight ---

/// Represents the `font-weight` property.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleFontWeight {

    Lighter,

    W100,

    W200,

    W300,

    #[default]

    Normal,

    W500,

    W600,

    Bold,

    W800,

    W900,

    Bolder,

}

impl PrintAsCssValue for StyleFontWeight {

        }

}

impl FormatAsRustCode for StyleFontWeight {

        use StyleFontWeight::{Lighter, W100, W200, W300, Normal, W500, W600, Bold, W800, W900, Bolder};

            }

        )

}

// --- Font Style ---

/// Represents the `font-style` property.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleFontStyle {

    #[default]

    Normal,

    Italic,

    Oblique,

}

impl PrintAsCssValue for StyleFontStyle {

        }

}

impl FormatAsRustCode for StyleFontStyle {

        use StyleFontStyle::{Normal, Italic, Oblique};

            }

        )

}

// --- Font Size ---

/// Represents a `font-size` attribute

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct StyleFontSize {

    pub inner: PixelValue,

}

impl Default for StyleFontSize {

}

impl_pixel_value!(StyleFontSize);

impl PrintAsCssValue for StyleFontSize {

}

// --- Font Resource Management ---

/// Callback type for `FontRef` destructor - must be extern "C" for FFI safety

pub type FontRefDestructorCallbackType = extern "C" fn(*mut c_void);

/// `FontRef` is a reference-counted pointer to a parsed font.

/// It holds a *const `c_void` that points to the actual parsed font data

/// (typically a `ParsedFont` from the layout crate).

///

/// The parsed data is managed via atomic reference counting, allowing

/// safe sharing across threads without duplicating the font data.

#[repr(C)]

pub struct FontRef {

    /// Pointer to the parsed font data (e.g., `ParsedFont`)

    pub parsed: *const c_void,

    /// Reference counter for memory management

    pub copies: *const AtomicUsize,

    /// Process-unique, monotonically-assigned identity of this parsed font.

    /// Shared by shallow clones (same font), fresh for each `new`. Used for

    /// `Eq`/`Ord`/`Hash` instead of the `parsed` pointer so that freeing a

    /// font and reusing its heap address can't forge identity — the same

    /// aliasing fix applied to `ImageRef`. (Content-level dedup still uses the

    /// separate content hash via `font_ref_get_hash`.)

    pub id: u64,

    /// Whether to run the destructor on drop

    pub run_destructor: bool,

    /// Destructor function for the parsed data

    pub parsed_destructor: FontRefDestructorCallbackType,

}

/// Never-reused source of [`FontRef::id`]. Starts at 1 so `id == 0` can flag

/// an un-initialised / raw-reconstructed handle.

static FONT_REF_ID_COUNTER: AtomicU64 = AtomicU64::new(1);

#[must_use]

impl fmt::Debug for FontRef {

        } else {

        }

}

impl FontRef {

    /// Create a new `FontRef` from parsed font data

    ///

    /// # Arguments

    /// * `parsed` - Pointer to parsed font data (e.g., `Arc::into_raw(Arc::new(ParsedFont))`)

    /// * `destructor` - Function to clean up the parsed data

    /// Get a raw pointer to the parsed font data

    #[inline]

}

impl_option!(

    FontRef,

    OptionFontRef,

    copy = false,

    [Debug, Clone, PartialEq, Eq, Hash]

);

unsafe impl Send for FontRef {}

unsafe impl Sync for FontRef {}

// Identity is the never-reused `id`, NOT the `parsed` pointer (which is freed

// when the last ref drops and whose address may be reused by a later font).

impl PartialEq for FontRef {

}

impl PartialOrd for FontRef {

}

impl Ord for FontRef {

}

impl Eq for FontRef {}

impl Hash for FontRef {

}

impl Clone for FontRef {

}

impl Drop for FontRef {

}

// --- Font Family ---

/// Represents a `font-family` attribute.

/// 

/// Can be:

/// - `System(AzString)`: A named font family (e.g., "Arial", "Times New Roman")

/// - `SystemType(SystemFontType)`: A semantic system font type (e.g., `system:ui`, `system:monospace`)

/// - `File(AzString)`: A font loaded from a file URL

/// - `Ref(FontRef)`: A reference to a pre-loaded font

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

pub enum StyleFontFamily {

    /// Named font family (e.g., "Arial", "Times New Roman", "monospace")

    System(AzString),

    /// Semantic system font type (e.g., `system:ui`, `system:monospace:bold`)

    /// Resolved at runtime based on platform and accessibility settings

    SystemType(SystemFontType),

    /// Font loaded from a file URL

    File(AzString),

    /// Reference to a pre-loaded font

    Ref(FontRef),

}

impl_option!(

    StyleFontFamily,

    OptionStyleFontFamily,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl StyleFontFamily {

                } else {

                }

            }

        }

    /// The RAW family name, for querying the font backend (fontconfig). Unlike

    /// `as_string()` this does NOT apply CSS serialization — a multi-word name comes

    /// back as `Times New Roman`, not `"Times New Roman"`, since the backend matches on

    /// the bare name and the quotes would corrupt the query.

        }

}

impl_vec!(StyleFontFamily, StyleFontFamilyVec, StyleFontFamilyVecDestructor, StyleFontFamilyVecDestructorType, StyleFontFamilyVecSlice, OptionStyleFontFamily);

impl_vec_clone!(

    StyleFontFamily,

    StyleFontFamilyVec,

    StyleFontFamilyVecDestructor

);

impl_vec_debug!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_eq!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_ord!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_hash!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_partialeq!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_partialord!(StyleFontFamily, StyleFontFamilyVec);

impl PrintAsCssValue for StyleFontFamilyVec {

}

// Formatting to Rust code for StyleFontFamilyVec

impl FormatAsRustCode for StyleFontFamilyVec {

        )

}

// --- PARSERS ---

// -- Font Weight Parser --

#[derive(Clone, PartialEq, Eq)]

pub enum CssFontWeightParseError<'a> {

    InvalidValue(InvalidValueErr<'a>),

    InvalidNumber(ParseIntError),

}

// Formatting to Rust code for StyleFontFamily

impl FormatAsRustCode for StyleFontFamily {

            }

            }

            }

            }

        }

}

impl_debug_as_display!(CssFontWeightParseError<'a>);

impl_display! { CssFontWeightParseError<'a>, {

    InvalidValue(e) => format!("Invalid font-weight keyword: \"{}\"", e.0),

    InvalidNumber(e) => format!("Invalid font-weight number: {}", e),

}}

impl<'a> From<InvalidValueErr<'a>> for CssFontWeightParseError<'a> {

}

impl From<ParseIntError> for CssFontWeightParseError<'_> {

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum CssFontWeightParseErrorOwned {

    InvalidValue(InvalidValueErrOwned),

    InvalidNumber(crate::props::basic::error::ParseIntError),

}

impl CssFontWeightParseError<'_> {

        }

}

impl CssFontWeightParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `font-weight` value.

    }

// -- Font Style Parser --

#[derive(Clone, PartialEq, Eq)]

pub enum CssFontStyleParseError<'a> {

    InvalidValue(InvalidValueErr<'a>),

}

impl_debug_as_display!(CssFontStyleParseError<'a>);

impl_display! { CssFontStyleParseError<'a>, {

    InvalidValue(e) => format!("Invalid font-style: \"{}\"", e.0),

}}

impl_from! { InvalidValueErr<'a>, CssFontStyleParseError::InvalidValue }

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum CssFontStyleParseErrorOwned {

    InvalidValue(InvalidValueErrOwned),

}

impl CssFontStyleParseError<'_> {

        }

}

impl CssFontStyleParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `font-style` value.

    }

// -- Font Size Parser --

#[derive(Clone, PartialEq, Eq)]

pub enum CssStyleFontSizeParseError<'a> {

    PixelValue(CssPixelValueParseError<'a>),

}

impl_debug_as_display!(CssStyleFontSizeParseError<'a>);

impl_display! { CssStyleFontSizeParseError<'a>, {

    PixelValue(e) => format!("Invalid font-size: {}", e),

}}

impl_from! { CssPixelValueParseError<'a>, CssStyleFontSizeParseError::PixelValue }

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum CssStyleFontSizeParseErrorOwned {

    PixelValue(CssPixelValueParseErrorOwned),

}

impl CssStyleFontSizeParseError<'_> {

        }

}

impl CssStyleFontSizeParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `font-size` value.

    Ok(StyleFontSize {

    })

// -- Font Family Parser --

#[derive(PartialEq, Eq, Clone)]

pub enum CssStyleFontFamilyParseError<'a> {

    InvalidStyleFontFamily(&'a str),

    UnclosedQuotes(UnclosedQuotesError<'a>),

}

impl_debug_as_display!(CssStyleFontFamilyParseError<'a>);

impl_display! { CssStyleFontFamilyParseError<'a>, {

    InvalidStyleFontFamily(val) => format!("Invalid font-family: \"{}\"", val),

    UnclosedQuotes(val) => format!("Unclosed quotes in font-family: \"{}\"", val.0),

}}

impl<'a> From<UnclosedQuotesError<'a>> for CssStyleFontFamilyParseError<'a> {

}

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum CssStyleFontFamilyParseErrorOwned {

    InvalidStyleFontFamily(AzString),

    UnclosedQuotes(AzString),

}

impl CssStyleFontFamilyParseError<'_> {

            }

            }

        }

}

impl CssStyleFontFamilyParseErrorOwned {

            }

            }

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `font-family` value.

        // Check for system font type syntax: system:ui, system:monospace:bold, etc.

            // Invalid system font type, fall through to treat as regular font name

    }

// --- Font Metrics ---

use crate::corety::{OptionI16, OptionU16, OptionU32};

/// PANOSE classification values for font identification (10 bytes).

/// See <https://learn.microsoft.com/en-us/typography/opentype/spec/os2#panose>

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub struct Panose {

    pub family_type: u8,

    pub serif_style: u8,

    pub weight: u8,

    pub proportion: u8,

    pub contrast: u8,

    pub stroke_variation: u8,

    pub arm_style: u8,

    pub letterform: u8,

    pub midline: u8,

    pub x_height: u8,

}

impl Panose {

}

/// Font metrics structure containing all font-related measurements from

/// the font file tables (head, hhea, and os/2 tables).

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct FontMetrics {

    // os/2 version 1 table (u32 fields - align 4, placed first)

    pub ul_code_page_range1: OptionU32,

    pub ul_code_page_range2: OptionU32,

    // os/2 table (u32 fields)

    pub ul_unicode_range1: u32,

    pub ul_unicode_range2: u32,

    pub ul_unicode_range3: u32,

    pub ul_unicode_range4: u32,

    pub ach_vend_id: u32,

    // os/2 version 0 table (Option<i16>/Option<u16> - align 2)

    pub s_typo_ascender: OptionI16,

    pub s_typo_descender: OptionI16,

    pub s_typo_line_gap: OptionI16,

    pub us_win_ascent: OptionU16,

    pub us_win_descent: OptionU16,

    // +spec:font-metrics:d3b654 - cap-height and x-height metrics for visual text centering (leading-trim)

    // os/2 version 2 table

    pub sx_height: OptionI16,

    pub s_cap_height: OptionI16,

    pub us_default_char: OptionU16,

    pub us_break_char: OptionU16,

    pub us_max_context: OptionU16,

    // os/2 version 3 table

    pub us_lower_optical_point_size: OptionU16,

    pub us_upper_optical_point_size: OptionU16,

    // head table (u16/i16 - align 2)

    pub units_per_em: u16,

    pub font_flags: u16,

    pub x_min: i16,

    pub y_min: i16,

    pub x_max: i16,

    pub y_max: i16,

    // hhea table

    pub ascender: i16,

    pub descender: i16,

    pub line_gap: i16,

    pub advance_width_max: u16,

    pub min_left_side_bearing: i16,

    pub min_right_side_bearing: i16,

    pub x_max_extent: i16,

    pub caret_slope_rise: i16,

    pub caret_slope_run: i16,

    pub caret_offset: i16,

    pub num_h_metrics: u16,

    // os/2 table (u16/i16 fields)

    pub x_avg_char_width: i16,

    pub us_weight_class: u16,

    pub us_width_class: u16,

    pub fs_type: u16,

    pub y_subscript_x_size: i16,

    pub y_subscript_y_size: i16,

    pub y_subscript_x_offset: i16,

    pub y_subscript_y_offset: i16,

    pub y_superscript_x_size: i16,

    pub y_superscript_y_size: i16,

    pub y_superscript_x_offset: i16,

    pub y_superscript_y_offset: i16,

    pub y_strikeout_size: i16,

    pub y_strikeout_position: i16,

    pub s_family_class: i16,

    pub fs_selection: u16,

    pub us_first_char_index: u16,

    pub us_last_char_index: u16,

    // panose (align 1 - last)

    pub panose: Panose,

}

impl Default for FontMetrics {

}

impl FontMetrics {

    /// Only for testing, zero-sized font, will always return 0 for every metric

    /// (`units_per_em = 1000`)

    /// Returns the ascender value from the hhea table

    /// Returns the descender value from the hhea table

    /// Returns the line gap value from the hhea table

    /// Returns the maximum advance width from the hhea table

    /// Returns the minimum left side bearing from the hhea table

    /// Returns the minimum right side bearing from the hhea table

    /// Returns the `x_min` value from the head table

    /// Returns the `y_min` value from the head table

    /// Returns the `x_max` value from the head table

    /// Returns the `y_max` value from the head table

    /// Returns the maximum extent in the x direction from the hhea table

    /// Returns the average character width from the os/2 table

    /// Returns the subscript x size from the os/2 table

    /// Returns the subscript y size from the os/2 table

    /// Returns the subscript x offset from the os/2 table

    /// Returns the subscript y offset from the os/2 table

    /// Returns the superscript x size from the os/2 table

    /// Returns the superscript y size from the os/2 table

    /// Returns the superscript x offset from the os/2 table

    /// Returns the superscript y offset from the os/2 table

    /// Returns the strikeout size from the os/2 table

    /// Returns the strikeout position from the os/2 table

    /// Returns whether typographic metrics should be used (from `fs_selection` flag)

        // Bit 7 of fs_selection indicates USE_TYPO_METRICS

}

#[cfg(all(test, feature = "parser"))]

mod tests {

    use super::*;

    #[test]

            StyleFontWeight::Normal

        );

            StyleFontWeight::Lighter

        );

            StyleFontWeight::Bolder

        );

    #[test]

    #[test]

    #[test]

            StyleFontStyle::Oblique

        );

            StyleFontStyle::Italic

        );

    #[test]

        );

        );

        );

        );

    #[test]

        // Single unquoted

        );

        // Single quoted

        );

        // Multiple

        );

        );

        // Multiple with quotes and extra whitespace

        );

        );

    #[test]

        use crate::system::SystemFontType;

        // Single system font type

        // System font type with bold variant

        // System font type with italic variant

        // System font type with fallback

        // All system font types

        // Invalid system font type should be parsed as regular font name

    #[test]

        use crate::system::SystemFontType;

        // Test that as_css_str() and from_css_str() are inverses

        }

}

#[cfg(test)]

#[allow(clippy::too_many_lines, clippy::float_cmp)]

mod autotest_generated {

    use std::collections::hash_map::DefaultHasher;

    use super::*;

    use crate::props::basic::{

        error::ParseIntError as CParseIntError, length::SizeMetric,

    };

    fn hash_of<T: Hash>(value: &T) -> u64 {

        let mut hasher = DefaultHasher::new();

        value.hash(&mut hasher);

        hasher.finish()

    }

    /// Leaks nothing: the matching destructor below reconstructs the `Box`.

    fn boxed_font_data(value: u64) -> *const c_void {

        Box::into_raw(Box::new(value)).cast::<c_void>().cast_const()

    }

    extern "C" fn noop_destructor(_ptr: *mut c_void) {}

    // One counter per test: `cargo test` runs tests in parallel within a single

    // process, so a shared counter would race.

    static SINGLE_DTOR_CALLS: AtomicUsize = AtomicUsize::new(0);

    extern "C" fn single_counting_destructor(ptr: *mut c_void) {

        SINGLE_DTOR_CALLS.fetch_add(1, AtomicOrdering::SeqCst);

        if !ptr.is_null() {

            unsafe { drop(Box::from_raw(ptr.cast::<u64>())) };

        }

    }

    static CLONE_DTOR_CALLS: AtomicUsize = AtomicUsize::new(0);

    extern "C" fn clone_counting_destructor(ptr: *mut c_void) {

        CLONE_DTOR_CALLS.fetch_add(1, AtomicOrdering::SeqCst);

        if !ptr.is_null() {

            unsafe { drop(Box::from_raw(ptr.cast::<u64>())) };

        }

    }

    static MANY_DTOR_CALLS: AtomicUsize = AtomicUsize::new(0);

    extern "C" fn many_counting_destructor(ptr: *mut c_void) {

        MANY_DTOR_CALLS.fetch_add(1, AtomicOrdering::SeqCst);

        if !ptr.is_null() {

            unsafe { drop(Box::from_raw(ptr.cast::<u64>())) };

        }

    }

    // ---------------------------------------------------------------------

    // next_font_ref_id (private)

    // ---------------------------------------------------------------------

    #[test]

    fn next_font_ref_id_is_monotonic_and_never_zero() {

        let a = next_font_ref_id();

        let b = next_font_ref_id();

        // `id == 0` is the "un-initialised / raw-reconstructed" sentinel, so the

        // counter must never hand it out.

        assert!(a >= 1, "id 0 is reserved as the null-handle sentinel");

        assert!(b > a, "ids must be strictly increasing ({a} -> {b})");

    }

    // ---------------------------------------------------------------------

    // FontRef::new / FontRef::get_parsed

    // ---------------------------------------------------------------------

    #[test]

    fn font_ref_new_post_construction_invariants() {

        let ptr = boxed_font_data(0xDEAD);

        let font = FontRef::new(ptr, single_counting_destructor);

        assert_eq!(font.get_parsed(), ptr, "get_parsed must return the pointer passed to new()");

        assert!(font.run_destructor);

        assert!(font.id >= 1);

        assert!(!font.copies.is_null());

        assert_eq!(unsafe { (*font.copies).load(AtomicOrdering::SeqCst) }, 1);

        assert_eq!(SINGLE_DTOR_CALLS.load(AtomicOrdering::SeqCst), 0);

        drop(font);

        assert_eq!(

            SINGLE_DTOR_CALLS.load(AtomicOrdering::SeqCst),

            1,

            "the destructor must run exactly once when the last handle drops"

        );

    }

    #[test]

    fn font_ref_new_accepts_null_pointer_without_panicking() {

        let font = FontRef::new(core::ptr::null(), noop_destructor);

        assert!(font.get_parsed().is_null());

        assert!(font.id >= 1);

        // Debug must not choke on a null `parsed`.

        let dbg = format!("{font:?}");

        assert!(dbg.starts_with("FontRef(0x0"), "unexpected Debug output: {dbg}");

        assert!(dbg.contains("copies: 1"), "unexpected Debug output: {dbg}");

    }

    #[test]

    fn font_ref_clone_shares_identity_and_defers_the_destructor() {

        let ptr = boxed_font_data(42);

        let original = FontRef::new(ptr, clone_counting_destructor);

        let copy = original.clone();

        assert_eq!(original, copy, "shallow clones are the same font");

        assert_eq!(original.id, copy.id);

        assert_eq!(hash_of(&original), hash_of(&copy));

        assert_eq!(original.cmp(&copy), Ordering::Equal);

        assert_eq!(original.get_parsed(), copy.get_parsed());

        assert_eq!(unsafe { (*original.copies).load(AtomicOrdering::SeqCst) }, 2);

        drop(copy);

        assert_eq!(

            CLONE_DTOR_CALLS.load(AtomicOrdering::SeqCst),

            0,

            "dropping one of two handles must not free the parsed data"

        );

        drop(original);

        assert_eq!(CLONE_DTOR_CALLS.load(AtomicOrdering::SeqCst), 1);

    }

    #[test]

    fn font_ref_many_clones_run_the_destructor_exactly_once() {

        let ptr = boxed_font_data(7);

        let original = FontRef::new(ptr, many_counting_destructor);

        let clones: Vec<FontRef> = (0..1000).map(|_| original.clone()).collect();

        assert_eq!(unsafe { (*original.copies).load(AtomicOrdering::SeqCst) }, 1001);

        assert!(clones.iter().all(|c| *c == original));

        drop(clones);

        assert_eq!(MANY_DTOR_CALLS.load(AtomicOrdering::SeqCst), 0);

        drop(original);

        assert_eq!(MANY_DTOR_CALLS.load(AtomicOrdering::SeqCst), 1);

    }

    #[test]

    fn font_ref_identity_is_the_id_not_the_pointer() {

        // Two independently-constructed handles over the *same* pointer value must

        // NOT compare equal — that is the whole point of the `id` field (a freed

        // font's heap address can be reused by a later font).

        let a = FontRef::new(core::ptr::null(), noop_destructor);

        let b = FontRef::new(core::ptr::null(), noop_destructor);

        assert_eq!(a.get_parsed(), b.get_parsed(), "same (null) pointer");

        assert_ne!(a, b, "same pointer must not forge identity");

        assert_ne!(a.id, b.id);

        assert_ne!(hash_of(&a), hash_of(&b));

        assert_eq!(a.cmp(&b), Ordering::Less, "ids are handed out in increasing order");

        assert_eq!(a.partial_cmp(&b), Some(Ordering::Less));

    }

    #[test]

    fn font_ref_raw_zero_handle_is_drop_safe() {

        // A handle reconstructed from raw parts (id == 0, no refcount) must not be

        // dereferenced by Debug/Drop.

        let make = || FontRef {

            parsed: core::ptr::null(),

            copies: core::ptr::null(),

            id: 0,

            run_destructor: false,

            parsed_destructor: noop_destructor,

        };

        let raw = make();

        let raw2 = make();

        assert!(raw.get_parsed().is_null());

        assert_eq!(format!("{raw:?}"), "FontRef(0x0)");

        assert_eq!(raw, raw2, "both carry the id==0 sentinel");

        let cloned = raw.clone();

        assert_eq!(cloned.id, 0);

        assert!(cloned.copies.is_null(), "cloning must not allocate a refcount for a raw handle");

        drop(cloned);

        drop(raw2);

        drop(raw); // must not double-free / deref null

    }

    // ---------------------------------------------------------------------

    // StyleFontFamily::as_string

    // ---------------------------------------------------------------------

    #[test]

    fn style_font_family_as_string_quotes_only_when_whitespace_is_present() {

        assert_eq!(StyleFontFamily::System("Arial".into()).as_string(), "Arial");