rpdfium_parser/

object.rs

// Derived from PDFium's cpdf_object.h / cpdf_object.cpp
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! PDF object model — ObjectId, StreamData, and the Object enum.

use std::collections::HashMap;

pub use rpdfium_core::error::ObjectId;
use rpdfium_core::{Name, PdfString};

/// Represents the raw (undecoded) data of a PDF stream.
///
/// Stream data is not read or decoded at parse time. Only the byte range
/// within the source data is recorded for later on-demand decoding.
#[derive(Debug, Clone)]
pub enum StreamData {
    /// Undecoded: byte range within source data.
    Raw { offset: u64, length: u64 },
    /// Already decoded/generated data (used by editing operations).
    Decoded { data: Vec<u8> },
}

/// A PDF object value.
///
/// `Object::Reference` holds an unresolved indirect reference — it is **not**
/// recursively resolved at parse time to avoid `OnceLock` deadlocks.
#[derive(Debug, Clone)]
pub enum Object {
    /// The PDF null object.
    Null,
    /// A boolean value.
    Boolean(bool),
    /// An integer number.
    Integer(i64),
    /// A real (floating-point) number.
    Real(f64),
    /// A PDF string (encoding-aware).
    String(PdfString),
    /// A PDF name.
    Name(Name),
    /// An array of objects.
    Array(Vec<Object>),
    /// A dictionary mapping names to objects.
    Dictionary(HashMap<Name, Object>),
    /// A stream object with dictionary metadata and raw data reference.
    Stream {
        dict: HashMap<Name, Object>,
        data: StreamData,
    },
    /// An unresolved indirect reference to another object.
    Reference(ObjectId),
}

impl Object {
    /// Returns the boolean value if this is `Object::Boolean`.
    pub fn as_bool(&self) -> Option<bool> {
        match self {
            Object::Boolean(b) => Some(*b),
            _ => None,
        }
    }

    /// ADR-019 alias for [`as_bool()`](Self::as_bool).
    ///
    /// Corresponds to `CPDF_Object::GetBooleanValue`.
    #[inline]
    pub fn as_boolean(&self) -> Option<bool> {
        self.as_bool()
    }

    /// Returns the integer value if this is `Object::Integer`.
    pub fn as_i64(&self) -> Option<i64> {
        match self {
            Object::Integer(n) => Some(*n),
            _ => None,
        }
    }

    /// Returns the floating-point value if this is `Object::Real` or `Object::Integer`.
    pub fn as_f64(&self) -> Option<f64> {
        match self {
            Object::Real(f) => Some(*f),
            Object::Integer(n) => Some(*n as f64),
            _ => None,
        }
    }

    /// Returns a reference to the `PdfString` if this is `Object::String`.
    pub fn as_string(&self) -> Option<&PdfString> {
        match self {
            Object::String(s) => Some(s),
            _ => None,
        }
    }

    /// Returns a reference to the `Name` if this is `Object::Name`.
    pub fn as_name(&self) -> Option<&Name> {
        match self {
            Object::Name(n) => Some(n),
            _ => None,
        }
    }

    /// Returns a reference to the array if this is `Object::Array`.
    pub fn as_array(&self) -> Option<&[Object]> {
        match self {
            Object::Array(a) => Some(a),
            _ => None,
        }
    }

    /// Returns a reference to the dictionary if this is `Object::Dictionary`.
    pub fn as_dict(&self) -> Option<&HashMap<Name, Object>> {
        match self {
            Object::Dictionary(d) => Some(d),
            _ => None,
        }
    }

    /// ADR-019 alias for [`as_dict()`](Self::as_dict).
    ///
    /// Corresponds to `CPDF_Object::AsDictionary`.
    #[inline]
    pub fn as_dictionary(&self) -> Option<&HashMap<Name, Object>> {
        self.as_dict()
    }

    /// Returns a reference to the stream dictionary if this is `Object::Stream`.
    pub fn as_stream_dict(&self) -> Option<&HashMap<Name, Object>> {
        match self {
            Object::Stream { dict, .. } => Some(dict),
            _ => None,
        }
    }

    /// Returns the `ObjectId` if this is `Object::Reference`.
    pub fn as_reference(&self) -> Option<ObjectId> {
        match self {
            Object::Reference(id) => Some(*id),
            _ => None,
        }
    }

    /// Returns a mutable reference to the dictionary if this is `Object::Dictionary`.
    pub fn as_dict_mut(&mut self) -> Option<&mut HashMap<Name, Object>> {
        match self {
            Object::Dictionary(d) => Some(d),
            _ => None,
        }
    }

    /// Returns a mutable reference to the array if this is `Object::Array`.
    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Object>> {
        match self {
            Object::Array(a) => Some(a),
            _ => None,
        }
    }

    /// Returns `true` if this is `Object::Null`.
    pub fn is_null(&self) -> bool {
        matches!(self, Object::Null)
    }

    /// Returns `true` if this is `Object::Reference`.
    pub fn is_reference(&self) -> bool {
        matches!(self, Object::Reference(_))
    }

    /// Returns `true` if this is `Object::Boolean`.
    ///
    /// Corresponds to `CPDF_Object::IsBoolean()` in PDFium.
    pub fn is_boolean(&self) -> bool {
        matches!(self, Object::Boolean(_))
    }

    /// Returns `true` if this is `Object::Integer` or `Object::Real`.
    ///
    /// Corresponds to `CPDF_Object::IsNumber()` in PDFium.
    pub fn is_number(&self) -> bool {
        matches!(self, Object::Integer(_) | Object::Real(_))
    }

    /// Returns `true` if this is `Object::String`.
    ///
    /// Corresponds to `CPDF_Object::IsString()` in PDFium.
    pub fn is_string(&self) -> bool {
        matches!(self, Object::String(_))
    }

    /// Returns `true` if this is `Object::Name`.
    ///
    /// Corresponds to `CPDF_Object::IsName()` in PDFium.
    pub fn is_name(&self) -> bool {
        matches!(self, Object::Name(_))
    }

    /// Returns `true` if this is `Object::Array`.
    ///
    /// Corresponds to `CPDF_Object::IsArray()` in PDFium.
    pub fn is_array(&self) -> bool {
        matches!(self, Object::Array(_))
    }

    /// Returns `true` if this is `Object::Dictionary`.
    ///
    /// Corresponds to `CPDF_Object::IsDictionary()` in PDFium.
    pub fn is_dictionary(&self) -> bool {
        matches!(self, Object::Dictionary(_))
    }

    /// Returns `true` if this is `Object::Stream`.
    ///
    /// Corresponds to `CPDF_Object::IsStream()` in PDFium.
    pub fn is_stream(&self) -> bool {
        matches!(self, Object::Stream { .. })
    }

    /// Upstream-aligned alias for [`Self::as_i64()`].
    ///
    /// Returns the integer value if this is `Object::Integer`.
    /// Corresponds to `CPDF_Object::GetInteger()` in PDFium.
    #[inline]
    pub fn get_integer(&self) -> Option<i64> {
        self.as_i64()
    }

