PeriodArray

class pandas::PeriodArray

Extension array type for specialized data storage.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use PeriodArray
PeriodArray obj;
// ... operations ...

Constructors

Signature	Location	Example
PeriodArray(const numpy::NDArray<numpy::int64>& data, const numpy::NDArray<numpy::bool_>& mask, const std::string& freq, bool copy = false)	pd_period_array.h:106	View
PeriodArray(const numpy::NDArray<numpy::int64>& data, const std::string& freq)	pd_period_array.h:122	View
PeriodArray(const std::vector<std::optional<numpy::int64>>& values, const std::string& freq)	pd_period_array.h:164	View
PeriodArray(const std::vector<std::string>& period_strings, const std::string& freq)	pd_period_array.h:184	View

Construction

Signature	Return Type	Location	Example
static PeriodArray from_sequence(const std::vector<std::optional<numpy::int64>>& scalars, const std::string& freq)	static PeriodArray	pd_period_array.h:1059

Indexing / Selection

Signature	Return Type	Location	Example
numpy::int64 at(size_t index) const	numpy::int64	pd_period_array.h:303	View
const numpy::NDArray<numpy::bool_>& mask() const	const numpy::NDArray<numpy::bool_>&	pd_period_array.h:283	View

Data Manipulation

Signature	Return Type	Location	Example
PeriodArray dropna() const	PeriodArray	pd_period_array.h:396	View

Missing Data

Signature	Return Type	Location	Example
PeriodArray fillna(numpy::int64 value) const	PeriodArray	pd_period_array.h:382	View
numpy::NDArray<numpy::bool_> isna() const	numpy::NDArray<numpy::bool_>	pd_period_array.h:332	View
numpy::NDArray<numpy::bool_> notna() const	numpy::NDArray<numpy::bool_>	pd_period_array.h:339	View

Statistics

Signature	Return Type	Location	Example
size_t count() const	size_t	pd_period_array.h:357	View
std::optional<numpy::int64> max() const	std::optional<numpy::int64>	pd_period_array.h:984	View
std::optional<numpy::int64> min() const	std::optional<numpy::int64>	pd_period_array.h:975	View
IntegerArray<numpy::int32> minute() const	IntegerArray<numpy::int32>	pd_period_array.h:563	View

Comparison

Signature	Return Type	Location	Example
size_t len() const	size_t	pd_period_array.h:251	View

Sorting

Signature	Return Type	Location	Example
numpy::NDArray<size_t> argsort(bool ascending = true, const std::string& na_position = "last") const	numpy::NDArray<size_t>	pd_period_array.h:905	View

Combining

Signature	Return Type	Location	Example
static PeriodArray concat(const std::vector<PeriodArray>& arrays)	static PeriodArray	pd_period_array.h:1067	View

Time Series

Signature	Return Type	Location	Example
PeriodArray asfreq(const std::string& new_freq, const std::string& how = "end") const	PeriodArray	pd_period_array.h:675	View
DatetimeArray to_timestamp(const std::string& how = "start") const	DatetimeArray	pd_period_array.h:642	View

I/O

Signature	Return Type	Location	Example
std::string to_string() const	std::string	pd_period_array.h:1104	View

Conversion

Signature	Return Type	Location	Example
PeriodArray copy() const	PeriodArray	pd_period_array.h:350	View

Iteration

Signature	Return Type	Location	Example
DatetimeArray end_time() const	DatetimeArray	pd_period_array.h:666	View

Set Operations

Signature	Return Type	Location	Example
PeriodArray unique() const	PeriodArray	pd_period_array.h:997	View

Type Checking

Signature	Return Type	Location	Example
BooleanArray is_leap_year() const	BooleanArray	pd_period_array.h:619	View
bool is_na(size_t index) const	bool	pd_period_array.h:314	View

Other Methods