    /// Upstream-aligned alias for [`Self::as_f64()`].
    ///
    /// Returns the numeric value as `f64` for `Object::Real` or `Object::Integer`.
    /// Corresponds to `CPDF_Object::GetNumber()` in PDFium.
    #[inline]
    pub fn get_number(&self) -> Option<f64> {
        self.as_f64()
    }

    /// Upstream-aligned alias for [`Self::as_string()`].
    ///
    /// Returns a reference to the `PdfString` if this is `Object::String`.
    /// Corresponds to `CPDF_Object::GetString()` in PDFium.
    #[inline]
    pub fn get_string(&self) -> Option<&PdfString> {
        self.as_string()
    }

    /// Returns the string value decoded to a UTF-8 `String`, if this is a
    /// `Object::String` or `Object::Name`.
    ///
    /// Corresponds to `CPDF_Object::GetUnicodeText()` in PDFium.
    pub fn unicode_text(&self) -> Option<String> {
        match self {
            Object::String(s) => Some(s.to_string_lossy()),
            Object::Name(n) => Some(n.as_str().to_string()),
            _ => None,
        }
    }

    /// Upstream-aligned alias for [`Self::unicode_text()`].
    ///
    /// Corresponds to `CPDF_Object::GetUnicodeText()` in PDFium.
    #[inline]
    pub fn get_unicode_text(&self) -> Option<String> {
        self.unicode_text()
    }

    // -----------------------------------------------------------------------
    // CPDF_Number-level methods
    // -----------------------------------------------------------------------

    /// Returns `true` if this is `Object::Integer` (a whole number, not real).
    ///
    /// Corresponds to `CPDF_Number::IsInteger()` in PDFium.
    pub fn is_integer(&self) -> bool {
        matches!(self, Object::Integer(_))
    }

    // -----------------------------------------------------------------------
    // CPDF_Reference-level methods
    // -----------------------------------------------------------------------

    /// Returns the object number of the indirect reference if this is
    /// `Object::Reference`.
    ///
    /// Corresponds to `CPDF_Reference::GetRefObjNum()` in PDFium.
    pub fn ref_obj_num(&self) -> Option<u32> {
        match self {
            Object::Reference(id) => Some(id.number),
            _ => None,
        }
    }

    /// Upstream-aligned alias for [`Self::ref_obj_num()`].
    ///
    /// Corresponds to `CPDF_Reference::GetRefObjNum()` in PDFium.
    #[inline]
    pub fn get_ref_obj_num(&self) -> Option<u32> {
        self.ref_obj_num()
    }

    // -----------------------------------------------------------------------
    // CPDF_Stream-level methods
    // -----------------------------------------------------------------------

    /// Returns the raw (encoded) byte size of the stream data if this is
    /// `Object::Stream`.
    ///
    /// - For `StreamData::Raw`, returns the `length` stored at parse time.
    /// - For `StreamData::Decoded`, returns the byte length of the in-memory buffer.
    ///
    /// Corresponds to `CPDF_Stream::GetRawSize()` in PDFium.
    pub fn raw_size(&self) -> Option<u64> {
        match self {
            Object::Stream { data, .. } => match data {
                StreamData::Raw { length, .. } => Some(*length),
                StreamData::Decoded { data } => Some(data.len() as u64),
            },
            _ => None,
        }
    }

    /// Upstream-aligned alias for [`Self::raw_size()`].
    ///
    /// Corresponds to `CPDF_Stream::GetRawSize()` in PDFium.
    #[inline]
    pub fn get_raw_size(&self) -> Option<u64> {
        self.raw_size()
    }

    /// Returns `true` if this stream has a `/Filter` entry in its dictionary.
    ///
    /// Corresponds to `CPDF_Stream::HasFilter()` in PDFium.
    pub fn has_filter(&self) -> bool {
        match self {
            Object::Stream { dict, .. } => dict.contains_key(&Name::filter()),
            _ => false,
        }
    }

    // -----------------------------------------------------------------------
    // CPDF_Array convenience methods
    // -----------------------------------------------------------------------

    /// Returns the number of elements if this is `Object::Array`, otherwise `None`.
    ///
    /// Corresponds to `CPDF_Array::size()` in PDFium.
    pub fn array_len(&self) -> Option<usize> {
        match self {
            Object::Array(a) => Some(a.len()),
            _ => None,
        }
    }

    /// Variant name for [`Self::array_len()`].
    ///
    /// Corresponds to `CPDF_Array::size()` in PDFium, but the exact snake_case
    /// of that method is `size()`, which would be ambiguous on the unified `Object`
    /// type. Use [`array_len()`](Self::array_len) instead.
    #[inline]
    #[deprecated(since = "0.0.0", note = "use `array_len()`")]
    pub fn array_size(&self) -> Option<usize> {
        self.array_len()
    }

    /// Returns `true` if this is an `Object::Array` with no elements.
    ///
    /// Corresponds to `CPDF_Array::IsEmpty()` in PDFium.
    pub fn array_is_empty(&self) -> bool {
        match self {
            Object::Array(a) => a.is_empty(),
            _ => false,
        }
    }

    // -----------------------------------------------------------------------
    // CPDF_Dictionary convenience methods
    // -----------------------------------------------------------------------

    /// Returns the number of key–value pairs if this is `Object::Dictionary`,
    /// otherwise `None`.
    ///
    /// Corresponds to `CPDF_Dictionary::size()` in PDFium.
    pub fn dict_len(&self) -> Option<usize> {
        match self {
            Object::Dictionary(d) => Some(d.len()),
            _ => None,
        }
    }

    /// Variant name for [`Self::dict_len()`].
    ///
    /// Corresponds to `CPDF_Dictionary::size()` in PDFium, but the exact snake_case
    /// of that method is `size()`, which would be ambiguous on the unified `Object`
    /// type. Use [`dict_len()`](Self::dict_len) instead.
    #[inline]
    #[deprecated(since = "0.0.0", note = "use `dict_len()`")]
    pub fn dict_size(&self) -> Option<usize> {
        self.dict_len()
    }

    /// Returns `true` if the dictionary contains `key`.
    ///
    /// Returns `false` for non-dictionary objects.
    ///
    /// Corresponds to `CPDF_Dictionary::KeyExist()` in PDFium.
    pub fn key_exist(&self, key: &Name) -> bool {
        match self {
            Object::Dictionary(d) => d.contains_key(key),
            _ => false,
        }
    }

    /// Returns the list of keys if this is `Object::Dictionary`, otherwise `None`.
    ///
    /// Corresponds to `CPDF_Dictionary::GetKeys()` in PDFium.
    pub fn keys(&self) -> Option<Vec<&Name>> {
        match self {
            Object::Dictionary(d) => Some(d.keys().collect()),
            _ => None,
        }
    }

    /// Upstream-aligned alias for [`Self::keys()`].
    ///
    /// Corresponds to `CPDF_Dictionary::GetKeys()` in PDFium.
    #[inline]
    pub fn get_keys(&self) -> Option<Vec<&Name>> {
        self.keys()
    }

    // -----------------------------------------------------------------------
    // CPDF_Object::GetDict — unified dict accessor
    // -----------------------------------------------------------------------

    /// Returns the dictionary of this object:
    /// - If `Object::Dictionary`, returns the dictionary.
    /// - If `Object::Stream`, returns the stream dictionary.
    /// - Otherwise returns `None`.
    ///
    /// Corresponds to `CPDF_Object::GetDict()` in PDFium.
    pub fn dict(&self) -> Option<&HashMap<Name, Object>> {
        match self {
            Object::Dictionary(d) => Some(d),
            Object::Stream { dict, .. } => Some(dict),
            _ => None,
        }
    }

    /// Upstream-aligned alias for [`Self::dict()`].
    ///
    /// Corresponds to `CPDF_Object::GetDict()` in PDFium.
    #[inline]
    pub fn get_dict(&self) -> Option<&HashMap<Name, Object>> {
        self.dict()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_object_id_display_format() {
        let id = ObjectId::new(42, 0);
        assert_eq!(format!("{}", id), "42 0 R");
    }

    #[test]
    fn test_object_id_equality() {
        let a = ObjectId::new(1, 0);
        let b = ObjectId::new(1, 0);
        let c = ObjectId::new(1, 1);
        assert_eq!(a, b);
        assert_ne!(a, c);
    }

    #[test]
    fn test_object_null() {
        let obj = Object::Null;
        assert!(obj.is_null());
        assert_eq!(obj.as_bool(), None);
        assert_eq!(obj.as_i64(), None);
    }

    #[test]
    fn test_object_boolean() {
        let obj = Object::Boolean(true);
        assert_eq!(obj.as_bool(), Some(true));
        assert_eq!(obj.as_i64(), None);
    }

    #[test]
    fn test_object_integer() {
        let obj = Object::Integer(42);
        assert_eq!(obj.as_i64(), Some(42));
        assert_eq!(obj.as_f64(), Some(42.0));
        assert_eq!(obj.as_bool(), None);
    }

    #[test]
    #[allow(clippy::approx_constant)]
    fn test_object_real() {
        let obj = Object::Real(3.14);
        assert_eq!(obj.as_f64(), Some(3.14));
        assert_eq!(obj.as_i64(), None);
    }

    #[test]
    fn test_object_string() {
        let obj = Object::String(PdfString::from_bytes(b"hello".to_vec()));
        assert!(obj.as_string().is_some());
        assert_eq!(obj.as_string().unwrap().as_bytes(), b"hello");
    }

    #[test]
    fn test_object_name() {
        let obj = Object::Name(Name::from_bytes(b"Type".to_vec()));
        assert!(obj.as_name().is_some());
    }

    #[test]
    fn test_object_array() {
        let obj = Object::Array(vec![Object::Integer(1), Object::Integer(2)]);
        assert_eq!(obj.as_array().unwrap().len(), 2);
    }

    #[test]
    fn test_object_dictionary() {
        let mut dict = HashMap::new();
        dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Catalog".to_vec())),
        );
        let obj = Object::Dictionary(dict);
        assert!(obj.as_dict().is_some());
    }

    #[test]
    fn test_object_stream() {
        let dict = HashMap::new();
        let data = StreamData::Raw {
            offset: 0,
            length: 100,
        };
        let obj = Object::Stream { dict, data };
        assert!(obj.as_stream_dict().is_some());
    }

    #[test]
    fn test_object_reference() {
        let id = ObjectId::new(5, 0);
        let obj = Object::Reference(id);
        assert!(obj.is_reference());
        assert_eq!(obj.as_reference(), Some(id));
    }

    #[test]
    fn test_object_unicode_text() {
        let str_obj = Object::String(PdfString::from_bytes(b"hello".to_vec()));
        assert_eq!(str_obj.unicode_text(), Some("hello".to_string()));
        assert_eq!(str_obj.get_unicode_text(), Some("hello".to_string()));

        let name_obj = Object::Name(Name::from("Foo"));
        assert_eq!(name_obj.unicode_text(), Some("Foo".to_string()));

        let int_obj = Object::Integer(42);
        assert_eq!(int_obj.unicode_text(), None);
    }

    #[test]
    fn test_object_get_aliases_delegate_to_as_methods() {
        let int_obj = Object::Integer(99);
        assert_eq!(int_obj.get_integer(), Some(99));
        assert_eq!(int_obj.get_number(), Some(99.0));
        assert_eq!(int_obj.get_string(), None);
        assert_eq!(int_obj.as_name(), None);

        let real_obj = Object::Real(3.14);
        assert_eq!(real_obj.get_number(), Some(3.14));
        assert_eq!(real_obj.get_integer(), None);

        let str_obj = Object::String(PdfString::from_bytes(b"hello".to_vec()));
        assert!(str_obj.get_string().is_some());
        assert_eq!(str_obj.get_integer(), None);

        let name_obj = Object::Name(Name::from("Foo"));
        assert!(name_obj.as_name().is_some());
        assert_eq!(name_obj.get_string(), None);
    }

    // ------------------------------------------------------------------
    // Tests for new methods added in ADR-019 audit pass
    // ------------------------------------------------------------------

    #[test]
    fn test_is_integer_distinguishes_integer_from_real() {
        // Only Object::Integer → is_integer() == true
        assert!(Object::Integer(5).is_integer());
        assert!(!Object::Real(5.0).is_integer());
        assert!(!Object::Null.is_integer());
        assert!(!Object::Boolean(true).is_integer());
    }

    #[test]
    fn test_ref_obj_num_and_alias() {
        let id = ObjectId::new(7, 0);
        let obj = Object::Reference(id);
        assert_eq!(obj.ref_obj_num(), Some(7));
        assert_eq!(obj.get_ref_obj_num(), Some(7));

        // Non-reference → None
        assert_eq!(Object::Integer(1).ref_obj_num(), None);
        assert_eq!(Object::Null.get_ref_obj_num(), None);
    }

    #[test]
    fn test_raw_size_and_alias() {
        // Raw stream
        let raw_stream = Object::Stream {
            dict: HashMap::new(),
            data: StreamData::Raw {
                offset: 0,
                length: 42,
            },
        };
        assert_eq!(raw_stream.raw_size(), Some(42));
        assert_eq!(raw_stream.get_raw_size(), Some(42));

        // Decoded stream
        let decoded_stream = Object::Stream {
            dict: HashMap::new(),
            data: StreamData::Decoded {
                data: vec![0u8; 10],
            },
        };
        assert_eq!(decoded_stream.raw_size(), Some(10));
        assert_eq!(decoded_stream.get_raw_size(), Some(10));

        // Non-stream → None
        assert_eq!(Object::Integer(1).raw_size(), None);
    }