Signature	Return Type	Location	Example
std::optional<size_t> argmax() const	std::optional<size_t>	pd_period_array.h:956	View
std::optional<size_t> argmin() const	std::optional<size_t>	pd_period_array.h:937	View
const numpy::NDArray<numpy::int64>& data() const	const numpy::NDArray<numpy::int64>&	pd_period_array.h:276	View
IntegerArray<numpy::int32> day() const	IntegerArray<numpy::int32>	pd_period_array.h:488	View
IntegerArray<numpy::int32> dayofweek() const	IntegerArray<numpy::int32>	pd_period_array.h:505	View
IntegerArray<numpy::int32> dayofyear() const	IntegerArray<numpy::int32>	pd_period_array.h:529	View
IntegerArray<numpy::int32> days_in_month() const	IntegerArray<numpy::int32>	pd_period_array.h:597	View
days_since_epoch_to_date(days, year, month, day)		pd_period_array.h:697
dtype_type dtype() const	dtype_type	pd_period_array.h:209	View
bool empty() const	bool	pd_period_array.h:244	View
std::pair<numpy::NDArray<numpy::int64>, PeriodArray> factorize() const	std::pair<numpy::NDArray<numpy::int64>, PeriodArray>	pd_period_array.h:1023	View
PeriodFrequency freq() const	PeriodFrequency	pd_period_array.h:258	View
std::string freqstr() const	std::string	pd_period_array.h:265	View
bool has_na() const	bool	pd_period_array.h:370	View
IntegerArray<numpy::int32> hour() const	IntegerArray<numpy::int32>	pd_period_array.h:546	View
IntegerArray<numpy::int32> month() const	IntegerArray<numpy::int32>	pd_period_array.h:447	View
size_t nbytes() const	size_t	pd_period_array.h:223	View
constexpr int ndim() const	constexpr int	pd_period_array.h:230	View
numpy::int64 ordinal(size_t index) const	numpy::int64	pd_period_array.h:321	View
ordinal_to_day(data_.getElementAt({i}), freq_)))		pd_period_array.h:496
ordinal_to_dayofweek(data_.getElementAt({i}), freq_)))		pd_period_array.h:513
ordinal_to_dayofyear(data_.getElementAt({i}), freq_)))		pd_period_array.h:537
ordinal_to_hour(data_.getElementAt({i}), freq_)))		pd_period_array.h:554
ordinal_to_minute(data_.getElementAt({i}), freq_)))		pd_period_array.h:571
ordinal_to_month(data_.getElementAt({i}), freq_)))		pd_period_array.h:455
ordinal_to_quarter(data_.getElementAt({i}), freq_)))		pd_period_array.h:438
ordinal_to_second(data_.getElementAt({i}), freq_)))		pd_period_array.h:588
ordinal_to_week(data_.getElementAt({i}), freq_)))		pd_period_array.h:472
ordinal_to_year(data_.getElementAt({i}), freq_)))		pd_period_array.h:421
IntegerArray<numpy::int32> quarter() const	IntegerArray<numpy::int32>	pd_period_array.h:430	View
std::string repr() const	std::string	pd_period_array.h:1126	View
IntegerArray<numpy::int32> second() const	IntegerArray<numpy::int32>	pd_period_array.h:580	View
std::vector<size_t> shape() const	std::vector<size_t>	pd_period_array.h:237	View
size_t size() const	size_t	pd_period_array.h:216	View
DatetimeArray start_time() const	DatetimeArray	pd_period_array.h:659	View
void validate_arrays()	void	pd_period_array.h:66
IntegerArray<numpy::int32> week() const	IntegerArray<numpy::int32>	pd_period_array.h:464	View
IntegerArray<numpy::int32> weekday() const	IntegerArray<numpy::int32>	pd_period_array.h:522	View
IntegerArray<numpy::int32> weekofyear() const	IntegerArray<numpy::int32>	pd_period_array.h:481
IntegerArray<numpy::int32> year() const	IntegerArray<numpy::int32>	pd_period_array.h:413	View

Code Examples

The following examples are extracted from the test suite.

PeriodArray (pd_test_1_all.cpp:2927)

        }

        // Subtract integer
        auto unshifted = shifted - 3;
        auto un0 = unshifted[0];
        if (!un0.has_value() || un0.value() != orig0.value()) {
            std::cout << "  [FAIL] : unshifted should equal original" << std::endl;
            throw std::runtime_error("pd_test_period_array_arithmetic failed: unshift");
        }

        // Subtract PeriodArray (get differences)
        pandas::PeriodArray arr2(std::vector<std::string>{
            "2024-04",
            "2024-03",
            "2024-01"
        }, "M");

        auto diff = arr2 - arr;
        auto d0 = diff[0];
        if (!d0.has_value() || d0.value() != 3) {
            std::cout << "  [FAIL] : diff[0] should be 3 (Apr - Jan)" << std::endl;

PeriodArray (pd_test_1_all.cpp:2927)

        }

        // Subtract integer
        auto unshifted = shifted - 3;
        auto un0 = unshifted[0];
        if (!un0.has_value() || un0.value() != orig0.value()) {
            std::cout << "  [FAIL] : unshifted should equal original" << std::endl;
            throw std::runtime_error("pd_test_period_array_arithmetic failed: unshift");
        }

        // Subtract PeriodArray (get differences)
        pandas::PeriodArray arr2(std::vector<std::string>{
            "2024-04",
            "2024-03",
            "2024-01"
        }, "M");

        auto diff = arr2 - arr;
        auto d0 = diff[0];
        if (!d0.has_value() || d0.value() != 3) {
            std::cout << "  [FAIL] : diff[0] should be 3 (Apr - Jan)" << std::endl;

PeriodArray (pd_test_1_all.cpp:2927)

        }

        // Subtract integer
        auto unshifted = shifted - 3;
        auto un0 = unshifted[0];
        if (!un0.has_value() || un0.value() != orig0.value()) {
            std::cout << "  [FAIL] : unshifted should equal original" << std::endl;
            throw std::runtime_error("pd_test_period_array_arithmetic failed: unshift");
        }

        // Subtract PeriodArray (get differences)
        pandas::PeriodArray arr2(std::vector<std::string>{
            "2024-04",
            "2024-03",
            "2024-01"
        }, "M");

        auto diff = arr2 - arr;
        auto d0 = diff[0];
        if (!d0.has_value() || d0.value() != 3) {
            std::cout << "  [FAIL] : diff[0] should be 3 (Apr - Jan)" << std::endl;

PeriodArray (pd_test_1_all.cpp:2927)

        }

        // Subtract integer
        auto unshifted = shifted - 3;
        auto un0 = unshifted[0];
        if (!un0.has_value() || un0.value() != orig0.value()) {
            std::cout << "  [FAIL] : unshifted should equal original" << std::endl;
            throw std::runtime_error("pd_test_period_array_arithmetic failed: unshift");
        }

        // Subtract PeriodArray (get differences)
        pandas::PeriodArray arr2(std::vector<std::string>{
            "2024-04",
            "2024-03",
            "2024-01"
        }, "M");

        auto diff = arr2 - arr;
        auto d0 = diff[0];
        if (!d0.has_value() || d0.value() != 3) {
            std::cout << "  [FAIL] : diff[0] should be 3 (Apr - Jan)" << std::endl;

at (pd_test_1_all.cpp:6581)

            // Test isna/notna with float data
            {
                std::map<std::string, std::vector<numpy::float64>> float_data;
                float_data["X"] = {1.0, std::nan(""), 3.0};
                float_data["Y"] = {4.0, 5.0, std::nan("")};
                pandas::DataFrame df_na(float_data);

                auto na_mask = df_na.isna();
                // Row 1, col 0 (X) should be NA
                if (!na_mask.getElementAt({1, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (1,0) should be true" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (1,0)");
                }
                // Row 2, col 1 (Y) should be NA
                if (!na_mask.getElementAt({2, 1})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (2,1) should be true" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (2,1)");
                }
                // Row 0, col 0 should NOT be NA
                if (na_mask.getElementAt({0, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (0,0) should be false" << std::endl;

mask (pd_test_1_all.cpp:9119)

void pd_test_datetime_mixin_array_constructor() {
    std::cout << "========= DatetimeTDMixin array constructor =========================";

    // Create DatetimeArray with some values
    numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
    data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
    data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
    data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{3});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));
    mask.setElementAt({2}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeTDMixin idx(arr, "timestamps");

    bool passed = (idx.size() == 3 && !idx.empty() &&
                   idx.name().has_value() && *idx.name() == "timestamps" &&
                   idx.inferred_type() == "datetime");

dropna (pd_test_1_all.cpp:531)

        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");

fillna (pd_test_1_all.cpp:537)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");
        }

        // Test fillna (fill with existing category)
        pandas::CategoricalArray filled = arr.fillna("a");  // 'a' is in categories
        if (filled.has_na()) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : fillna should have no NA" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: fillna should have no NA");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_categorical_array_add_categories() {

isna (pd_test_1_all.cpp:524)

            throw std::runtime_error("pd_test_categorical_array_na_handling failed: has_na() should be true");
        }

        // Test count (non-NA)
        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : count() != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: count() != 2");
        }

        // Test isna array
        numpy::NDArray<numpy::bool_> na_mask = arr.isna();
        if (na_mask.getSize() != 4) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : isna size != 4" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: isna size != 4");
        }

        // Test dropna
        pandas::CategoricalArray dropped = arr.dropna();
        if (dropped.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_na_handling() : dropna size != 2" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_na_handling failed: dropna size != 2");