    #[test]
    fn test_has_filter_detects_filter_key() {
        let mut dict_with_filter = HashMap::new();
        dict_with_filter.insert(Name::filter(), Object::Name(Name::from("FlateDecode")));
        let stream_with_filter = Object::Stream {
            dict: dict_with_filter,
            data: StreamData::Raw {
                offset: 0,
                length: 0,
            },
        };
        assert!(stream_with_filter.has_filter());

        let stream_without_filter = Object::Stream {
            dict: HashMap::new(),
            data: StreamData::Raw {
                offset: 0,
                length: 0,
            },
        };
        assert!(!stream_without_filter.has_filter());

        // Non-stream → false
        assert!(!Object::Integer(1).has_filter());
    }

    #[test]
    #[allow(deprecated)]
    fn test_array_len_size_is_empty() {
        let arr = Object::Array(vec![Object::Integer(1), Object::Integer(2)]);
        assert_eq!(arr.array_len(), Some(2));
        assert_eq!(arr.array_size(), Some(2));
        assert!(!arr.array_is_empty());

        let empty_arr = Object::Array(vec![]);
        assert_eq!(empty_arr.array_len(), Some(0));
        assert!(empty_arr.array_is_empty());

        // Non-array → None / false
        assert_eq!(Object::Integer(1).array_len(), None);
        assert_eq!(Object::Integer(1).array_size(), None);
        assert!(!Object::Integer(1).array_is_empty());
    }

    #[test]
    #[allow(deprecated)]
    fn test_dict_len_size() {
        let mut map = HashMap::new();
        map.insert(Name::r#type(), Object::Name(Name::from("Page")));
        let dict = Object::Dictionary(map);
        assert_eq!(dict.dict_len(), Some(1));
        assert_eq!(dict.dict_size(), Some(1));

        let empty_dict = Object::Dictionary(HashMap::new());
        assert_eq!(empty_dict.dict_len(), Some(0));

        // Non-dict → None
        assert_eq!(Object::Integer(1).dict_len(), None);
    }

    #[test]
    fn test_key_exist_on_dictionary() {
        let mut map = HashMap::new();
        let type_name = Name::r#type();
        map.insert(type_name.clone(), Object::Name(Name::from("Page")));
        let dict = Object::Dictionary(map);

        assert!(dict.key_exist(&type_name));
        assert!(!dict.key_exist(&Name::from("Missing")));

        // Non-dict → false
        assert!(!Object::Integer(1).key_exist(&type_name));
    }

    #[test]
    fn test_keys_and_get_keys_on_dictionary() {
        let mut map = HashMap::new();
        map.insert(Name::r#type(), Object::Name(Name::from("Page")));
        let dict = Object::Dictionary(map);

        let ks = dict.keys().expect("should return keys for dict");
        assert_eq!(ks.len(), 1);
        let gks = dict.get_keys().expect("get_keys alias should also work");
        assert_eq!(gks.len(), 1);

        // Non-dict → None
        assert!(Object::Integer(1).keys().is_none());
        assert!(Object::Integer(1).get_keys().is_none());
    }

    #[test]
    fn test_dict_method_returns_dict_and_stream_dict() {
        // Object::Dictionary
        let mut map = HashMap::new();
        map.insert(Name::r#type(), Object::Name(Name::from("Page")));
        let dict_obj = Object::Dictionary(map.clone());
        assert!(dict_obj.dict().is_some());
        assert!(dict_obj.get_dict().is_some());

        // Object::Stream
        let stream_obj = Object::Stream {
            dict: map,
            data: StreamData::Raw {
                offset: 0,
                length: 0,
            },
        };
        assert!(stream_obj.dict().is_some());
        assert!(stream_obj.get_dict().is_some());

        // Other variants → None
        assert!(Object::Integer(1).dict().is_none());
        assert!(Object::Null.get_dict().is_none());
    }

    // -----------------------------------------------------------------------
    // Upstream-derived number tests (cpdf_number_unittest.cpp)
    // -----------------------------------------------------------------------

    /// Upstream: TEST(CPDFNumber, WriteToFloat)
    ///
    /// Verifies that float number objects produce correct string representations.
    /// Note: rpdfium's serialization is in rpdfium-edit's serialize_object.
    /// Here we test the Object's numeric accessor methods match expected values.
    #[test]
    fn test_number_float_values() {
        // Integer 0 represented as float
        let n = Object::Real(0.0);
        assert_eq!(n.as_f64(), Some(0.0));
        assert!(n.is_number());
        assert!(!n.is_integer());

        // Float 1.0
        let n = Object::Real(1.0);
        assert_eq!(n.as_f64(), Some(1.0));

        // Float -7.5
        let n = Object::Real(-7.5);
        assert_eq!(n.as_f64(), Some(-7.5));

        // Float with precision loss (38.895285f → 38.895287 in C++)
        let n = Object::Real(38.895285_f64);
        let val = n.as_f64().unwrap();
        assert!((val - 38.895285).abs() < 0.001);

        // Large float (f64::MAX is too large for PDF; test f32::MAX equivalent)
        let n = Object::Real(f32::MAX as f64);
        assert!(n.as_f64().unwrap() > 0.0);

        // Small float (f32::MIN_POSITIVE equivalent)
        let n = Object::Real(f32::MIN_POSITIVE as f64);
        let val = n.as_f64().unwrap();
        assert!(val > 0.0);
        assert!(val < 0.001);
    }

    /// Upstream: TEST(CPDFNumber, WriteToInt)
    ///
    /// Verifies that integer number objects produce correct values.
    #[test]
    fn test_number_integer_values() {
        // Integer 0
        let n = Object::Integer(0);
        assert_eq!(n.as_i64(), Some(0));
        assert!(n.is_integer());
        assert!(n.is_number());

        // Integer 1
        let n = Object::Integer(1);
        assert_eq!(n.as_i64(), Some(1));

        // Negative
        let n = Object::Integer(-99);
        assert_eq!(n.as_i64(), Some(-99));

        // Larger positive
        let n = Object::Integer(1234);
        assert_eq!(n.as_i64(), Some(1234));

        // Larger negative
        let n = Object::Integer(-54321);
        assert_eq!(n.as_i64(), Some(-54321));

        // i32::MAX
        let n = Object::Integer(i32::MAX as i64);
        assert_eq!(n.as_i64(), Some(i32::MAX as i64));
        assert_eq!(n.as_f64(), Some(i32::MAX as f64));

        // i32::MIN
        let n = Object::Integer(i32::MIN as i64);
        assert_eq!(n.as_i64(), Some(i32::MIN as i64));
        assert_eq!(n.as_f64(), Some(i32::MIN as f64));
    }

    // -----------------------------------------------------------------------
    // Upstream-derived dictionary tests (cpdf_dictionary_unittest.cpp)
    // -----------------------------------------------------------------------

    /// Upstream: TEST(DictionaryTest, Iterators)
    ///
    /// Verifies that dictionary iteration yields all key-value pairs and
    /// that the values have the correct types.
    #[test]
    fn test_dictionary_iterators() {
        let mut dict = HashMap::new();
        dict.insert(
            Name::from("the-dictionary"),
            Object::Dictionary(HashMap::new()),
        );
        dict.insert(Name::from("the-array"), Object::Array(vec![]));
        dict.insert(Name::from("the-number"), Object::Integer(42));

        let obj = Object::Dictionary(dict);
        let d = obj.as_dict().unwrap();

        // All three keys should be present
        assert_eq!(d.len(), 3);

        // Verify each key maps to the correct type
        let dict_val = d.get(&Name::from("the-dictionary")).unwrap();
        assert!(dict_val.is_dictionary());

        let arr_val = d.get(&Name::from("the-array")).unwrap();
        assert!(arr_val.is_array());

        let num_val = d.get(&Name::from("the-number")).unwrap();
        assert!(num_val.is_number());
        assert_eq!(num_val.as_i64(), Some(42));

        // Verify iteration covers all entries
        let keys: Vec<&Name> = d.keys().collect();
        assert_eq!(keys.len(), 3);
        assert!(keys.contains(&&Name::from("the-dictionary")));
        assert!(keys.contains(&&Name::from("the-array")));
        assert!(keys.contains(&&Name::from("the-number")));

        // Note: Unlike C++'s std::map (sorted by key), Rust's HashMap has no
        // guaranteed iteration order, so we check membership rather than order.
    }

    // -----------------------------------------------------------------------
    // Tests ported from upstream cpdf_object_unittest.cpp
    // -----------------------------------------------------------------------

    /// Build the set of direct objects matching upstream's PDFObjectsTest fixture.
    fn make_direct_objects() -> Vec<Object> {
        let mut dict = HashMap::new();
        dict.insert(Name::from("bool"), Object::Boolean(false));
        dict.insert(Name::from("num"), Object::Real(0.23));

        let mut stream_dict = HashMap::new();
        stream_dict.insert(
            Name::from("key1"),
            Object::String(PdfString::from_bytes(b" test dict".to_vec())),
        );
        stream_dict.insert(Name::from("key2"), Object::Integer(-1));

        vec![
            Object::Boolean(false),                                           // 0
            Object::Boolean(true),                                            // 1
            Object::Integer(1245),                                            // 2
            Object::Real(9.00345_f64),                                        // 3
            Object::String(PdfString::from_bytes(b"A simple test".to_vec())), // 4
            Object::String(PdfString::from_bytes(b"\t\n".to_vec())),          // 5
            Object::Name(Name::from("space")),                                // 6
            Object::Array(vec![
                Object::Integer(8902),
                Object::Name(Name::from("address")),
            ]), // 7
            Object::Dictionary(dict),                                         // 8
            Object::Stream {
                dict: stream_dict,
                data: StreamData::Decoded {
                    data: b"abcdefghijklmnopqrstuvwxyz".to_vec(),
                },
            }, // 9
            Object::Null,                                                     // 10
        ]
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetType)
    ///
    /// Verify type predicates for all direct object types.
    #[test]
    fn test_pdf_objects_get_type() {
        let objs = make_direct_objects();
        assert!(objs[0].is_boolean());
        assert!(objs[1].is_boolean());
        assert!(objs[2].is_number());
        assert!(objs[2].is_integer());
        assert!(objs[3].is_number());
        assert!(!objs[3].is_integer());
        assert!(objs[4].is_string());
        assert!(objs[5].is_string());
        assert!(objs[6].is_name());
        assert!(objs[7].is_array());
        assert!(objs[8].is_dictionary());
        assert!(objs[9].is_stream());
        assert!(objs[10].is_null());
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetInteger)
    ///
    /// Verify get_integer() for each direct object type.
    #[test]
    fn test_pdf_objects_get_integer() {
        let objs = make_direct_objects();
        assert_eq!(objs[0].get_integer(), None);
        assert_eq!(objs[1].get_integer(), None);
        assert_eq!(objs[2].get_integer(), Some(1245));
        assert_eq!(objs[3].get_integer(), None);
        assert_eq!(objs[4].get_integer(), None);
        assert_eq!(objs[6].get_integer(), None);
        assert_eq!(objs[7].get_integer(), None);
        assert_eq!(objs[8].get_integer(), None);
        assert_eq!(objs[10].get_integer(), None);
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetNumber)
    ///
    /// Verify get_number() for each direct object type.
    #[test]
    fn test_pdf_objects_get_number() {
        let objs = make_direct_objects();
        assert_eq!(objs[0].get_number(), None);
        assert_eq!(objs[2].get_number(), Some(1245.0));
        assert!(objs[3].get_number().is_some());
        assert_eq!(objs[4].get_number(), None);
        assert_eq!(objs[6].get_number(), None);
        assert_eq!(objs[10].get_number(), None);
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetString)
    ///
    /// Verify get_string() for each direct object type.
    #[test]
    fn test_pdf_objects_get_string() {
        let objs = make_direct_objects();
        assert_eq!(objs[0].get_string(), None);
        assert_eq!(objs[1].get_string(), None);
        assert_eq!(objs[2].get_string(), None);
        assert_eq!(objs[3].get_string(), None);
        assert!(objs[4].get_string().is_some());
        assert_eq!(objs[4].get_string().unwrap().as_bytes(), b"A simple test");
        assert!(objs[5].get_string().is_some());
        assert_eq!(objs[5].get_string().unwrap().as_bytes(), b"\t\n");
        assert_eq!(objs[6].get_string(), None);
        assert_eq!(objs[7].get_string(), None);
        assert_eq!(objs[10].get_string(), None);
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetDict)
    ///
    /// Verify dict() for each direct object type.
    #[test]
    fn test_pdf_objects_get_dict() {
        let objs = make_direct_objects();
        assert!(objs[0].dict().is_none());
        assert!(objs[2].dict().is_none());
        assert!(objs[4].dict().is_none());
        assert!(objs[6].dict().is_none());
        assert!(objs[7].dict().is_none());
        assert!(objs[8].dict().is_some());
        assert!(objs[9].dict().is_some());
        assert!(objs[10].dict().is_none());
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetArray)
    ///
    /// Verify as_array() for each direct object type.
    #[test]
    fn test_pdf_objects_get_array() {
        let objs = make_direct_objects();
        assert!(objs[0].as_array().is_none());
        assert!(objs[2].as_array().is_none());
        assert!(objs[4].as_array().is_none());
        assert!(objs[6].as_array().is_none());
        assert!(objs[7].as_array().is_some());
        assert_eq!(objs[7].as_array().unwrap().len(), 2);
        assert!(objs[8].as_array().is_none());
        assert!(objs[9].as_array().is_none());
        assert!(objs[10].as_array().is_none());
    }

    /// Upstream: TEST_F(PDFObjectsTest, IsTypeAndAsType)
    ///
    /// For each object type, verify is_X/as_X predicates and accessors.
    #[test]
    fn test_pdf_objects_is_type_and_as_type() {
        let objs = make_direct_objects();

        for (i, obj) in objs.iter().enumerate() {
            if i <= 1 {
                assert!(obj.is_boolean(), "obj[{i}] should be boolean");
                assert!(obj.as_bool().is_some());
            } else {
                assert!(!obj.is_boolean(), "obj[{i}] should not be boolean");
                assert!(obj.as_bool().is_none());
            }

            if i == 2 || i == 3 {
                assert!(obj.is_number(), "obj[{i}] should be number");
            } else {
                assert!(!obj.is_number(), "obj[{i}] should not be number");
            }

            if i == 4 || i == 5 {
                assert!(obj.is_string(), "obj[{i}] should be string");
                assert!(obj.as_string().is_some());
            } else {
                assert!(!obj.is_string(), "obj[{i}] should not be string");
                assert!(obj.as_string().is_none());
            }

            if i == 6 {
                assert!(obj.is_name(), "obj[{i}] should be name");
                assert!(obj.as_name().is_some());
            } else {
                assert!(!obj.is_name(), "obj[{i}] should not be name");
                assert!(obj.as_name().is_none());
            }

            if i == 7 {
                assert!(obj.is_array(), "obj[{i}] should be array");
                assert!(obj.as_array().is_some());
            } else {
                assert!(!obj.is_array(), "obj[{i}] should not be array");
                assert!(obj.as_array().is_none());
            }

            if i == 8 {
                assert!(obj.is_dictionary(), "obj[{i}] should be dictionary");
                assert!(obj.as_dict().is_some());
            } else {
                assert!(!obj.is_dictionary(), "obj[{i}] should not be dictionary");
                if i != 9 {
                    assert!(obj.as_dict().is_none());
                }
            }

            if i == 9 {
                assert!(obj.is_stream(), "obj[{i}] should be stream");
                assert!(obj.as_stream_dict().is_some());
            } else {
                assert!(!obj.is_stream(), "obj[{i}] should not be stream");
                assert!(obj.as_stream_dict().is_none());
            }

            assert!(!obj.is_reference(), "obj[{i}] should not be reference");
            assert!(obj.as_reference().is_none());
        }
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetDirect)
    ///
    /// Verify that Reference objects hold the correct ObjectId.
    #[test]
    fn test_pdf_objects_reference_deref() {
        let id = ObjectId::new(42, 0);
        let ref_obj = Object::Reference(id);
        assert!(ref_obj.is_reference());
        assert_eq!(ref_obj.as_reference(), Some(id));
        assert_eq!(ref_obj.ref_obj_num(), Some(42));
    }

    // -----------------------------------------------------------------------
    // Tests ported from upstream cpdf_array_unittest.cpp (read-only)
    // -----------------------------------------------------------------------

    /// Upstream: TEST(PDFArrayTest, GetMatrix)
    ///
    /// 6-element float array — verify element access.
    #[test]
    fn test_pdf_array_get_matrix_elements() {
        let elems: Vec<[f64; 6]> = vec![
            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
            [1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
            [2.3, 4.05, 3.0, -2.0, -3.0, 0.0],
            [0.05, 0.1, 0.56, 0.67, 1.34, 99.9],
        ];
        for elem in &elems {
            let arr = Object::Array(elem.iter().map(|&f| Object::Real(f)).collect());
            let items = arr.as_array().unwrap();
            assert_eq!(items.len(), 6);
            for (i, &val) in elem.iter().enumerate() {
                assert_eq!(items[i].as_f64(), Some(val), "mismatch at index {i}");
            }
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetRect)
    ///
    /// 4-element float array — verify element access.
    #[test]
    fn test_pdf_array_get_rect_elements() {
        let elems: Vec<[f64; 4]> = vec![
            [0.0, 0.0, 0.0, 0.0],
            [1.0, 2.0, 5.0, 6.0],
            [2.3, 4.05, -3.0, 0.0],
            [0.05, 0.1, 1.34, 99.9],
        ];
        for elem in &elems {
            let arr = Object::Array(elem.iter().map(|&f| Object::Real(f)).collect());
            let items = arr.as_array().unwrap();
            assert_eq!(items.len(), 4);
            for (i, &val) in elem.iter().enumerate() {
                assert_eq!(items[i].as_f64(), Some(val), "mismatch at index {i}");
            }
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Boolean sub-case
    #[test]
    fn test_pdf_array_get_type_at_boolean() {
        let vals = [true, false, false, true, true];
        let arr = Object::Array(vals.iter().map(|&b| Object::Boolean(b)).collect());
        let items = arr.as_array().unwrap();
        for (i, &expected) in vals.iter().enumerate() {
            assert_eq!(items[i].as_bool(), Some(expected), "bool mismatch at {i}");
            assert_eq!(items[i].as_i64(), None);
            assert_eq!(items[i].as_f64(), None);
            assert!(items[i].as_array().is_none());
            assert!(items[i].as_dict().is_none());
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Integer sub-case
    #[test]
    fn test_pdf_array_get_type_at_integer() {
        let vals: Vec<i64> = vec![10, 0, -345, 2089345456, -1000000000, 567, 93658767];
        let arr = Object::Array(vals.iter().map(|&n| Object::Integer(n)).collect());
        let items = arr.as_array().unwrap();
        for (i, &val) in vals.iter().enumerate() {
            assert_eq!(items[i].as_i64(), Some(val), "int mismatch at {i}");
            assert_eq!(items[i].as_f64(), Some(val as f64), "float mismatch at {i}");
            assert!(items[i].as_array().is_none());
            assert!(items[i].as_dict().is_none());
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Name sub-case
    #[test]
    fn test_pdf_array_get_type_at_name() {
        let vals = [
            "this",
            "adsde$%^",
            "\r\t",
            "\"012",
            ".",
            "EYREW",
            "It is a joke :)",
        ];
        let arr = Object::Array(vals.iter().map(|&s| Object::Name(Name::from(s))).collect());
        let items = arr.as_array().unwrap();
        for (i, &val) in vals.iter().enumerate() {
            let name = items[i].as_name().unwrap();
            assert_eq!(name.as_str().as_ref(), val, "name mismatch at {i}");
            assert_eq!(items[i].as_i64(), None);
            assert_eq!(items[i].as_f64(), None);
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Null sub-case
    #[test]
    fn test_pdf_array_get_type_at_null() {
        let arr = Object::Array(vec![Object::Null, Object::Null, Object::Null]);
        let items = arr.as_array().unwrap();
        for i in 0..3 {
            assert!(items[i].is_null());
            assert_eq!(items[i].as_i64(), None);
            assert_eq!(items[i].as_f64(), None);
            assert!(items[i].as_array().is_none());
            assert!(items[i].as_dict().is_none());
            assert!(items[i].as_string().is_none());
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Mixed array sub-case
    #[test]
    fn test_pdf_array_get_type_at_mixed() {
        let arr = Object::Array(vec![
            Object::Boolean(true),
            Object::Boolean(false),
            Object::Integer(0),
            Object::Integer(-1234),
            Object::Real(2345.0),
            Object::Real(0.05),
            Object::String(PdfString::from_bytes(b"".to_vec())),
            Object::String(PdfString::from_bytes(b"It is a test!".to_vec())),
            Object::Name(Name::from("NAME")),
            Object::Name(Name::from("test")),
            Object::Null,
        ]);
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), 11);
        assert_eq!(items[0].as_bool(), Some(true));
        assert_eq!(items[1].as_bool(), Some(false));
        assert_eq!(items[2].as_i64(), Some(0));
        assert_eq!(items[3].as_i64(), Some(-1234));
        assert_eq!(items[4].as_f64(), Some(2345.0));
        assert_eq!(items[5].as_f64(), Some(0.05));
        assert_eq!(items[6].as_string().unwrap().as_bytes(), b"");
        assert_eq!(items[7].as_string().unwrap().as_bytes(), b"It is a test!");
        assert_eq!(items[8].as_name().unwrap().as_str().as_ref(), "NAME");
        assert_eq!(items[9].as_name().unwrap().as_str().as_ref(), "test");
        assert!(items[10].is_null());
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Array of arrays
    #[test]
    fn test_pdf_array_nested_arrays() {
        let inner: Vec<Object> = (0..3)
            .map(|_| Object::Array((100..103).map(Object::Integer).collect()))
            .collect();
        let arr = Object::Array(inner);
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), 3);
        for i in 0..3 {
            let sub = items[i].as_array().unwrap();
            assert_eq!(sub.len(), 3);
            assert_eq!(sub[0].as_i64(), Some(100));
            assert_eq!(sub[1].as_i64(), Some(101));
            assert_eq!(sub[2].as_i64(), Some(102));
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Dictionary array
    #[test]
    fn test_pdf_array_of_dicts() {
        let inner: Vec<Object> = (0..3)
            .map(|_| {
                let mut d = HashMap::new();
                for j in 0..3i64 {
                    d.insert(
                        Name::from(format!("key{j}").as_str()),
                        Object::Integer(j + 200),
                    );
                }
                Object::Dictionary(d)
            })
            .collect();
        let arr = Object::Array(inner);
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), 3);
        for i in 0..3 {
            let d = items[i].as_dict().unwrap();
            assert_eq!(d.len(), 3);
            assert_eq!(d.get(&Name::from("key0")).unwrap().as_i64(), Some(200));
        }
    }

    /// Upstream: TEST(ArrayTest, Iterator)
    ///
    /// Verify iterating over array elements.
    #[test]
    fn test_pdf_array_iterator() {
        let elems: Vec<i64> = vec![
            -23, -11, 3, 455, 2345877, 0, 7895330, -12564334, 10000, -100000,
        ];
        let arr = Object::Array(elems.iter().map(|&n| Object::Integer(n)).collect());
        let items = arr.as_array().unwrap();
        for (i, item) in items.iter().enumerate() {
            assert_eq!(item.as_i64(), Some(elems[i]), "mismatch at index {i}");
        }
    }

    /// Upstream: TEST_F(PDFObjectsTest, GetNameFor)
    ///
    /// Verify dictionary name/string lookup.
    #[test]
    fn test_pdf_objects_dict_name_for() {
        let mut d = HashMap::new();
        d.insert(Name::from("bool"), Object::Boolean(false));
        d.insert(Name::from("num"), Object::Real(0.23));
        d.insert(
            Name::from("string"),
            Object::String(PdfString::from_bytes(b"ium".to_vec())),
        );
        d.insert(Name::from("name"), Object::Name(Name::from("Pdf")));
        let dict = Object::Dictionary(d);
        let d = dict.as_dict().unwrap();

        // GetNameFor: only returns value for Name entries
        assert_eq!(
            d.get(&Name::from("name"))
                .and_then(|o| o.as_name())
                .map(|n| n.as_str().to_string()),
            Some("Pdf".to_string())
        );
        // bool entry is not a Name
        assert!(
            d.get(&Name::from("bool"))
                .and_then(|o| o.as_name())
                .is_none()
        );
        // Missing key
        assert!(d.get(&Name::from("invalid")).is_none());
    }

    // -----------------------------------------------------------------------
    // Tests ported from upstream cpdf_object_unittest.cpp — additional
    // -----------------------------------------------------------------------

    /// Upstream: TEST_F(PDFObjectsTest, GetUnicodeText)
    ///
    /// Verify unicode_text() returns expected values for each object type.
    /// In upstream, strings and names return their unicode text, streams
    /// return their content as text, and other types return empty.
    /// Note: PdfString bytes are decoded via PDFDocEncoding, so raw bytes
    /// like 0x09 (\t) map to PDFDocEncoding codepoints, not ASCII.
    #[test]
    fn test_pdf_objects_get_unicode_text() {
        let objs = make_direct_objects();
        // Booleans → None
        assert!(objs[0].unicode_text().is_none());
        assert!(objs[1].unicode_text().is_none());
        // Numbers → None
        assert!(objs[2].unicode_text().is_none());
        assert!(objs[3].unicode_text().is_none());
        // String → text (decoded via PDFDocEncoding)
        assert_eq!(objs[4].unicode_text(), Some("A simple test".to_string()));
        // objs[5] is PdfString with bytes [0x09, 0x0A] — decoded via PDFDocEncoding
        assert!(objs[5].unicode_text().is_some());
        // Name → text
        assert_eq!(objs[6].unicode_text(), Some("space".to_string()));
        // Array → None
        assert!(objs[7].unicode_text().is_none());
        // Dictionary → None
        assert!(objs[8].unicode_text().is_none());
        // Null → None
        assert!(objs[10].unicode_text().is_none());
    }

    // -----------------------------------------------------------------------
    // Tests ported from upstream cpdf_array_unittest.cpp — read-only
    // -----------------------------------------------------------------------

    /// Upstream: TEST(ArrayTest, GetBooleanAt)
    ///
    /// Boolean values in an array — verify access by index.
    /// In rpdfium, we don't have GetBooleanAt with default, but we can
    /// check as_bool() on array elements.
    #[test]
    fn test_pdf_array_get_boolean_at() {
        let arr = Object::Array(vec![
            Object::Boolean(true),
            Object::Boolean(false),
            Object::Integer(100),
            Object::Integer(0),
        ]);
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), 4);

        // Boolean true
        assert_eq!(items[0].as_bool(), Some(true));
        // Boolean false
        assert_eq!(items[1].as_bool(), Some(false));
        // Integer 100 is not a boolean
        assert_eq!(items[2].as_bool(), None);
        // Integer 0 is not a boolean
        assert_eq!(items[3].as_bool(), None);
    }

    /// Upstream: TEST(PDFArrayTest, AddNumber)
    ///
    /// Float values in array — verify they round-trip correctly.
    #[test]
    fn test_pdf_array_add_number() {
        let vals: Vec<f64> = vec![1.0, -1.0, 0.0, 0.456734, 12345.54321, 0.5, 1000.0, 0.000045];
        let arr = Object::Array(vals.iter().map(|&f| Object::Real(f)).collect());
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), vals.len());
        for (i, &val) in vals.iter().enumerate() {
            assert!(items[i].is_number());
            assert_eq!(items[i].as_f64(), Some(val), "mismatch at index {i}");
        }
    }

    /// Upstream: TEST(PDFArrayTest, AddInteger)
    ///
    /// Integer values in array — verify they round-trip correctly.
    #[test]
    fn test_pdf_array_add_integer() {
        let vals: Vec<i64> = vec![0, 1, 934435456, 876, 10000, -1, -24354656, -100];
        let arr = Object::Array(vals.iter().map(|&n| Object::Integer(n)).collect());
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), vals.len());
        for (i, &val) in vals.iter().enumerate() {
            assert!(items[i].is_number());
            assert_eq!(items[i].as_i64(), Some(val), "mismatch at index {i}");
        }
    }

    /// Upstream: TEST(PDFArrayTest, AddStringAndName)
    ///
    /// String and Name values in array — verify they round-trip correctly.
    #[test]
    fn test_pdf_array_add_string_and_name() {
        let vals = [
            "",
            "a",
            "ehjhRIOYTTFdfcdnv",
            "122323",
            "$#%^&**",
            " ",
            "This is a test.\r\n",
        ];
        let string_arr = Object::Array(
            vals.iter()
                .map(|&s| Object::String(PdfString::from_bytes(s.as_bytes().to_vec())))
                .collect(),
        );
        let name_arr = Object::Array(vals.iter().map(|&s| Object::Name(Name::from(s))).collect());
        let str_items = string_arr.as_array().unwrap();
        let name_items = name_arr.as_array().unwrap();
        for (i, &val) in vals.iter().enumerate() {
            assert!(str_items[i].is_string(), "string item {i} should be string");
            assert_eq!(
                str_items[i].as_string().unwrap().as_bytes(),
                val.as_bytes(),
                "string mismatch at {i}"
            );
            assert!(name_items[i].is_name(), "name item {i} should be name");
            assert_eq!(
                name_items[i].as_name().unwrap().as_str().as_ref(),
                val,
                "name mismatch at {i}"
            );
        }
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — Float sub-case
    ///
    /// Float values in array — verify accessor behavior.
    #[test]
    fn test_pdf_array_get_type_at_float() {
        let vals: Vec<f64> = vec![
            0.0, 0.0, 10.0, 10.0, 0.0345, 897.34, -2.5, -1.0, -345.0, -0.0,
        ];
        let arr = Object::Array(vals.iter().map(|&f| Object::Real(f)).collect());
        let items = arr.as_array().unwrap();
        assert_eq!(items.len(), vals.len());
        for (i, &val) in vals.iter().enumerate() {
            assert_eq!(items[i].as_f64(), Some(val), "float mismatch at {i}");
            assert!(items[i].as_array().is_none());
            assert!(items[i].as_dict().is_none());
        }
    }

    // Upstream: TEST_F(PDFObjectsTest, KeyForCache)
    //
    // rpdfium does not have a KeyForCache equivalent — objects use ObjectId
    // for cache keys rather than a u64 derived from pointer addresses.
    // Skipped: no rpdfium equivalent.

    /// Upstream: TEST(ArrayTest, Find)
    ///
    /// Find element by value in array.  rpdfium arrays are Vec<Object> and
    /// Object doesn't implement PartialEq, so there's no direct `find()`
    /// method.  We verify the equivalent using iter().position().
    #[test]
    fn test_pdf_array_find() {
        let arr = Object::Array(vec![
            Object::Integer(10),
            Object::Integer(20),
            Object::Integer(30),
        ]);
        let items = arr.as_array().unwrap();

        // Find by value using iterator
        let pos = items.iter().position(|o| o.as_i64() == Some(20));
        assert_eq!(pos, Some(1));

        let pos = items.iter().position(|o| o.as_i64() == Some(99));
        assert_eq!(pos, None);
    }

    /// Upstream: TEST(ArrayTest, Contains)
    ///
    /// Check if array contains element by value.
    #[test]
    fn test_pdf_array_contains() {
        let arr = Object::Array(vec![Object::Integer(10), Object::Integer(20)]);
        let items = arr.as_array().unwrap();
        assert!(items.iter().any(|o| o.as_i64() == Some(10)));
        assert!(items.iter().any(|o| o.as_i64() == Some(20)));
        assert!(!items.iter().any(|o| o.as_i64() == Some(30)));
    }

    /// Upstream: TEST(ArrayTest, SetAtBeyond)
    ///
    /// In upstream, SetNewAt fails when index is out of bounds.
    /// In rpdfium, arrays are Vec<Object> — setting beyond bounds would panic.
    /// This test verifies that valid index access works and documents the
    /// difference.
    #[test]
    fn test_pdf_array_set_at_beyond() {
        let mut arr = vec![Object::Integer(0)];
        // Setting at valid index works
        arr[0] = Object::Integer(42);
        assert_eq!(arr[0].as_i64(), Some(42));
        // Setting at index 1 would panic (out of bounds) — this matches
        // upstream where SetNewAt(1, ...) returns false on a size-1 array.
        assert_eq!(arr.len(), 1);
    }

    /// Upstream: TEST(ArrayTest, InsertAtBeyond)
    ///
    /// In upstream, InsertNewAt fails when index > size.
    /// rpdfium arrays are Vec<Object> — insert panics on out-of-bounds.
    /// Verify valid insertion at end (index == len) works.
    #[test]
    fn test_pdf_array_insert_at_beyond() {
        let mut arr: Vec<Object> = Vec::new();
        // Insert at index 0 (== len) is valid
        arr.insert(0, Object::Integer(0));
        assert_eq!(arr.len(), 1);
        // Insert at index 1 (== len) is valid
        arr.insert(1, Object::Integer(1));
        assert_eq!(arr.len(), 2);
        assert_eq!(arr[0].as_i64(), Some(0));
        assert_eq!(arr[1].as_i64(), Some(1));
    }

    /// Upstream: TEST(PDFArrayTest, GetTypeAt) — String sub-case
    ///
    /// String values in array — verify accessor behavior.
    #[test]
    fn test_pdf_array_get_type_at_string() {
        let vals = [
            "this",
            "adsde$%^",
            "\r\t",
            "\"012",
            ".",
            "EYREW",
            "It is a joke :)",
        ];
        let arr = Object::Array(
            vals.iter()
                .map(|&s| Object::String(PdfString::from_bytes(s.as_bytes().to_vec())))
                .collect(),
        );
        let items = arr.as_array().unwrap();
        for (i, &val) in vals.iter().enumerate() {
            assert_eq!(
                items[i].as_string().unwrap().as_bytes(),
                val.as_bytes(),
                "string mismatch at {i}"
            );
            assert_eq!(items[i].as_i64(), None);
            assert_eq!(items[i].as_f64(), None);
            assert!(items[i].as_array().is_none());
            assert!(items[i].as_dict().is_none());
        }
    }
}