notna (pd_test_1_all.cpp:6595)

                if (!na_mask.getElementAt({2, 1})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (2,1) should be true" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (2,1)");
                }
                // Row 0, col 0 should NOT be NA
                if (na_mask.getElementAt({0, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : isna at (0,0) should be false" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: isna at (0,0)");
                }

                auto notna_mask = df_na.notna();
                if (notna_mask.getElementAt({1, 0})) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : notna at (1,0) should be false" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: notna at (1,0)");
                }
            }

            // Test fillna
            {
                std::map<std::string, std::vector<numpy::float64>> float_data;
                float_data["X"] = {1.0, std::nan(""), 3.0};

count (pd_test_1_all.cpp:66)

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_boolean_array_kleene_and() {
        std::cout << "========= BooleanArray: Kleene AND ======================= ";

max (pd_test_1_all.cpp:771)

        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");
        }

        // Test unordered throws for min/max
        pandas::CategoricalArray unordered = arr.as_unordered();
        bool threw = false;
        try {
            unordered.min();

min (pd_test_1_all.cpp:764)

    }

    void pd_test_categorical_array_ordered_operations() {
        std::cout << "========= CategoricalArray: ordered operations (min/max) ======================= ";

        std::vector<std::string> cats = {"low", "medium", "high"};
        std::vector<numpy::int32> codes = {0, 2, 1, 0, -1};  // low, high, medium, low, NA
        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");

minute (pd_test_1_all.cpp:7505)

    std::cout << "========= minute property =============================";

    std::vector<std::optional<numpy::datetime64>> values = {
        make_dt(0),                    // Minute 0
        make_dt(30 * NS_PER_MIN),      // Minute 30
        make_dt(59 * NS_PER_MIN)       // Minute 59
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeIndex idx(arr);

    auto minutes = idx.minute();

    bool passed = (minutes.size() == 3);
    auto m0 = minutes[0];
    auto m1 = minutes[1];
    auto m2 = minutes[2];
    passed = passed && m0.has_value() && *m0 == 0;
    passed = passed && m1.has_value() && *m1 == 30;
    passed = passed && m2.has_value() && *m2 == 59;

    if (!passed) {

len (pd_test_3_all.cpp:20867)

    auto title_result = s.str().title();
    if (title_result[0] != "Hello World" || title_result[1] != "Hello World" || title_result[2] != "Hello World") {
        std::cout << "  [FAIL] : title() failed" << std::endl;
        throw std::runtime_error("pd_test_str_capitalize_title: title() failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

// ============================================================================
// Test str().len()
// ============================================================================

void pd_test_str_len() {
    std::cout << "========= Series.str().len() ============================";

    pandas::Series<std::string> s({"a", "bb", "ccc", ""});

    auto lens = s.str().len();
    if (lens[0] != 1 || lens[1] != 2 || lens[2] != 3 || lens[3] != 0) {
        std::cout << "  [FAIL] : len() failed" << std::endl;

argsort (pd_test_1_all.cpp:1304)

        std::cout << "========= DatetimeArray: sorting ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-06-15",
            "NaT",
            "2023-01-01",
            "2023-12-31"
        });

        // argsort ascending
        auto indices = arr.argsort(true, "last");
        // Expected order: 2023-01-01(2), 2023-06-15(0), 2023-12-31(3), NaT(1)
        if (indices.getElementAt({0}) != 2) {
            std::cout << "  [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first");
        }
        if (indices.getElementAt({3}) != 1) {
            std::cout << "  [FAIL] : argsort: last should be index 1 (NaT)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position");
        }

concat (pd_test_1_all.cpp:17717)

}

void pd_test_period_index_concat() {
    std::cout << "========= concat factory ==============================";

    std::vector<int64_t> ordinals1 = {0, 1};
    std::vector<int64_t> ordinals2 = {2, 3};
    pandas::PeriodIndex idx1(ordinals1, "D");
    pandas::PeriodIndex idx2(ordinals2, "D");

    pandas::PeriodIndex concatenated = pandas::PeriodIndex::concat({idx1, idx2});

    bool passed = (concatenated.size() == 4);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_concat()" << std::endl;
        throw std::runtime_error("pd_test_period_index_concat failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

asfreq (pd_test_1_all.cpp:2869)

        std::cout << "========= PeriodArray: asfreq ======================= ";

        // Monthly to quarterly
        pandas::PeriodArray arr_m(std::vector<std::string>{
            "2024-01",
            "2024-04",
            "2024-07",
            "NaT"
        }, "M");

        auto arr_q = arr_m.asfreq("Q");
        if (arr_q.size() != 4) {
            std::cout << "  [FAIL] : asfreq size should be 4" << std::endl;
            throw std::runtime_error("pd_test_period_array_asfreq failed: size");
        }
        if (arr_q.freqstr() != "Q") {
            std::cout << "  [FAIL] : asfreq freqstr should be 'Q'" << std::endl;
            throw std::runtime_error("pd_test_period_array_asfreq failed: freqstr");
        }

        // Check NaT is preserved

to_timestamp (pd_test_1_all.cpp:2830)

    void pd_test_period_array_to_timestamp() {
        std::cout << "========= PeriodArray: to_timestamp ======================= ";

        pandas::PeriodArray arr(std::vector<std::string>{
            "2024-01",
            "2024-06",
            "NaT"
        }, "M");

        // to_timestamp with start
        auto ts_start = arr.to_timestamp("start");
        if (ts_start.size() != 3) {
            std::cout << "  [FAIL] : to_timestamp size should be 3" << std::endl;
            throw std::runtime_error("pd_test_period_array_to_timestamp failed: size");
        }

        auto ts0 = ts_start[0];
        if (!ts0.has_value()) {
            std::cout << "  [FAIL] : ts_start[0] should have value" << std::endl;
            throw std::runtime_error("pd_test_period_array_to_timestamp failed: ts_start[0]");
        }

to_string (pd_test_1_all.cpp:2693)

        pandas::PeriodArray arr_m(std::vector<std::string>{
            "2020-01",
            "NaT",
            "2025-06"
        }, "M");

        // Year
        auto years = arr_m.year();
        auto y0 = years[0];
        if (!y0.has_value() || y0.value() != 2020) {
            std::cout << "  [FAIL] : year[0] should be 2020, got " << (y0.has_value() ? std::to_string(y0.value()) : "NA") << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[0]");
        }

        auto y1 = years[1];
        if (y1.has_value()) {
            std::cout << "  [FAIL] : year[1] should be NA (NaT)" << std::endl;
            throw std::runtime_error("pd_test_period_array_year_month_quarter failed: year[1] should be NA");
        }

        auto y2 = years[2];

copy (pd_test_1_all.cpp:5798)

// ============================================================================
// Copy/Rename Tests
// ============================================================================

void pd_test_categorical_index_copy() {
    std::cout << "========= copy ========================================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    pandas::CategoricalIndex idx(arr, "original");

    pandas::CategoricalIndex copied = idx.copy();

    bool passed = (copied.size() == idx.size() && copied.name() == idx.name() &&
                   copied.categories() == idx.categories() && copied.ordered() == idx.ordered());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_copy()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_copy failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

end_time (pd_test_1_all.cpp:17146)

    std::cout << " -> tests passed" << std::endl;
}

void pd_test_period_index_end_time() {
    std::cout << "========= end_time property ===========================";

    std::vector<int64_t> ordinals = {0};  // 1970-01-01 daily period
    pandas::PeriodIndex idx = pandas::PeriodIndex::from_ordinals(ordinals, "D");

    pandas::DatetimeArray end_times = idx.end_time();

    bool passed = (end_times.size() == 1 && !end_times.is_na(0));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_end_time()" << std::endl;
        throw std::runtime_error("pd_test_period_index_end_time failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

unique (pd_test_1_all.cpp:1345)

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-01-01",
            "2023-06-15",
            "2023-01-01",
            "NaT",
            "2023-06-15",
            "NaT"
        });

        // unique
        auto uniq = arr.unique();
        // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values)
        if (uniq.size() != 3) {
            std::cout << "  [FAIL] : unique size should be 3, got " << uniq.size() << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: size");
        }

        // factorize
        auto [codes, uniques] = arr.factorize();
        // Codes for NaT should be -1
        if (codes.getElementAt({3}) != -1) {

is_leap_year (pd_test_1_all.cpp:1280)

        }

        // is_month_end
        auto me = arr.is_month_end();
        if (!me[1].has_value() || !me[1].value()) {
            std::cout << "  [FAIL] : 2023-03-31 should be month end" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_boolean_props failed: month end");
        }

        // is_leap_year
        auto ly = arr.is_leap_year();
        if (!ly[2].has_value() || !ly[2].value()) {
            std::cout << "  [FAIL] : 2024 should be leap year" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_boolean_props failed: leap year");
        }
        if (!ly[0].has_value() || ly[0].value()) {
            std::cout << "  [FAIL] : 2023 should not be leap year" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_boolean_props failed: not leap year");
        }

        std::cout << " -> tests passed" << std::endl;

is_na (pd_test_1_all.cpp:51)

    void pd_test_boolean_array_na_handling() {
        std::cout << "========= BooleanArray: NA handling ======================= ";

        pandas::BooleanArray arr({
            std::optional<bool>(true),
            std::nullopt,  // NA at index 1
            std::optional<bool>(false)
        });

        if (!arr.is_na(1)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(1) should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(1) should be true");
        }

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {

argmax (pd_test_1_all.cpp:1323)

        }

        // argmin
        auto min_idx = arr.argmin();
        if (!min_idx.has_value() || min_idx.value() != 2) {
            std::cout << "  [FAIL] : argmin should be 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin");
        }

        // argmax
        auto max_idx = arr.argmax();
        if (!max_idx.has_value() || max_idx.value() != 3) {
            std::cout << "  [FAIL] : argmax should be 3 (2023-12-31)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_datetime_array_unique() {
        std::cout << "========= DatetimeArray: unique/factorize ======================= ";

argmin (pd_test_1_all.cpp:1316)

        if (indices.getElementAt({0}) != 2) {
            std::cout << "  [FAIL] : argsort: first should be index 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argsort first");
        }
        if (indices.getElementAt({3}) != 1) {
            std::cout << "  [FAIL] : argsort: last should be index 1 (NaT)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: NaT position");
        }

        // argmin
        auto min_idx = arr.argmin();
        if (!min_idx.has_value() || min_idx.value() != 2) {
            std::cout << "  [FAIL] : argmin should be 2 (2023-01-01)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmin");
        }

        // argmax
        auto max_idx = arr.argmax();
        if (!max_idx.has_value() || max_idx.value() != 3) {
            std::cout << "  [FAIL] : argmax should be 3 (2023-12-31)" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_sorting failed: argmax");

data (pd_test_1_all.cpp:9114)

        throw std::runtime_error("pd_test_datetime_mixin_default_constructor failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

void pd_test_datetime_mixin_array_constructor() {
    std::cout << "========= DatetimeTDMixin array constructor =========================";

    // Create DatetimeArray with some values
    numpy::NDArray<numpy::datetime64> data(std::vector<size_t>{3});
    data.setElementAt({0}, numpy::datetime64(1000000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2001
    data.setElementAt({1}, numpy::datetime64(1500000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2017
    data.setElementAt({2}, numpy::datetime64(1600000000000000000LL, numpy::DateTimeUnit::Nanosecond));  // ~2020

    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{3});
    mask.setElementAt({0}, numpy::bool_(false));
    mask.setElementAt({1}, numpy::bool_(false));
    mask.setElementAt({2}, numpy::bool_(false));

    pandas::DatetimeArray arr(data, mask);

day (pd_test_1_all.cpp:1193)

            std::cout << "  [FAIL] : month[0] should be 3" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: month[0]");
        }
        auto m1 = months[1];
        if (!m1.has_value() || m1.value() != 12) {
            std::cout << "  [FAIL] : month[1] should be 12" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: month[1]");
        }

        // Day
        auto days = arr.day();
        auto d0 = days[0];
        if (!d0.has_value() || d0.value() != 15) {
            std::cout << "  [FAIL] : day[0] should be 15" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: day[0]");
        }
        auto d1 = days[1];
        if (!d1.has_value() || d1.value() != 25) {
            std::cout << "  [FAIL] : day[1] should be 25" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: day[1]");
        }

dayofweek (pd_test_1_all.cpp:7565)

    // 1970-01-01 was a Thursday (day 3)
    std::vector<std::optional<numpy::datetime64>> values = {
        make_dt(0),                // Thursday (3)
        make_dt(NS_PER_DAY),       // Friday (4)
        make_dt(2 * NS_PER_DAY),   // Saturday (5)
        make_dt(3 * NS_PER_DAY)    // Sunday (6)
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeIndex idx(arr);

    auto dow = idx.dayofweek();

    bool passed = (dow.size() == 4);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_index_dayofweek()" << std::endl;
        throw std::runtime_error("pd_test_datetime_index_dayofweek failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

dayofyear (pd_test_3_all.cpp:18582)

    auto seconds = s.dt().second();
    if (seconds[0] != 45 || seconds[1] != 30 || seconds[2] != 59) {
        std::cout << "  [FAIL] : second() failed" << std::endl;
        throw std::runtime_error("pd_test_dt_time_components: second() failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

// ============================================================================
// Test dt().dayofweek(), dt().dayofyear(), dt().quarter()
// ============================================================================

void pd_test_dt_derived_properties() {
    std::cout << "========= Series.dt().dayofweek/dayofyear/quarter() ======";

    // 2020-01-01 is a Wednesday (dayofweek=2), dayofyear=1, Q1
    // 2020-07-04 is a Saturday (dayofweek=5), dayofyear=186, Q3
    pandas::Series<std::string> s({"2020-01-01", "2020-07-04"});

    auto dow = s.dt().dayofweek();

days_in_month (pd_test_1_all.cpp:2766)

            std::cout << "  [FAIL] : day[0] should be 15" << std::endl;
            throw std::runtime_error("pd_test_period_array_day_components failed: day[0]");
        }
        auto d1 = days[1];
        if (!d1.has_value() || d1.value() != 25) {
            std::cout << "  [FAIL] : day[1] should be 25" << std::endl;
            throw std::runtime_error("pd_test_period_array_day_components failed: day[1]");
        }

        // Days in month
        auto dim = arr.days_in_month();
        auto dim0 = dim[0];
        if (!dim0.has_value() || dim0.value() != 31) {
            std::cout << "  [FAIL] : days_in_month[0] should be 31 (March)" << std::endl;
            throw std::runtime_error("pd_test_period_array_day_components failed: days_in_month[0]");
        }
        auto dim1 = dim[1];
        if (!dim1.has_value() || dim1.value() != 31) {
            std::cout << "  [FAIL] : days_in_month[1] should be 31 (December)" << std::endl;
            throw std::runtime_error("pd_test_period_array_day_components failed: days_in_month[1]");
        }

dtype (pd_test_1_all.cpp:295)

            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

        pandas::BooleanArray arr;
        if (arr.dtype().name() != "boolean") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype name should be 'boolean'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype name");
        }

        if (arr.dtype().kind() != "b") {
            std::cout << "  [FAIL] : in pd_test_boolean_array_dtype() : dtype kind should be 'b'" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_dtype failed: dtype kind");
        }

        std::cout << " -> tests passed" << std::endl;

empty (pd_test_1_all.cpp:941)

#include "../pandas/pd_config.h"

namespace dataframe_tests {

namespace dataframe_tests_config {

    void pd_test_config_version() {
        std::cout << "========= df_config: version info ======================= ";
        const char* version = pandas::DataFrameInfo::version();
        if (version == nullptr || std::string(version).empty()) {
            std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl;
            throw std::runtime_error("pd_test_config_version failed: version is null or empty");
        }
        std::cout << "-> tests passed" << std::endl;
    }

    void pd_test_config_na_repr() {
        std::cout << "========= df_config: NA representation ======================= ";
        const char* na_repr = pandas::DataFrameConfig::get_na_repr();
        if (na_repr == nullptr) {

factorize (pd_test_1_all.cpp:1353)

        // unique
        auto uniq = arr.unique();
        // Should have: NaT, 2023-01-01, 2023-06-15 (3 unique values)
        if (uniq.size() != 3) {
            std::cout << "  [FAIL] : unique size should be 3, got " << uniq.size() << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: size");
        }

        // factorize
        auto [codes, uniques] = arr.factorize();
        // Codes for NaT should be -1
        if (codes.getElementAt({3}) != -1) {
            std::cout << "  [FAIL] : factorize: NaT code should be -1" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: NaT code");
        }
        // Same values should have same codes
        if (codes.getElementAt({0}) != codes.getElementAt({2})) {
            std::cout << "  [FAIL] : factorize: 2023-01-01 values should have same code" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_unique failed: same code");
        }

freq (pd_test_1_all.cpp:8233)

    std::cout << "========= freq property ===============================";

    std::vector<std::optional<numpy::datetime64>> values = {
        numpy::datetime64(0LL, numpy::DateTimeUnit::Nanosecond),
        numpy::datetime64(86400000000000LL, numpy::DateTimeUnit::Nanosecond)  // 1 day
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeMixinIndex idx(arr);

    // Default freq is nullopt or inferred
    auto f = idx.freq();
    std::string fs = idx.freqstr();

    bool passed = true;  // freq may or may not be set
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_datetime_mixin_freq()" << std::endl;
        throw std::runtime_error("pd_test_datetime_mixin_freq failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

freqstr (pd_test_1_all.cpp:2671)

        }

        pandas::PeriodDtype dtype_y("Y");
        if (dtype_y.name() != "period[Y]") {
            std::cout << "  [FAIL] : dtype_y.name() should be 'period[Y]'" << std::endl;
            throw std::runtime_error("pd_test_period_array_freq_validation failed: dtype name Y");
        }

        // Test frequency string
        pandas::PeriodArray arr(std::vector<std::string>{"2024-01-15"}, "D");
        if (arr.freqstr() != "D") {
            std::cout << "  [FAIL] : arr.freqstr() should be 'D'" << std::endl;
            throw std::runtime_error("pd_test_period_array_freq_validation failed: freqstr");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_period_array_year_month_quarter() {
        std::cout << "========= PeriodArray: year/month/quarter components ======================= ";

has_na (pd_test_1_all.cpp:61)

        if (!arr.is_na(1)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(1) should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(1) should be true");
        }

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

        std::cout << " -> tests passed" << std::endl;

hour (pd_test_1_all.cpp:7476)

    std::cout << "========= hour property ===============================";

    std::vector<std::optional<numpy::datetime64>> values = {
        make_dt(0),                    // Hour 0
        make_dt(6 * NS_PER_HOUR),      // Hour 6
        make_dt(23 * NS_PER_HOUR)      // Hour 23
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeIndex idx(arr);

    auto hours = idx.hour();

    bool passed = (hours.size() == 3);
    auto h0 = hours[0];
    auto h1 = hours[1];
    auto h2 = hours[2];
    passed = passed && h0.has_value() && *h0 == 0;
    passed = passed && h1.has_value() && *h1 == 6;
    passed = passed && h2.has_value() && *h2 == 23;

    if (!passed) {

month (pd_test_1_all.cpp:1180)

    void pd_test_datetime_array_component_month_day() {
        std::cout << "========= DatetimeArray: month/day components ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-03-15",
            "2023-12-25",
            "NaT"
        });

        // Month
        auto months = arr.month();
        auto m0 = months[0];
        if (!m0.has_value() || m0.value() != 3) {
            std::cout << "  [FAIL] : month[0] should be 3" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: month[0]");
        }
        auto m1 = months[1];
        if (!m1.has_value() || m1.value() != 12) {
            std::cout << "  [FAIL] : month[1] should be 12" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_month_day failed: month[1]");
        }

nbytes (pd_test_1_all.cpp:6214)

            }

            // Test empty DataFrame
            pandas::DataFrame empty_df;
            if (!empty_df.empty()) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : should be empty" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: should be empty");
            }

            // Test nbytes > 0 for non-empty
            if (df.nbytes() == 0) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : nbytes should be > 0" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: nbytes should be > 0");
            }

            // Test columns index
            if (df.columns().size() != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : columns size != 3" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: columns size != 3");
            }

ndim (pd_test_1_all.cpp:6195)

            pandas::DataFrame df(data);

            // Test shape
            auto shape = df.shape();
            if (shape.size() != 2 || shape[0] != 4 || shape[1] != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : shape mismatch" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: shape mismatch");
            }

            // Test ndim
            if (df.ndim() != 2) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : ndim != 2" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: ndim != 2");
            }

            // Test empty
            if (df.empty()) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : should not be empty" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: should not be empty");
            }

ordinal (pd_test_5_all.cpp:41796)

    std::cout << "----- case_11_period_nat_sentinel_api_self_check -----\n";
    pandas::Period nat1 = pandas::Period::NaT("D");
    pandas::Period nat2;  // default ctor = NaT
    pandas::Period real(123, std::string("D"));

    pandas_tests::check(nat1.isNaT(), "case11.NaT_factory_isNaT", local_fail);
    pandas_tests::check(nat2.isNaT(),
                        "case11.default_ctor_isNaT", local_fail);
    pandas_tests::check(!real.isNaT(),
                        "case11.real_period_is_NOT_NaT", local_fail);
    pandas_tests::check(nat1.ordinal() == pandas::PERIOD_NAT,
                        "case11.NaT_ordinal_equals_PERIOD_NAT_sentinel", local_fail);
    pandas_tests::check(real.ordinal() == 123,
                        "case11.real_period_ordinal_value", local_fail);

    std::cout << "  NaT.ordinal=" << nat1.ordinal()
              << " PERIOD_NAT=" << pandas::PERIOD_NAT
              << " real.ordinal=" << real.ordinal() << "\n";
}

void case_12_period_oracle_parity_subset(int& local_fail) {

quarter (pd_test_1_all.cpp:1218)

    void pd_test_datetime_array_quarter() {
        std::cout << "========= DatetimeArray: quarter ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2023-01-15",  // Q1
            "2023-05-20",  // Q2
            "2023-09-10",  // Q3
            "2023-11-25"   // Q4
        });

        auto quarters = arr.quarter();

        auto q0 = quarters[0];
        if (!q0.has_value() || q0.value() != 1) {
            std::cout << "  [FAIL] : quarter[0] should be 1" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_quarter failed: quarter[0]");
        }
        auto q1 = quarters[1];
        if (!q1.has_value() || q1.value() != 2) {
            std::cout << "  [FAIL] : quarter[1] should be 2" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_quarter failed: quarter[1]");

repr (pd_test_1_all.cpp:10906)

    std::cout << " -> tests passed" << std::endl;
}

void pd_test_extension_index_repr() {
    std::cout << "========= repr =========================";

    pandas::CategoricalArray arr({"a", "b", "c"});
    // Use ExtensionIndex<CategoricalArray> directly to test base class repr
    pandas::ExtensionIndex<pandas::CategoricalArray> idx(arr, "test");

    std::string repr_str = idx.repr();

    bool passed = (!repr_str.empty() && repr_str.find("ExtensionIndex") != std::string::npos);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_repr() : repr check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_repr failed");
    }

    std::cout << " -> tests passed" << std::endl;
}

second (pd_test_1_all.cpp:7534)

    std::cout << "========= second property =============================";

    std::vector<std::optional<numpy::datetime64>> values = {
        make_dt(0),                    // Second 0
        make_dt(30 * NS_PER_SEC),      // Second 30
        make_dt(59 * NS_PER_SEC)       // Second 59
    };
    pandas::DatetimeArray arr(values);
    pandas::DatetimeIndex idx(arr);

    auto seconds = idx.second();

    bool passed = (seconds.size() == 3);
    auto s0 = seconds[0];
    auto s1 = seconds[1];
    auto s2 = seconds[2];
    passed = passed && s0.has_value() && *s0 == 0;
    passed = passed && s1.has_value() && *s1 == 30;
    passed = passed && s2.has_value() && *s2 == 59;

    if (!passed) {

shape (pd_test_1_all.cpp:6188)

            std::cout << "========= properties =======================";

            std::map<std::string, std::vector<numpy::float64>> data;
            data["A"] = {1.0, 2.0, 3.0, 4.0};
            data["B"] = {5.0, 6.0, 7.0, 8.0};
            data["C"] = {9.0, 10.0, 11.0, 12.0};

            pandas::DataFrame df(data);

            // Test shape
            auto shape = df.shape();
            if (shape.size() != 2 || shape[0] != 4 || shape[1] != 3) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : shape mismatch" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: shape mismatch");
            }

            // Test ndim
            if (df.ndim() != 2) {
                std::cout << "  [FAIL] : in pd_test_dataframe_properties() : ndim != 2" << std::endl;
                throw std::runtime_error("pd_test_dataframe_properties failed: ndim != 2");
            }

size (pd_test_1_all.cpp:22)

#include "../pandas/pd_boolean_array.h"

namespace dataframe_tests {

namespace dataframe_tests_boolean_array {
    void pd_test_boolean_array_constructors() {
        std::cout << "========= BooleanArray: constructors ======================= ";

        // Default constructor
        pandas::BooleanArray arr1;
        if (arr1.size() != 0) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
        }

        // Initializer list constructor
        pandas::BooleanArray arr2({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::nullopt,
            std::optional<bool>(true)

start_time (pd_test_1_all.cpp:2848)

            std::cout << "  [FAIL] : ts_start[0] should have value" << std::endl;
            throw std::runtime_error("pd_test_period_array_to_timestamp failed: ts_start[0]");
        }

        auto ts2 = ts_start[2];
        if (ts2.has_value()) {
            std::cout << "  [FAIL] : ts_start[2] should be NaT" << std::endl;
            throw std::runtime_error("pd_test_period_array_to_timestamp failed: ts_start[2]");
        }

        // start_time() alias
        auto start_times = arr.start_time();
        if (start_times.size() != 3) {
            std::cout << "  [FAIL] : start_time size should be 3" << std::endl;
            throw std::runtime_error("pd_test_period_array_to_timestamp failed: start_time size");
        }

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_period_array_asfreq() {

week (pd_test_timestamp_scalar.cpp:406)

      // 2024-06-15 is a Saturday
      pandas::Timestamp ts(2024, 6, 15);

      if (ts.dayofweek() != 5) { pass = false; fail_msg = "2024-06-15 should be Saturday (5)"; }
      if (ts.day_of_week() != 5) { pass = false; fail_msg = "day_of_week alias"; }
      if (ts.dayofyear() != 167) { pass = false; fail_msg = "2024-06-15 should be day 167"; }
      if (ts.day_of_year() != 167) { pass = false; fail_msg = "day_of_year alias"; }
      if (ts.quarter() != 2) { pass = false; fail_msg = "June is Q2"; }
      if (ts.days_in_month() != 30) { pass = false; fail_msg = "June has 30 days"; }

      int week = ts.week();
      if (week < 1 || week > 53) { pass = false; fail_msg = "week should be 1-53"; }

      if (!pass) {
        std::cout << "  [FAIL] : in np_test_timestamp_derived() : " << fail_msg;
        throw std::runtime_error("np_test_timestamp_derived failed: " + fail_msg);
      }

      std::cout << " -> tests passed" << std::endl;
    }

weekday (pd_test_3_all.cpp:1471)

            std::cout << "  [FAIL] date_range 10-arg form: expected size 10, got "
                      << idx.size() << std::endl;
            throw std::runtime_error("date_range 10-arg form regressed");
        }
    }

    std::cout << " -> tests passed" << std::endl;
}

void pd_test_3_all_period_weekday() {
    std::cout << "========= PeriodArray.weekday() ======================";

    // Create a PeriodArray with some dates
    std::vector<std::optional<numpy::int64>> ordinals = {0, 1, 2, 3, 4};  // Days from epoch
    pandas::PeriodArray arr(ordinals, "D");

    pandas::IntegerArray<numpy::int32> weekdays = arr.weekday();

    if (weekdays.size() != 5) {
        std::cout << "  [FAIL] : in pd_test_3_all_period_weekday() : size should be 5" << std::endl;
        throw std::runtime_error("pd_test_3_all_period_weekday failed: size");

year (pd_test_1_all.cpp:1147)

    void pd_test_datetime_array_component_year() {
        std::cout << "========= DatetimeArray: year component ======================= ";

        pandas::DatetimeArray arr(std::vector<std::string>{
            "2020-01-15",
            "NaT",
            "2025-06-20"
        });

        auto years = arr.year();

        auto y0 = years[0];
        if (!y0.has_value() || y0.value() != 2020) {
            std::cout << "  [FAIL] : year[0] should be 2020" << std::endl;
            throw std::runtime_error("pd_test_datetime_array_component_year failed: year[0]");
        }

        auto y1 = years[1];
        if (y1.has_value()) {
            std::cout << "  [FAIL] : year[1] should be NA (NaT)" << std::endl;