RangeIndex

class pandas::RangeIndex

Index class for axis labels in pandas data structures.

Example

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

// Create RangeIndex
RangeIndex<int64_t> idx({1, 2, 3}, "my_index");
size_t len = idx.size();

Constructors

Signature	Location	Example
explicit RangeIndex(int64_t stop, const std::optional<std::string>& name = std::nullopt)	pd_range_index.h:103	View
RangeIndex(const RangeIndex& other)	pd_range_index.h:136	View
RangeIndex(RangeIndex&& other) noexcept	pd_range_index.h:145	View

Construction

Signature	Return Type	Location	Example
static RangeIndex from_range(int64_t start, int64_t stop, int64_t step = 1, const std::optional<std::string>& name = std::nullopt)	static RangeIndex	pd_range_index.h:184	View

Indexing / Selection

Signature	Return Type	Location	Example
int64_t at(size_t i) const	int64_t	pd_range_index.h:320	View
numpy::NDArray<numpy::int64> get_indexer(const std::vector<int64_t>& target) const	numpy::NDArray<numpy::int64>	pd_range_index.h:425	View
numpy::NDArray<numpy::int64> get_indexer(const RangeIndex& target) const	numpy::NDArray<numpy::int64>	pd_range_index.h:440	View
numpy::NDArray<numpy::int64> get_indexer_for(const std::vector<int64_t>& target) const	numpy::NDArray<numpy::int64>	pd_range_index.h:1685	View
get_indexer_non_unique(const std::vector<int64_t>& target) const		pd_range_index.h:1695	View
RangeIndex get_level_values(int level) const	RangeIndex	pd_range_index.h:2236	View
RangeIndex get_level_values(const std::string& level_name) const	RangeIndex	pd_range_index.h:2252	View
size_t get_loc(int64_t key) const	size_t	pd_range_index.h:389	View
int64_t get_loc_str(const std::string& key_str) const override	int64_t	pd_range_index.h:399	View
std::optional<size_t> get_loc_string(const std::string& key) const override	std::optional<size_t>	pd_range_index.h:414	View
std::vector<std::optional<std::string>> get_names() const	std::vector<std::optional<std::string>>	pd_range_index.h:2408
size_t get_slice_bound(int64_t label, const std::string& side) const	size_t	pd_range_index.h:1727	View
std::string get_string(size_t i) const	std::string	pd_range_index.h:1295	View
std::string get_value_str(size_t index) const override	std::string	pd_range_index.h:1286	View
Index<numpy::int64> take(const std::vector<size_t>& indices) const	Index<numpy::int64>	pd_range_index.h:512	View
Index<numpy::int64> where(const numpy::NDArray<numpy::bool_>& cond, const std::vector<int64_t>& other) const	Index<numpy::int64>	pd_range_index.h:2036	View

Data Manipulation

Signature	Return Type	Location	Example
std::variant<RangeIndex, Index<numpy::int64>> drop(const std::vector<int64_t>& labels) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:655	View
RangeIndex drop_duplicates(const std::string& keep = "first") const	RangeIndex	pd_range_index.h:1786	View
RangeIndex droplevel(int level = 0) const	RangeIndex	pd_range_index.h:2220	View
RangeIndex dropna() const	RangeIndex	pd_range_index.h:1777	View
std::variant<RangeIndex, Index<numpy::int64>> insert(size_t loc, int64_t item) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:549	View
std::pair<RangeIndex, numpy::NDArray<numpy::int64>> reindex( const RangeIndex& target, const std::string& method = "") const	std::pair<RangeIndex, numpy::NDArray<numpy::int64>>	pd_range_index.h:1935	View
RangeIndex rename(const std::optional<std::string>& new_name) const	RangeIndex	pd_range_index.h:707	View
RangeIndex set_names(const std::optional<std::string>& name) const	RangeIndex	pd_range_index.h:2177	View

Missing Data

Signature	Return Type	Location	Example
RangeIndex fillna(int64_t value) const	RangeIndex	pd_range_index.h:1768	View
numpy::NDArray<numpy::bool_> isna() const	numpy::NDArray<numpy::bool_>	pd_range_index.h:1528	View
numpy::NDArray<numpy::bool_> isnull() const	numpy::NDArray<numpy::bool_>	pd_range_index.h:1541	View
numpy::NDArray<numpy::bool_> notna() const	numpy::NDArray<numpy::bool_>	pd_range_index.h:1549	View
numpy::NDArray<numpy::bool_> notnull() const	numpy::NDArray<numpy::bool_>	pd_range_index.h:1562	View

Statistics

Signature	Return Type	Location	Example
int64_t max() const	int64_t	pd_range_index.h:1090	View
double mean() const	double	pd_range_index.h:1132	View
int64_t min() const	int64_t	pd_range_index.h:1080	View
size_t nunique(bool dropna = true) const	size_t	pd_range_index.h:1606	View
int64_t sum() const	int64_t	pd_range_index.h:1120	View
std::pair<Index<numpy::int64>, numpy::NDArray<numpy::int64>> value_counts( bool normalize = false, bool sort = true, bool ascending = false, bool dropna = true) const	std::pair<Index<numpy::int64>, numpy::NDArray<numpy::int64>>	pd_range_index.h:2416	View

Aggregation

Signature	Return Type	Location	Example
std::unordered_map<GroupT, std::vector<size_t>> groupby( const std::vector<GroupT>& values) const	std::unordered_map<GroupT, std::vector<size_t>>	pd_range_index.h:2271	View

Comparison

Signature	Return Type	Location	Example
bool equals(const RangeIndex& other) const	bool	pd_range_index.h:1255	View

Sorting

Signature	Return Type	Location	Example
numpy::NDArray<numpy::int64> argsort(bool ascending = true) const	numpy::NDArray<numpy::int64>	pd_range_index.h:1147	View
size_t searchsorted(int64_t value, const std::string& side = "left") const	size_t	pd_range_index.h:1355	View
RangeIndex sort_values(bool ascending = true) const	RangeIndex	pd_range_index.h:1168	View

Reshaping

Signature	Return Type	Location	Example
FrameData to_frame(bool index = true, const std::optional<std::string>& name = std::nullopt) const	FrameData	pd_range_index.h:2332	View
RangeIndex transpose() const	RangeIndex	pd_range_index.h:1880	View

Combining

Signature	Return Type	Location	Example
std::variant<RangeIndex, Index<numpy::int64>> append(const RangeIndex& other) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:1054	View
join(const RangeIndex& other, const std::string& how = "left", bool sort = false) const		pd_range_index.h:2066	View

Time Series

Signature	Return Type	Location	Example
std::optional<int64_t> asof(int64_t label) const	std::optional<int64_t>	pd_range_index.h:1620	View
numpy::NDArray<numpy::int64> asof_locs(const std::vector<int64_t>& where) const	numpy::NDArray<numpy::int64>	pd_range_index.h:1665	View
Index<numpy::int64> diff(int64_t periods = 1) const	Index<numpy::int64>	pd_range_index.h:1744	View
std::variant<RangeIndex, Index<numpy::int64>> difference(const RangeIndex& other) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:932	View
Index<numpy::int64> difference(const Index<numpy::int64>& other, bool sort = true) const	Index<numpy::int64>	pd_range_index.h:1036	View
Index<numpy::int64> shift(int64_t periods = 1, int64_t fill_value = 0) const	Index<numpy::int64>	pd_range_index.h:2003	View

I/O

Signature	Return Type	Location	Example
numpy::NDArray<numpy::int64> to_array() const	numpy::NDArray<numpy::int64>	pd_range_index.h:330	View
RangeIndex to_flat_index() const	RangeIndex	pd_range_index.h:1872	View
Index<numpy::int64> to_index() const	Index<numpy::int64>	pd_range_index.h:1341	View
std::vector<int64_t> to_list() const	std::vector<int64_t>	pd_range_index.h:345	View
numpy::NDArray<numpy::int64> to_numpy() const	numpy::NDArray<numpy::int64>	pd_range_index.h:1864	View
SeriesData to_series(const std::optional<RangeIndex>& index = std::nullopt, const std::optional<std::string>& name = std::nullopt) const	SeriesData	pd_range_index.h:2372	View
std::string to_string() const override	std::string	pd_range_index.h:1321	View
std::vector<std::string> to_string_vector() const override	std::vector<std::string>	pd_range_index.h:1273	View
std::vector<int64_t> tolist() const	std::vector<int64_t>	pd_range_index.h:1856	View

Conversion

Signature	Return Type	Location	Example
RangeIndex copy() const	RangeIndex	pd_range_index.h:700	View
RangeIndex infer_objects() const	RangeIndex	pd_range_index.h:1824	View
numpy::NDArray<numpy::int64> view() const	numpy::NDArray<numpy::int64>	pd_range_index.h:1888	View

Set Operations

Signature	Return Type	Location	Example
numpy::NDArray<numpy::bool_> duplicated(const std::string& keep = "first") const	numpy::NDArray<numpy::bool_>	pd_range_index.h:1796	View
std::variant<RangeIndex, Index<numpy::int64>> intersection(const RangeIndex& other) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:868	View
Index<numpy::int64> intersection(const Index<numpy::int64>& other) const	Index<numpy::int64>	pd_range_index.h:1028	View
numpy::NDArray<bool> isin(const std::vector<int64_t>& values) const override	numpy::NDArray<bool>	pd_range_index.h:526	View
std::variant<RangeIndex, Index<numpy::int64>> symmetric_difference(const RangeIndex& other) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:971	View
Index<numpy::int64> symmetric_difference(const Index<numpy::int64>& other, bool sort = true) const	Index<numpy::int64>	pd_range_index.h:1045	View
std::variant<RangeIndex, Index<numpy::int64>> union_(const RangeIndex& other) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:817	View
Index<numpy::int64> unique() const	Index<numpy::int64>	pd_range_index.h:2440	View

Type Checking

Signature	Return Type	Location	Example
bool is_(const RangeIndex& other) const	bool	pd_range_index.h:2190	View
bool is_aligned(int64_t value) const	bool	pd_range_index.h:83
bool is_boolean() const	bool	pd_range_index.h:1468	View
bool is_categorical() const	bool	pd_range_index.h:1476	View
bool is_floating() const	bool	pd_range_index.h:1484	View
bool is_integer() const	bool	pd_range_index.h:1492	View
bool is_interval() const	bool	pd_range_index.h:1500	View
bool is_monotonic_decreasing() const	bool	pd_range_index.h:297	View
bool is_monotonic_increasing() const	bool	pd_range_index.h:290	View
bool is_numeric() const	bool	pd_range_index.h:1508	View
bool is_object() const	bool	pd_range_index.h:1516	View
bool is_range_index() const override	bool	pd_range_index.h:257	View
bool is_unique() const override	bool	pd_range_index.h:262	View

Other Methods

Signature	Return Type	Location	Example
std::variant<RangeIndex, Index<numpy::int64>> abs() const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:786	View
bool all(bool skipna = true) const	bool	pd_range_index.h:1575	View
bool any(bool skipna = true) const	bool	pd_range_index.h:1589	View
size_t argmax() const	size_t	pd_range_index.h:1110	View
size_t argmin() const	size_t	pd_range_index.h:1100	View
size_t cache_memory_usage() const override	size_t	pd_range_index.h:1444
void clear_cache() const override	void	pd_range_index.h:1426	View
std::unique_ptr<IndexBase> clone() const override	std::unique_ptr<IndexBase>	pd_range_index.h:1310	View
size_t compute_size() const	size_t	pd_range_index.h:58
bool contains(int64_t value) const	bool	pd_range_index.h:364	View
bool contains_str(const std::string& key_str) const override	bool	pd_range_index.h:374	View
std::variant<RangeIndex, Index<numpy::int64>> delete_(size_t loc) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:579	View
std::variant<RangeIndex, Index<numpy::int64>> delete_(const std::vector<size_t>& locs) const	std::variant<RangeIndex, Index<numpy::int64>>	pd_range_index.h:605	View
std::string dtype_name() const override	std::string	pd_range_index.h:229	View
bool empty() const override	bool	pd_range_index.h:222	View
std::pair<numpy::NDArray<numpy::int64>, RangeIndex> factorize() const	std::pair<numpy::NDArray<numpy::int64>, RangeIndex>	pd_range_index.h:1408	View
std::vector<std::string> format(const std::string& na_rep = "NaN") const	std::vector<std::string>	pd_range_index.h:1815	View
bool has_cached_values() const override	bool	pd_range_index.h:1435	View
bool has_duplicates() const override	bool	pd_range_index.h:269	View
bool holds_integer() const	bool	pd_range_index.h:1460	View
bool identical(const RangeIndex& other) const	bool	pd_range_index.h:1262	View
bool in_bounds(int64_t value) const	bool	pd_range_index.h:72
std::string inferred_type() const override	std::string	pd_range_index.h:250	View
int64_t item() const	int64_t	pd_range_index.h:1832	View
size_t memory_usage(bool deep = false) const	size_t	pd_range_index.h:1844	View
std::optional<std::string> name() const override	std::optional<std::string>	pd_range_index.h:236	View
name_(other.name_)		pd_range_index.h:138
name_(std::move(other.name_)), cached_array_(std::move(other.cached_array_))		pd_range_index.h:147
size_t nbytes() const override	size_t	pd_range_index.h:283	View
size_t nlevels() const	size_t	pd_range_index.h:2400	View
Index<numpy::int64> putmask(const numpy::NDArray<numpy::bool_>& mask, int64_t value) const	Index<numpy::int64>	pd_range_index.h:1910	View
numpy::NDArray<numpy::int64> ravel() const	numpy::NDArray<numpy::int64>	pd_range_index.h:1896	View
Index<numpy::int64> repeat(size_t repeats) const	Index<numpy::int64>	pd_range_index.h:1948	View
Index<numpy::int64> repeat(const std::vector<size_t>& repeats) const	Index<numpy::int64>	pd_range_index.h:1967	View
std::string repr() const override	std::string	pd_range_index.h:1334	View
RangeIndex result(\*this)	RangeIndex	pd_range_index.h:708	View
RangeIndex round(int decimals = 0) const	RangeIndex	pd_range_index.h:1992	View
void set_name(const std::optional<std::string>& name) override	void	pd_range_index.h:243	View
size_t size() const override	size_t	pd_range_index.h:215	View
RangeIndex slice(size_t start_idx, size_t stop_idx, int64_t step_idx = 1) const	RangeIndex	pd_range_index.h:455	View
std::pair<size_t, size_t> slice_indexer(std::optional<int64_t> start = std::nullopt, std::optional<int64_t> stop = std::nullopt, size_t step = 1) const	std::pair<size_t, size_t>	pd_range_index.h:2201	View
std::pair<size_t, size_t> slice_locs( std::optional<int64_t> start = std::nullopt, std::optional<int64_t> stop = std::nullopt) const	std::pair<size_t, size_t>	pd_range_index.h:476	View
RangeIndex sort(bool ascending = true) const	RangeIndex	pd_range_index.h:2447	View
std::pair<RangeIndex, numpy::NDArray<numpy::int64>> sortlevel( int level = 0, bool ascending = true, bool sort_remaining = true, const std::string& na_position = "first") const	std::pair<RangeIndex, numpy::NDArray<numpy::int64>>	pd_range_index.h:2297	View
int64_t start() const	int64_t	pd_range_index.h:196	View
int64_t step() const	int64_t	pd_range_index.h:206	View
int64_t stop() const	int64_t	pd_range_index.h:201	View
StringMethods<RangeIndex> str() const	StringMethods<RangeIndex>	pd_range_index.h:1303	View
IndexTypeId type_id() const override	IndexTypeId	pd_range_index.h:1314	View

Code Examples

The following examples are extracted from the test suite.

RangeIndex (pd_test_1_all.cpp:18370)

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

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

    void pd_test_range_index_delete() {
        std::cout << "========= delete ====================================== " << std::endl;

        pandas::RangeIndex ri(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        std::cout << "  Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl;

        bool passed = true;

        // ===== Single Element Tests (existing) =====

        // Delete from start preserves range
        std::cout << "  Test 1: Single delete_(0)..." << std::endl;
        auto result1 = ri.delete_(0);
        bool is_ri1 = std::holds_alternative<pandas::RangeIndex>(result1);
        std::cout << "    Type: " << (is_ri1 ? "RangeIndex" : "Index<int64>") << std::endl;

RangeIndex (pd_test_1_all.cpp:18370)

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

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

    void pd_test_range_index_delete() {
        std::cout << "========= delete ====================================== " << std::endl;

        pandas::RangeIndex ri(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        std::cout << "  Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl;

        bool passed = true;

        // ===== Single Element Tests (existing) =====

        // Delete from start preserves range
        std::cout << "  Test 1: Single delete_(0)..." << std::endl;
        auto result1 = ri.delete_(0);
        bool is_ri1 = std::holds_alternative<pandas::RangeIndex>(result1);
        std::cout << "    Type: " << (is_ri1 ? "RangeIndex" : "Index<int64>") << std::endl;

RangeIndex (pd_test_1_all.cpp:18370)

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

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

    void pd_test_range_index_delete() {
        std::cout << "========= delete ====================================== " << std::endl;

        pandas::RangeIndex ri(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        std::cout << "  Created RangeIndex(0, 10) with " << ri.size() << " elements" << std::endl;

        bool passed = true;

        // ===== Single Element Tests (existing) =====

        // Delete from start preserves range
        std::cout << "  Test 1: Single delete_(0)..." << std::endl;
        auto result1 = ri.delete_(0);
        bool is_ri1 = std::holds_alternative<pandas::RangeIndex>(result1);
        std::cout << "    Type: " << (is_ri1 ? "RangeIndex" : "Index<int64>") << std::endl;

from_range (pd_test_1_all.cpp:17986)

            std::cout << "  [FAIL] : full constructor" << std::endl;
            throw std::runtime_error("pd_test_range_index_full_constructor failed");
        }

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

    void pd_test_range_index_from_range() {
        std::cout << "========= from_range factory ========================== ";

        pandas::RangeIndex ri = pandas::RangeIndex::from_range(5, 20, 3, "test");

        bool passed = (ri.size() == 5 &&
                      ri.start() == 5 &&
                      ri.stop() == 20 &&
                      ri.step() == 3 &&
                      ri.name().value() == "test" &&
                      ri[0] == 5 && ri[4] == 17);

        if (!passed) {
            std::cout << "  [FAIL] : from_range factory" << 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;

get_indexer (pd_test_1_all.cpp:10332)

void pd_test_extension_index_get_indexer() {
    std::cout << "========= get_indexer =========================";

    pandas::CategoricalArray arr1({"a", "b", "c", "d"});
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "d", "x"});
    pandas::CategoricalIndex idx2(arr2);

    auto indexer = idx1.get_indexer(idx2);

    bool passed = (indexer.getSize() == 3 &&
                   indexer.getElementAt({0}) == 1 &&
                   indexer.getElementAt({1}) == 3 &&
                   indexer.getElementAt({2}) == -1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_get_indexer() : get_indexer check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_get_indexer failed");
    }

get_indexer (pd_test_1_all.cpp:10332)

void pd_test_extension_index_get_indexer() {
    std::cout << "========= get_indexer =========================";

    pandas::CategoricalArray arr1({"a", "b", "c", "d"});
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "d", "x"});
    pandas::CategoricalIndex idx2(arr2);

    auto indexer = idx1.get_indexer(idx2);

    bool passed = (indexer.getSize() == 3 &&
                   indexer.getElementAt({0}) == 1 &&
                   indexer.getElementAt({1}) == 3 &&
                   indexer.getElementAt({2}) == -1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_get_indexer() : get_indexer check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_get_indexer failed");
    }

get_indexer_for (pd_test_3_all.cpp:716)

// ============================================================================
// Category 6: Index Indexer Methods
// ============================================================================

void pd_test_3_all_index_indexers() {
    std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() ";

    std::vector<std::string> vals = {"a", "b", "c", "d", "e"};
    pandas::Index<std::string> idx(vals);

    // Test get_indexer_for()
    std::vector<std::string> target = {"b", "d", "f"};  // "f" doesn't exist
    numpy::NDArray<numpy::int64> indexer = idx.get_indexer_for(target);
    if (indexer.getSize() != 3) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size");
    }
    // "b" is at index 1
    if (indexer.getElementAt({0}) != 1) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'b' should be at index 1" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: 'b' index");

get_indexer_non_unique (pd_test_3_all.cpp:739)

    if (indexer.getElementAt({1}) != 3) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'd' should be at index 3" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: 'd' index");
    }
    // "f" doesn't exist -> -1
    if (indexer.getElementAt({2}) != -1) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : 'f' should be -1" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: 'f' index");
    }

    // Test get_indexer_non_unique()
    std::vector<std::string> target2 = {"a", "c", "z"};  // "z" doesn't exist
    pandas::Index<std::string> target_idx(target2);
    auto [indexer2, missing] = idx.get_indexer_non_unique(target_idx);

    if (indexer2.getSize() < 2) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_non_unique size too small" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_non_unique size");
    }

    // Test slice_indexer()

get_level_values (pd_test_3_all.cpp:4524)

    }

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

void pd_test_3_all_interval_index_get_level_values_droplevel() {
    std::cout << "========= IntervalIndex.get_level_values/droplevel() ";

    pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30});

    // get_level_values(0) should work
    pandas::IntervalIndex64 level_vals = idx.get_level_values(0);
    if (level_vals.size() != idx.size()) {
        throw std::runtime_error("get_level_values(0) size mismatch");
    }

    // get_level_values(1) should throw
    bool threw = false;
    try {
        idx.get_level_values(1);
    } catch (const std::out_of_range&) {

get_level_values (pd_test_3_all.cpp:4524)

    }

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

void pd_test_3_all_interval_index_get_level_values_droplevel() {
    std::cout << "========= IntervalIndex.get_level_values/droplevel() ";

    pandas::IntervalIndex64 idx = pandas::IntervalIndex64::from_breaks({0, 10, 20, 30});

    // get_level_values(0) should work
    pandas::IntervalIndex64 level_vals = idx.get_level_values(0);
    if (level_vals.size() != idx.size()) {
        throw std::runtime_error("get_level_values(0) size mismatch");
    }

    // get_level_values(1) should throw
    bool threw = false;
    try {
        idx.get_level_values(1);
    } catch (const std::out_of_range&) {

get_loc (pd_test_1_all.cpp:10281)

    bool passed = (idx.contains("apple") && idx.contains("banana") && !idx.contains("grape"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_contains() : contains check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_contains failed");
    }

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

void pd_test_extension_index_get_loc_unique() {
    std::cout << "========= get_loc (unique) =========================";

    pandas::CategoricalArray arr({"apple", "banana", "cherry"});
    pandas::CategoricalIndex idx(arr);

    auto loc_apple = idx.get_loc("apple");
    auto loc_banana = idx.get_loc("banana");
    auto loc_cherry = idx.get_loc("cherry");

    bool passed = (std::holds_alternative<size_t>(loc_apple) && std::get<size_t>(loc_apple) == 0 &&
                   std::get<size_t>(loc_banana) == 1 &&

get_loc_str (pd_test_1_all.cpp:10890)

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

void pd_test_extension_index_contains_str_get_loc_str() {
    std::cout << "========= contains_str/get_loc_str =========================";

    pandas::CategoricalArray arr({"apple", "banana", "cherry"});
    pandas::CategoricalIndex idx(arr);

    bool passed = (idx.contains_str("apple") && !idx.contains_str("grape") &&
                   idx.get_loc_str("banana") == 1 && idx.get_loc_str("grape") == -1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_contains_str_get_loc_str() : contains_str/get_loc_str check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_contains_str_get_loc_str failed");
    }

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

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

get_loc_string (pd_test_3_all.cpp:28108)

        vals.push_back(numpy::timedelta64(ns, numpy::DateTimeUnit::Nanosecond));
    }
    return pandas::TimedeltaArray(vals);
}

void pd_test_getitem_timedelta_str_lookup() {
    std::cout << "  -- pd_test_getitem_timedelta_str_lookup --" << std::endl;
    int fail = 0;
    auto tda = ge_make_tda({1 * GE_NS_PER_DAY, 2 * GE_NS_PER_DAY, 3 * GE_NS_PER_DAY});
    pandas::TimedeltaIndex tdi(tda);
    auto pos = tdi.get_loc_string("2 days");
    if (!pos.has_value()) { std::cout << "    FAIL: '2 days' not found" << std::endl; fail++; }
    else if (*pos != 1) { std::cout << "    FAIL: expected pos=1, got " << *pos << std::endl; fail++; }
    if (fail == 0) std::cout << "    OK" << std::endl;
    if (fail) throw std::runtime_error("pd_test_getitem_timedelta_str_lookup failed");
}

void pd_test_getitem_timedelta_str_not_found() {
    std::cout << "  -- pd_test_getitem_timedelta_str_not_found --" << std::endl;
    int fail = 0;
    auto tda = ge_make_tda({1 * GE_NS_PER_DAY});

get_slice_bound (pd_test_3_all.cpp:3644)

    formatted = idx.format(custom_formatter);

    if (formatted[0] != "val:1") {
        throw std::runtime_error("custom formatter failed");
    }

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

void pd_test_3_all_index_get_slice_bound() {
    std::cout << "========= Index.get_slice_bound() ==================";

    pandas::Index<numpy::int64> idx({10, 20, 30, 40, 50});

    // Exact match, left side
    size_t bound = idx.get_slice_bound(30, "left");
    if (bound != 2) {
        throw std::runtime_error("left bound for 30 should be 2");
    }

    // Exact match, right side

get_string (pd_test_3_all.cpp:27746)

        }
    }

    pandas::Series<numpy::int64> si({10, 20, 30}, "ints");
    auto result2 = si.astype("str");
    auto* str_s2 = dynamic_cast<pandas::Series<std::string>*>(result2.get());
    if (!str_s2) {
        std::cout << "    FAIL: expected Series<string> from int" << std::endl;
        fail++;
    } else {
        if (str_s2->get_string(0) != "10") {
            std::cout << "    FAIL: expected '10', got '" << str_s2->get_string(0) << "'" << std::endl;
            fail++;
        }
    }

    if (fail == 0) std::cout << "    OK" << std::endl;
}

void pd_test_astype_datetime_to_string() {
    std::cout << "  -- pd_test_astype_datetime_to_string --" << std::endl;

get_value_str (pd_test_1_all.cpp:4665)

            auto corr_df = df.corr();

            // Check dimensions
            bool passed = corr_df.nrows() == 2 && corr_df.ncols() == 2;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_corr() : corr should be 2x2" << std::endl;
                throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: corr should be 2x2");
            }

            // Diagonal should be 1.0
            std::string aa = corr_df["A"].get_value_str(0);
            passed = std::abs(std::stod(aa) - 1.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_aggregation_dataframe_corr() : diagonal should be 1.0" << std::endl;
                throw std::runtime_error("pd_test_aggregation_dataframe_corr failed: diagonal should be 1.0");
            }

            // A-B correlation should be 1.0 (perfect correlation)
            std::string ab = corr_df["B"].get_value_str(0);
            passed = std::abs(std::stod(ab) - 1.0) < 0.001;
            if (!passed) {

take (pd_test_1_all.cpp:5903)

// Inherited Operations Tests
// ============================================================================

void pd_test_categorical_index_take() {
    std::cout << "========= inherited take ==============================";

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

    std::vector<size_t> indices = {0, 2, 3};
    pandas::ExtensionIndex<pandas::CategoricalArray> taken = idx.take(indices);

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

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

where (pd_test_1_all.cpp:22018)

            data["B"] = {5.0, 6.0, 7.0, 8.0};
            pandas::DataFrame df(data);

            // Create condition DataFrame (values > 2)
            std::map<std::string, std::vector<numpy::bool_>> cond_data;
            cond_data["A"] = {false, false, true, true};   // 1<=2, 2<=2, 3>2, 4>2
            cond_data["B"] = {true, true, true, true};     // all >2
            pandas::DataFrame cond(cond_data);

            // Apply where with replacement value -1
            pandas::DataFrame result = df.where(cond, -1.0);

            // Get column index for A - it's sorted alphabetically in std::map
            size_t col_a_idx = df.get_column_index("A");
            size_t col_b_idx = df.get_column_index("B");

            bool passed = true;
            std::string error_msg;

            // Check A column values
            std::string a0 = result.iat<double>(0, col_a_idx) == -1.0 ? "ok" : "fail";

drop (pd_test_1_all.cpp:6558)

            if (df.ncols() != 2) {
                std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : pop ncols != 2" << std::endl;
                throw std::runtime_error("pd_test_dataframe_manipulation failed: pop ncols != 2");
            }
            if (!popped) {
                std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : popped is null" << std::endl;
                throw std::runtime_error("pd_test_dataframe_manipulation failed: popped is null");
            }

            // Test drop columns
            auto dropped = df.drop(std::vector<std::string>{"B"}, 1);
            if (dropped.ncols() != 1) {
                std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : drop ncols != 1" << std::endl;
                throw std::runtime_error("pd_test_dataframe_manipulation failed: drop ncols != 1");
            }

            // Test rename
            auto renamed = df.rename_columns(std::map<std::string, std::string>{{"A", "X"}});
            if (!renamed.has_column("X")) {
                std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : rename failed" << std::endl;
                throw std::runtime_error("pd_test_dataframe_manipulation failed: rename failed");

drop_duplicates (pd_test_1_all.cpp:6639)

                }
            }

            // Test drop_duplicates
            {
                std::map<std::string, std::vector<numpy::int64>> dup_data;
                dup_data["A"] = {1, 1, 2, 2};
                dup_data["B"] = {1, 1, 2, 3};
                pandas::DataFrame df_dup(dup_data);

                auto deduped = df_dup.drop_duplicates();
                // Rows 0 and 1 are duplicates (A=1, B=1), so should have 3 rows
                if (deduped.nrows() != 3) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_manipulation() : drop_duplicates nrows != 3, got " << deduped.nrows() << std::endl;
                    throw std::runtime_error("pd_test_dataframe_manipulation failed: drop_duplicates");
                }
            }

            // Test assign
            {
                std::map<std::string, std::vector<numpy::int64>> assign_data;

droplevel (pd_test_1_all.cpp:14428)

        void pd_test_multiindex_droplevel() {
            std::cout << "========= droplevel =================================== ";

            std::vector<std::vector<std::string>> arrays = {
                {"a", "a", "b"},
                {"x", "y", "z"},
                {"1", "2", "3"}
            };

            pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
            pandas::MultiIndex dropped = mi.droplevel(1);

            bool passed = true;

            if (dropped.nlevels() != 2) {
                std::cout << "  [FAIL] : nlevels should be 2 after drop" << std::endl;
                passed = false;
            }

            // Check remaining levels
            auto tup = dropped[0];

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");

insert (pd_test_1_all.cpp:12028)

            }

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

        void pd_test_index_insert_delete() {
            std::cout << "========= insert and delete ===========================";

            pandas::Index<numpy::int64> idx{1, 2, 4, 5};

            auto inserted = idx.insert(2, 3);
            bool passed = (inserted.size() == 5);
            passed = passed && (inserted[2] == 3);

            auto deleted = inserted.delete_(2);
            passed = passed && (deleted.size() == 4);
            passed = passed && deleted.equals(idx);

            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_index_insert_delete() : insert/delete failed" << std::endl;
                throw std::runtime_error("pd_test_index_insert_delete failed");

reindex (pd_test_1_all.cpp:6708)

                }
            }

            // Test reindex rows
            {
                std::map<std::string, std::vector<double>> data;
                data["A"] = {1.0, 2.0, 3.0};
                pandas::DataFrame df(data);
                df = df.set_axis({"x", "y", "z"}, 0);

                auto reindexed = df.reindex({"x", "z", "w"}, 0);
                if (reindexed.nrows() != 3) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : reindex wrong nrows" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex nrows");
                }
                // 'w' should have NaN
                std::string val = reindexed["A"].get_value_str(2);
                if (!std::isnan(std::stod(val))) {
                    std::cout << "  [FAIL] : in pd_test_dataframe_index_ops() : missing label should be NaN" << std::endl;
                    throw std::runtime_error("pd_test_dataframe_index_ops failed: reindex NaN");
                }

rename (pd_test_1_all.cpp:5816)

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

void pd_test_categorical_index_rename() {
    std::cout << "========= rename ======================================";

    pandas::CategoricalArray arr({"x", "y"});
    pandas::CategoricalIndex idx(arr, "old_name");

    pandas::CategoricalIndex renamed = idx.rename("new_name");

    bool passed = (renamed.name().has_value() && *renamed.name() == "new_name" &&
                   renamed.size() == idx.size() && renamed.categories() == idx.categories());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_rename()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_rename failed");
    }

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

set_names (pd_test_1_all.cpp:14519)

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

        void pd_test_multiindex_set_names() {
            std::cout << "========= set_names =================================== ";

            std::vector<std::vector<std::string>> arrays = {{"a", "b"}, {"x", "y"}};
            pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);

            std::vector<std::optional<std::string>> new_names = {"level_a", "level_b"};
            pandas::MultiIndex named = mi.set_names(new_names);

            bool passed = (named.names()[0] == "level_a" && named.names()[1] == "level_b");

            if (!passed) {
                std::cout << "  [FAIL] : names not set correctly" << std::endl;
                throw std::runtime_error("pd_test_multiindex_set_names failed");
            }

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

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");

isnull (pd_test_3_all.cpp:671)

// Category 5: Index Null Detection
// ============================================================================

void pd_test_3_all_index_null_detection() {
    std::cout << "========= Index.isnull/notnull() =====================";

    // Test with float index (can have NaN)
    std::vector<double> vals = {1.0, std::nan(""), 3.0, std::nan("")};
    pandas::Index<double> idx(vals);

    numpy::NDArray<numpy::bool_> isnull_result = idx.isnull();
    if (isnull_result.getSize() != 4) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size");
    }
    // Index 0: 1.0 -> not null
    if (isnull_result.getElementAt({0})) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : index 0 should not be null" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_null_detection failed: index 0");
    }
    // Index 1: NaN -> null

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};

notnull (pd_test_3_all.cpp:665)

    }

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

// ============================================================================
// Category 5: Index Null Detection
// ============================================================================

void pd_test_3_all_index_null_detection() {
    std::cout << "========= Index.isnull/notnull() =====================";

    // Test with float index (can have NaN)
    std::vector<double> vals = {1.0, std::nan(""), 3.0, std::nan("")};
    pandas::Index<double> idx(vals);

    numpy::NDArray<numpy::bool_> isnull_result = idx.isnull();
    if (isnull_result.getSize() != 4) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_null_detection() : isnull() size mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_null_detection failed: isnull() size");
    }

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();

mean (pd_test_1_all.cpp:282)

            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            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 ======================= ";

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'");

nunique (pd_test_1_all.cpp:10604)

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

void pd_test_extension_index_nunique() {
    std::cout << "========= nunique =========================";

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

    bool passed = (idx.nunique(true) == 3 && idx.nunique(false) == 4);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_nunique() : nunique check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_nunique failed");
    }

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

void pd_test_extension_index_factorize() {
    std::cout << "========= factorize =========================";

sum (pd_test_1_all.cpp:276)

        }

        // Test sum/mean
        pandas::BooleanArray arr({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

value_counts (pd_test_1_all.cpp:865)

        std::vector<std::optional<std::string>> values = {
            std::optional<std::string>("a"),
            std::optional<std::string>("b"),
            std::optional<std::string>("a"),
            std::optional<std::string>("a"),
            std::optional<std::string>("b"),
            std::nullopt  // NA not counted
        };
        pandas::CategoricalArray arr(values);

        auto [cats, counts] = arr.value_counts();

        // Should have 2 categories
        if (cats.size() != 2 || counts.size() != 2) {
            std::cout << "  [FAIL] : in pd_test_categorical_array_value_counts() : wrong size" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_value_counts failed: wrong size");
        }

        // Find 'a' count
        int64_t a_count = 0, b_count = 0;
        for (size_t i = 0; i < cats.size(); ++i) {

groupby (pd_test_1_all.cpp:11495)

            std::cout << "========= GroupBy basic =========================";

            // Create DataFrame with category column
            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0, 50.0}}
            };
            pandas::DataFrame df(data);

            // Test groupby
            auto grouped = df.groupby("category");

            bool passed = grouped.ngroups() == 2;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_groupby_basic() : ngroups should be 2" << std::endl;
                throw std::runtime_error("pd_test_groupby_basic failed: ngroups should be 2");
            }

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

equals (pd_test_1_all.cpp:5866)

    std::cout << "========= equals ======================================";

    pandas::CategoricalArray arr1({"a", "b", "a"});
    pandas::CategoricalArray arr2({"a", "b", "a"});
    pandas::CategoricalArray arr3({"a", "b", "c"});

    pandas::CategoricalIndex idx1(arr1);
    pandas::CategoricalIndex idx2(arr2);
    pandas::CategoricalIndex idx3(arr3);

    bool passed = (idx1.equals(idx2) && !idx1.equals(idx3));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_equals()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_equals failed");
    }

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

void pd_test_categorical_index_identical() {
    std::cout << "========= identical ===================================";

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");
        }

searchsorted (pd_test_1_all.cpp:18958)

    // =========================================================================
    // Search Tests
    // =========================================================================

    void pd_test_range_index_searchsorted() {
        std::cout << "========= searchsorted ================================ ";

        pandas::RangeIndex ri(0, 10, 2);  // [0, 2, 4, 6, 8]

        bool passed = (ri.searchsorted(4, "left") == 2 &&
                      ri.searchsorted(4, "right") == 3 &&
                      ri.searchsorted(3, "left") == 2 &&   // 3 would go between 2 and 4
                      ri.searchsorted(-1, "left") == 0 &&  // Before all
                      ri.searchsorted(10, "left") == 5);   // After all

        if (!passed) {
            std::cout << "  [FAIL] : searchsorted" << std::endl;
            throw std::runtime_error("pd_test_range_index_searchsorted failed");
        }

sort_values (pd_test_1_all.cpp:6408)

        void pd_test_dataframe_sorting() {
            std::cout << "========= sorting ==========================";

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

            pandas::DataFrame df(data);

            // Test sort_values ascending
            auto sorted_asc = df.sort_values("A", true);
            // First value should be smallest (1.0)
            std::string first_val = sorted_asc["A"].get_value_str(0);
            if (std::stod(first_val) != 1.0) {
                std::cout << "  [FAIL] : in pd_test_dataframe_sorting() : sort_values asc first != 1" << std::endl;
                throw std::runtime_error("pd_test_dataframe_sorting failed: sort_values asc first != 1");
            }

            // Test sort_values descending
            auto sorted_desc = df.sort_values("A", false);
            first_val = sorted_desc["A"].get_value_str(0);

to_frame (pd_test_3_all.cpp:4931)

    size_t usage = mi.memory_usage(true);
    if (usage == 0) {
        throw std::runtime_error("memory_usage() should return > 0");
    }

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

void pd_test_3_all_multiindex_to_frame() {
    std::cout << "========= MultiIndex.to_frame() =======================";

    std::vector<std::vector<std::string>> arrays = {{"a", "b"}, {"x", "y"}};
    std::vector<std::optional<std::string>> names = {"first", "second"};
    pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays, names);

    auto frame = mi.to_frame();
    if (frame.find("first") == frame.end() || frame.find("second") == frame.end()) {
        throw std::runtime_error("to_frame() missing columns");
    }

transpose (pd_test_1_all.cpp:16648)

                std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : T_() size" << std::endl;
                throw std::runtime_error("pd_test_ndframe_transpose failed: T_() size");
            }

            passed = transposed[0] == 1 && transposed[1] == 2 && transposed[2] == 3;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : T_() values" << std::endl;
                throw std::runtime_error("pd_test_ndframe_transpose failed: T_() values");
            }

            // Test transpose() alias
            auto transposed2 = s.transpose();
            passed = transposed2.size() == s.size();
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_transpose() : transpose() size" << std::endl;
                throw std::runtime_error("pd_test_ndframe_transpose failed: transpose() size");
            }

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

append (pd_test_1_all.cpp:10650)

    std::cout << "========= append =========================";

    // Use same categories for both arrays (required by CategoricalArray::concat)
    std::vector<std::string> cats = {"a", "b", "c", "d"};
    pandas::CategoricalArray arr1({"a", "b"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"c", "d"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto appended = idx1.append(idx2);

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

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

join (pd_test_1_all.cpp:12353)

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

        void pd_test_index_join() {
            std::cout << "========= join ========================================";

            pandas::Index<numpy::int64> idx1{1, 2, 3};
            pandas::Index<numpy::int64> idx2{2, 3, 4};

            auto [inner_joined, left_idx, right_idx] = idx1.join(idx2, "inner");
            bool passed = (inner_joined.size() == 2);  // {2, 3}

            auto [outer_joined, ol_idx, or_idx] = idx1.join(idx2, "outer");
            passed = passed && (outer_joined.size() == 4);  // {1, 2, 3, 4}

            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_index_join() : join failed" << std::endl;
                throw std::runtime_error("pd_test_index_join failed");
            }

asof (pd_test_2_all.cpp:366)

        std::cout << "====================================== [OK] pd_test_add_prefix test suite ========================== " << std::endl;
        return 0;
    }

} // namespace dataframe_tests
// ------------------- pd_test_add_prefix.cpp (end) -----------------------------

// ------------------- pd_test_asof.cpp (start) -----------------------------
// dataframe_tests/pd_test_asof.cpp
// Test for DataFrame.asof() method

#include <iostream>
#include <cmath>
#include <stdexcept>
#include <limits>
#include "../pandas/pd_dataframe.h"

// CRITICAL: No using namespace directives

namespace dataframe_tests {

asof_locs (pd_test_3_all.cpp:3557)

        throw std::runtime_error("all() should be true for empty index");
    }
    if (empty_idx.any()) {
        throw std::runtime_error("any() should be false for empty index");
    }

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

void pd_test_3_all_index_asof() {
    std::cout << "========= Index.asof()/asof_locs() =================";

    // Test with monotonically increasing index
    pandas::Index<numpy::int64> idx({10, 20, 30, 40, 50});

    // Exact match
    auto result = idx.asof(30);
    if (!result.has_value() || result.value() != 30) {
        throw std::runtime_error("asof() exact match should return 30");
    }

diff (pd_test_1_all.cpp:5171)

        }

        void pd_test_arithmetic_dataframe_diff_shift() {
            std::cout << "========= DataFrame diff/shift ==================";

            std::map<std::string, std::vector<double>> data;
            data["A"] = {1.0, 3.0, 6.0, 10.0};
            pandas::DataFrame df(data);

            // diff: [NaN, 2, 3, 4]
            auto d = df.diff();
            std::string val = d["A"].get_value_str(1);
            bool passed = std::abs(std::stod(val) - 2.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff failed");
            }

            // First element should be NaN
            val = d["A"].get_value_str(0);
            passed = std::isnan(std::stod(val));

difference (pd_test_1_all.cpp:10718)

    std::cout << "========= difference =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d"};
    pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "d"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto diff = idx1.difference(idx2);

    bool passed = (diff.size() == 2 &&
                   diff.contains("a") && diff.contains("c") &&
                   !diff.contains("b") && !diff.contains("d"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_difference() : difference check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_difference failed");
    }

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

difference (pd_test_1_all.cpp:10718)

    std::cout << "========= difference =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d"};
    pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "d"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto diff = idx1.difference(idx2);

    bool passed = (diff.size() == 2 &&
                   diff.contains("a") && diff.contains("c") &&
                   !diff.contains("b") && !diff.contains("d"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_difference() : difference check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_difference failed");
    }

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

shift (pd_test_1_all.cpp:5188)

            // First element should be NaN
            val = d["A"].get_value_str(0);
            passed = std::isnan(std::stod(val));
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : diff NaN failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: diff NaN failed");
            }

            // shift: [NaN, 1, 3, 6]
            auto s = df.shift();
            val = s["A"].get_value_str(1);
            passed = std::abs(std::stod(val) - 1.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_arithmetic_dataframe_diff_shift() : shift failed" << std::endl;
                throw std::runtime_error("pd_test_arithmetic_dataframe_diff_shift failed: shift failed");
            }

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

to_array (pd_test_1_all.cpp:18132)

        if (!passed) {
            std::cout << "  [FAIL] : element access" << std::endl;
            throw std::runtime_error("pd_test_range_index_element_access failed");
        }

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

    void pd_test_range_index_to_array() {
        std::cout << "========= to_array (lazy generation) ================== ";

        pandas::RangeIndex ri(0, 5);
        numpy::NDArray<numpy::int64> arr = ri.to_array();

        bool passed = (arr.getSize() == 5 &&
                      arr.getElementAt({0}) == 0 &&
                      arr.getElementAt({4}) == 4);

        if (!passed) {
            std::cout << "  [FAIL] : to_array" << std::endl;

to_flat_index (pd_test_1_all.cpp:14733)

        void pd_test_multiindex_to_flat_index() {
            std::cout << "========= to_flat_index =============================== ";

            std::vector<std::vector<std::string>> arrays = {
                {"a", "b"},
                {"x", "y"}
            };

            pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
            auto flat = mi.to_flat_index();

            bool passed = (flat.size() == 2 &&
                          flat[0][0] == "a" && flat[0][1] == "x" &&
                          flat[1][0] == "b" && flat[1][1] == "y");

            if (!passed) {
                std::cout << "  [FAIL] : to_flat_index incorrect" << std::endl;
                throw std::runtime_error("pd_test_multiindex_to_flat_index failed");
            }

to_index (pd_test_1_all.cpp:18935)

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

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

    void pd_test_range_index_to_index() {
        std::cout << "========= to_index ==================================== ";

        pandas::RangeIndex ri(0, 5, 1, "test");
        pandas::Index<numpy::int64> idx = ri.to_index();

        bool passed = (idx.size() == 5 &&
                      idx[0] == 0 && idx[4] == 4 &&
                      idx.name().value() == "test");

        if (!passed) {
            std::cout << "  [FAIL] : to_index" << std::endl;
            throw std::runtime_error("pd_test_range_index_to_index failed");
        }

to_list (pd_test_1_all.cpp:10247)

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

void pd_test_extension_index_to_list() {
    std::cout << "========= to_list =========================";

    pandas::CategoricalArray arr({"x", "y", "z"});
    pandas::CategoricalIndex idx(arr);

    auto list = idx.to_list();

    bool passed = (list.size() == 3 &&
                   list[0].has_value() && *list[0] == "x" &&
                   list[1].has_value() && *list[1] == "y" &&
                   list[2].has_value() && *list[2] == "z");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_to_list() : to_list check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_to_list failed");
    }

to_numpy (pd_test_1_all.cpp:16764)

        // =====================================================================
        // to_numpy Tests
        // =====================================================================

        void pd_test_ndframe_to_numpy() {
            std::cout << "========= to_numpy =============================================" << std::endl;

            pandas::Series<int> s({10, 20, 30});

            auto arr = s.to_numpy();

            bool passed = arr.getSize() == 3;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_to_numpy() : size" << std::endl;
                throw std::runtime_error("pd_test_ndframe_to_numpy failed: size");
            }

            passed = arr.getElementAt({0}) == 10 && arr.getElementAt({1}) == 20 && arr.getElementAt({2}) == 30;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_ndframe_to_numpy() : values" << std::endl;

to_series (pd_test_3_all.cpp:5788)

        throw std::runtime_error("to_frame use_index should be false when index=false");
    }
    if (frame3.column_name != "0") {
        throw std::runtime_error("to_frame column_name should be '0' when no name");
    }

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

void pd_test_3_all_period_index_to_series() {
    std::cout << "========= PeriodIndex.to_series() =====================";

    pandas::PeriodIndex idx = make_period_index({1, 2, 3}, "M").rename("periods");

    // Test to_series() with default parameters
    pandas::PeriodIndex::SeriesData series = idx.to_series();

    // values should have same size
    if (series.values.size() != 3) {
        throw std::runtime_error("to_series values size should be 3");
    }

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];

to_string_vector (pd_test_1_all.cpp:10871)

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

void pd_test_extension_index_to_string_vector() {
    std::cout << "========= to_string_vector =========================";

    pandas::CategoricalArray arr({"a", std::nullopt, "c"});
    pandas::CategoricalIndex idx(arr);

    auto str_vec = idx.to_string_vector();

    bool passed = (str_vec.size() == 3 &&
                   str_vec[0] == "a" && str_vec[1] == "NA" && str_vec[2] == "c");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_to_string_vector() : to_string_vector check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_to_string_vector failed");
    }

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

tolist (pd_test_3_all.cpp:2300)

        threw = true;
    }
    if (!threw) {
        throw std::runtime_error("swapaxes should throw for invalid axes");
    }

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

void pd_test_3_all_categorical_to_list() {
    std::cout << "========= CategoricalArray.to_list()/tolist() =========";

    std::vector<std::optional<std::string>> values = {"a", "b", std::nullopt, "c"};
    pandas::CategoricalArray arr(values);

    auto list = arr.to_list();
    if (list.size() != 4 || *list[0] != "a" || *list[1] != "b" ||
        list[2].has_value() || *list[3] != "c") {
        throw std::runtime_error("to_list failed");
    }

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;
}

infer_objects (pd_test_1_all.cpp:27595)

            // Create DataFrame with string column containing integers
            std::map<std::string, std::vector<std::string>> data;
            data["A"] = {"1", "2", "3", "4", "5"};

            pandas::DataFrame df(data);

            // Before inference, dtype should be string/object
            std::string before_dtype = df["A"].dtype_name();

            // Apply infer_objects
            pandas::DataFrame result = df.infer_objects();

            // After inference, dtype should be int64
            std::string after_dtype = result["A"].dtype_name();

            bool passed = (after_dtype == "int64");
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_infer_objects_integer_column() : expected int64, got " << after_dtype << std::endl;
                throw std::runtime_error("pd_test_infer_objects_integer_column failed");
            }

view (pd_test_3_all.cpp:2147)

        throw std::runtime_error("memory_usage shallow too small");
    }
    if (deep < shallow) {
        throw std::runtime_error("memory_usage deep should be >= shallow");
    }

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

void pd_test_3_all_categorical_ravel_view() {
    std::cout << "========= CategoricalArray.ravel()/view() =============";

    std::vector<std::optional<std::string>> values = {"a", "b", "c"};
    pandas::CategoricalArray arr(values);

    auto raveled = arr.ravel();
    if (raveled.size() != 3 || !raveled.equals(arr)) {
        throw std::runtime_error("ravel failed");
    }

    auto viewed = arr.view();

duplicated (pd_test_1_all.cpp:10583)

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

void pd_test_extension_index_duplicated() {
    std::cout << "========= duplicated =========================";

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

    auto dup_mask = idx.duplicated("first");

    bool passed = (dup_mask.getElementAt({0}) == false &&
                   dup_mask.getElementAt({1}) == false &&
                   dup_mask.getElementAt({2}) == true &&
                   dup_mask.getElementAt({3}) == false &&
                   dup_mask.getElementAt({4}) == true);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_duplicated() : duplicated check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_duplicated failed");
    }

intersection (pd_test_1_all.cpp:10672)

    std::cout << "========= intersection =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d", "e", "f"};
    pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "c", "e", "f"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto inter = idx1.intersection(idx2);

    bool passed = (inter.size() == 2 && inter.contains("b") && inter.contains("c"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_intersection() : intersection check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_intersection failed");
    }

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

intersection (pd_test_1_all.cpp:10672)

    std::cout << "========= intersection =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d", "e", "f"};
    pandas::CategoricalArray arr1({"a", "b", "c", "d"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "c", "e", "f"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto inter = idx1.intersection(idx2);

    bool passed = (inter.size() == 2 && inter.contains("b") && inter.contains("c"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_intersection() : intersection check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_intersection failed");
    }

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

isin (pd_test_1_all.cpp:5938)

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

void pd_test_categorical_index_isin() {
    std::cout << "========= inherited isin ==============================";

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

    std::vector<std::string> values = {"a", "c"};
    numpy::NDArray<numpy::bool_> mask = idx.isin(values);

    bool passed = (mask.getSize() == 4 &&
                   mask.getElementAt({0}) == true &&   // a
                   mask.getElementAt({1}) == false &&  // b
                   mask.getElementAt({2}) == true &&   // c
                   mask.getElementAt({3}) == false);   // d
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_isin()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_isin failed");
    }

symmetric_difference (pd_test_1_all.cpp:10742)

    std::cout << "========= symmetric_difference =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d"};
    pandas::CategoricalArray arr1({"a", "b", "c"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "c", "d"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto sym_diff = idx1.symmetric_difference(idx2);

    bool passed = (sym_diff.size() == 2 &&
                   sym_diff.contains("a") && sym_diff.contains("d") &&
                   !sym_diff.contains("b") && !sym_diff.contains("c"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_symmetric_difference() : symmetric_difference check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_symmetric_difference failed");
    }

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

symmetric_difference (pd_test_1_all.cpp:10742)

    std::cout << "========= symmetric_difference =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d"};
    pandas::CategoricalArray arr1({"a", "b", "c"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "c", "d"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto sym_diff = idx1.symmetric_difference(idx2);

    bool passed = (sym_diff.size() == 2 &&
                   sym_diff.contains("a") && sym_diff.contains("d") &&
                   !sym_diff.contains("b") && !sym_diff.contains("c"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_symmetric_difference() : symmetric_difference check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_symmetric_difference failed");
    }

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

union_ (pd_test_1_all.cpp:10694)

    std::cout << "========= union =========================";

    // Use same categories for both arrays
    std::vector<std::string> cats = {"a", "b", "c", "d", "e"};
    pandas::CategoricalArray arr1({"a", "b", "c"}, cats);
    pandas::CategoricalIndex idx1(arr1);

    pandas::CategoricalArray arr2({"b", "c", "d", "e"}, cats);
    pandas::CategoricalIndex idx2(arr2);

    auto uni = idx1.union_(idx2);

    bool passed = (uni.size() == 5 &&
                   uni.contains("a") && uni.contains("b") && uni.contains("c") &&
                   uni.contains("d") && uni.contains("e"));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_union() : union check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_union 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_ (pd_test_3_all.cpp:3972)

    // For typed Index, this is a no-op
    if (result.size() != 5) {
        throw std::runtime_error("infer_objects size should be 5");
    }

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

void pd_test_3_all_index_is_() {
    std::cout << "========= Index.is_() ==============================";

    pandas::Index<numpy::int64> idx1({1, 2, 3, 4, 5});
    pandas::Index<numpy::int64> idx2({1, 2, 3, 4, 5});  // Different object

    // Different objects should not be the same
    if (idx1.is_(idx2)) {
        throw std::runtime_error("different objects should not be is_() equal");
    }

    // Same object should be the same

is_boolean (pd_test_3_all.cpp:3290)

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

void pd_test_3_all_datetime_index_type_checks() {
    std::cout << "========= DatetimeIndex type checks ======================";

    pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");

    // Type check methods
    if (idx.is_boolean()) {
        throw std::runtime_error("is_boolean() should be false");
    }
    if (idx.is_categorical()) {
        throw std::runtime_error("is_categorical() should be false");
    }
    if (idx.is_floating()) {
        throw std::runtime_error("is_floating() should be false");
    }
    if (idx.is_integer()) {
        throw std::runtime_error("is_integer() should be false");

is_categorical (pd_test_3_all.cpp:3293)

void pd_test_3_all_datetime_index_type_checks() {
    std::cout << "========= DatetimeIndex type checks ======================";

    pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");

    // Type check methods
    if (idx.is_boolean()) {
        throw std::runtime_error("is_boolean() should be false");
    }
    if (idx.is_categorical()) {
        throw std::runtime_error("is_categorical() should be false");
    }
    if (idx.is_floating()) {
        throw std::runtime_error("is_floating() should be false");
    }
    if (idx.is_integer()) {
        throw std::runtime_error("is_integer() should be false");
    }
    if (idx.is_interval()) {
        throw std::runtime_error("is_interval() should be false");

is_floating (pd_test_3_all.cpp:622)

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");
    }

    // Test with float index
    pandas::IndexDtype<double> float_dtype;

is_integer (pd_test_3_all.cpp:618)

void pd_test_3_all_index_dtype_checks() {
    std::cout << "========= IndexDtype.is_numeric/integer/floating/object() ";

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");

is_interval (pd_test_3_all.cpp:3302)

    }
    if (idx.is_categorical()) {
        throw std::runtime_error("is_categorical() should be false");
    }
    if (idx.is_floating()) {
        throw std::runtime_error("is_floating() should be false");
    }
    if (idx.is_integer()) {
        throw std::runtime_error("is_integer() should be false");
    }
    if (idx.is_interval()) {
        throw std::runtime_error("is_interval() should be false");
    }
    if (idx.is_numeric()) {
        throw std::runtime_error("is_numeric() should be false");
    }
    if (idx.is_object()) {
        throw std::runtime_error("is_object() should be false");
    }
    if (idx.holds_integer()) {
        throw std::runtime_error("holds_integer() should be false");

is_monotonic_decreasing (pd_test_1_all.cpp:10203)

}

void pd_test_extension_index_monotonicity() {
    std::cout << "========= monotonicity =========================";

    pandas::CategoricalArray arr1({"a", "b", "c"});
    pandas::CategoricalIndex idx1(arr1);

    // Just test that the methods work (result depends on internal ordering)
    bool inc = idx1.is_monotonic_increasing();
    bool dec = idx1.is_monotonic_decreasing();

    bool passed = (inc || dec || (!inc && !dec));  // Any result is valid
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_monotonicity() : monotonicity check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_monotonicity failed");
    }

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

is_monotonic_increasing (pd_test_1_all.cpp:10202)

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

void pd_test_extension_index_monotonicity() {
    std::cout << "========= monotonicity =========================";

    pandas::CategoricalArray arr1({"a", "b", "c"});
    pandas::CategoricalIndex idx1(arr1);

    // Just test that the methods work (result depends on internal ordering)
    bool inc = idx1.is_monotonic_increasing();
    bool dec = idx1.is_monotonic_decreasing();

    bool passed = (inc || dec || (!inc && !dec));  // Any result is valid
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_monotonicity() : monotonicity check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_monotonicity failed");
    }

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

is_numeric (pd_test_3_all.cpp:614)

// ============================================================================
// Category 4: Index Type Checking (IndexDtype)
// ============================================================================

void pd_test_3_all_index_dtype_checks() {
    std::cout << "========= IndexDtype.is_numeric/integer/floating/object() ";

    // Test with integer index
    pandas::IndexDtype<numpy::int64> int_dtype;
    if (!int_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");

is_object (pd_test_3_all.cpp:626)

        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_numeric");
    }
    if (!int_dtype.is_integer()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should be integer" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_integer");
    }
    if (int_dtype.is_floating()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be floating" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_floating");
    }
    if (int_dtype.is_object()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : int should not be object" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: int is_object");
    }

    // Test with float index
    pandas::IndexDtype<double> float_dtype;
    if (!float_dtype.is_numeric()) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_dtype_checks() : float should be numeric" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_dtype_checks failed: float is_numeric");
    }

is_range_index (pd_test_5_all.cpp:21595)

                  << local_fail << " checks failed" << std::endl;
        throw std::runtime_error("f_test_merge_int_dtype_upcast_4 failed");
    }
    std::cout << " -> tests passed" << std::endl;
}

// --- f_test_rename_column_width_bug_4.cpp ---

namespace f_test_rename_column_width_bug_4_ns {

static bool is_range_index(const pandas::DataFrame& df) {
    return dynamic_cast<const pandas::RangeIndex*>(&df.index()) != nullptr;
}

static void diff_print(const std::string& got,
                       const std::string& expected,
                       const std::string& label) {
    if (got == expected) return;
    std::cout << "    [" << label << "] to_string MISMATCH\n";
    std::cout << "    --- got ---\n";
    std::cout << got << "\n";

is_unique (pd_test_1_all.cpp:5962)

void pd_test_categorical_index_is_unique() {
    std::cout << "========= inherited is_unique =========================";

    pandas::CategoricalArray arr_unique({"a", "b", "c"});
    pandas::CategoricalArray arr_dups({"a", "b", "a"});

    pandas::CategoricalIndex idx_unique(arr_unique);
    pandas::CategoricalIndex idx_dups(arr_dups);

    bool passed = (idx_unique.is_unique() && !idx_dups.is_unique());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_is_unique()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_is_unique failed");
    }

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

void pd_test_categorical_index_hasnans() {
    std::cout << "========= inherited hasnans ===========================";

abs (pd_test_1_all.cpp:283)

            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            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 ======================= ";

all (pd_test_1_all.cpp:247)

        pandas::BooleanArray has_true({
            std::optional<bool>(false),
            std::optional<bool>(true)
        });
        any_result = has_true.any();
        if (!any_result.has_value() || !any_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : any() with True" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: any() with True");
        }

        // Test all()
        pandas::BooleanArray all_true({
            std::optional<bool>(true),
            std::optional<bool>(true)
        });
        auto all_result = all_true.all();
        if (!all_result.has_value() || !all_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : all() of all True" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: all() all True");
        }

any (pd_test_1_all.cpp:226)

            std::cout << "  [FAIL] : in pd_test_boolean_array_kleene_not() : ~NA should be NA" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_kleene_not failed: ~NA");
        }

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

    void pd_test_boolean_array_reductions() {
        std::cout << "========= BooleanArray: reductions ======================= ";

        // Test any()
        pandas::BooleanArray all_false({
            std::optional<bool>(false),
            std::optional<bool>(false)
        });
        auto any_result = all_false.any();
        if (!any_result.has_value() || any_result.value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : any() of all False" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: any() all False");
        }

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");

clear_cache (pd_test_1_all.cpp:19413)

            s.mean();
            s.min();
            s.max();

            passed = s.has_cached_values() == true;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_series_cache() : cache not populated" << std::endl;
                throw std::runtime_error("pd_test_series_cache failed: cache not populated");
            }

            s.clear_cache();
            passed = s.has_cached_values() == false;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_series_cache() : cache not cleared" << std::endl;
                throw std::runtime_error("pd_test_series_cache failed: cache not cleared");
            }

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

        void pd_test_series_string_repr() {

clone (pd_test_1_all.cpp:5776)

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

void pd_test_categorical_index_clone() {
    std::cout << "========= clone =======================================";

    pandas::CategoricalArray arr({"p", "q", "r"});
    pandas::CategoricalIndex idx(arr, "original");

    std::unique_ptr<pandas::IndexBase> cloned = idx.clone();

    bool passed = (cloned != nullptr && cloned->size() == idx.size() &&
                   cloned->name() == idx.name());
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_clone()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_clone failed");
    }

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

contains (pd_test_1_all.cpp:2200)

// Test: contains method
// ============================================================================
void test_contains() {
    std::cout << "========= IntervalArray: contains ======================= ";

    std::vector<numpy::float64> breaks = {0.0, 1.0, 2.0, 3.0};

    // Right-closed intervals: (0, 1], (1, 2], (2, 3]
    auto arr_right = pandas::IntervalArrayFloat64::from_breaks(breaks, pandas::IntervalClosed::Right);

    // Test contains(1.0) - should be in interval 0 but not 1 (since 1 is exclusive on left of interval 1)
    auto contains_1 = arr_right.contains(1.0);
    // (0, 1] contains 1: yes, (1, 2] contains 1: no (open on left), (2, 3] contains 1: no
    if (contains_1[0].value_or(false) != true ||
        contains_1[1].value_or(true) != false ||
        contains_1[2].value_or(true) != false) {
        std::cout << "[FAIL] : in test_contains() : right-closed contains 1.0" << std::endl;
        return;
    }

    // Left-closed intervals: [0, 1), [1, 2), [2, 3)

contains_str (pd_test_1_all.cpp:10889)

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

void pd_test_extension_index_contains_str_get_loc_str() {
    std::cout << "========= contains_str/get_loc_str =========================";

    pandas::CategoricalArray arr({"apple", "banana", "cherry"});
    pandas::CategoricalIndex idx(arr);

    bool passed = (idx.contains_str("apple") && !idx.contains_str("grape") &&
                   idx.get_loc_str("banana") == 1 && idx.get_loc_str("grape") == -1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_contains_str_get_loc_str() : contains_str/get_loc_str check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_contains_str_get_loc_str failed");
    }

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

void pd_test_extension_index_repr() {

delete_ (pd_test_1_all.cpp:10501)

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

void pd_test_extension_index_delete() {
    std::cout << "========= delete_ =========================";

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

    auto deleted = idx.delete_(1);
    auto v0 = deleted[0];
    auto v1 = deleted[1];
    auto v2 = deleted[2];

    bool passed = (deleted.size() == 3 &&
                   v0.has_value() && *v0 == "a" &&
                   v1.has_value() && *v1 == "c" &&
                   v2.has_value() && *v2 == "d");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl;

delete_ (pd_test_1_all.cpp:10501)

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

void pd_test_extension_index_delete() {
    std::cout << "========= delete_ =========================";

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

    auto deleted = idx.delete_(1);
    auto v0 = deleted[0];
    auto v1 = deleted[1];
    auto v2 = deleted[2];

    bool passed = (deleted.size() == 3 &&
                   v0.has_value() && *v0 == "a" &&
                   v1.has_value() && *v1 == "c" &&
                   v2.has_value() && *v2 == "d");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_delete() : delete_ check failed" << std::endl;

dtype_name (pd_test_1_all.cpp:10104)

}

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

    pandas::CategoricalArray arr({"apple", "banana", "apple", "cherry"});
    pandas::CategoricalIndex idx(arr, "fruits");

    bool passed = (idx.size() == 4 && !idx.empty() &&
                   idx.name().has_value() && *idx.name() == "fruits" &&
                   idx.dtype_name() == "category");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_extension_index_array_constructor() : array constructor check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_array_constructor failed");
    }

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

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

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");
        }

format (main.cpp:20)

int main() {
  // Automatically log all output to temp/pd_test_output.log
  numpy::TestLogger logger("temp/pd_test_output.log");

  int res = 0;
  int res1 = 0;
  std::string resS = "";

  // call all the tests
  res1 = dataframe_tests::pd_test_main();
  resS += std::format("             pd_test_main: {}  errors\n", res1);
  res += res1;

  std::cout << "\n------------------------- main --------------------------------------------\n";
  std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl;
  std::cout << "Details: \n" << resS;
  std::cout << "\n---------------------------------------------------------------------------\n";
  return res;
}

has_cached_values (pd_test_1_all.cpp:19395)

            }

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

        void pd_test_series_cache() {
            std::cout << "========= cache management =========================================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});

            bool passed = s.has_cached_values() == false;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_series_cache() : initial cache not empty" << std::endl;
                throw std::runtime_error("pd_test_series_cache failed: initial cache not empty");
            }

            // Trigger cache
            s.sum();
            s.mean();
            s.min();
            s.max();

has_duplicates (pd_test_1_all.cpp:10176)

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

void pd_test_extension_index_uniqueness() {
    std::cout << "========= uniqueness =========================";

    // Unique values
    pandas::CategoricalArray arr1({"a", "b", "c"});
    pandas::CategoricalIndex idx1(arr1);

    bool passed1 = (idx1.is_unique() && !idx1.has_duplicates());
    if (!passed1) {
        std::cout << "  [FAIL] : in pd_test_extension_index_uniqueness() : unique check failed" << std::endl;
        throw std::runtime_error("pd_test_extension_index_uniqueness failed");
    }

    // With duplicates
    pandas::CategoricalArray arr2({"a", "b", "a", "c"});
    pandas::CategoricalIndex idx2(arr2);

    bool passed2 = (!idx2.is_unique() && idx2.has_duplicates());

holds_integer (pd_test_3_all.cpp:3311)

    }
    if (idx.is_interval()) {
        throw std::runtime_error("is_interval() should be false");
    }
    if (idx.is_numeric()) {
        throw std::runtime_error("is_numeric() should be false");
    }
    if (idx.is_object()) {
        throw std::runtime_error("is_object() should be false");
    }
    if (idx.holds_integer()) {
        throw std::runtime_error("holds_integer() should be false");
    }

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

void pd_test_3_all_datetime_index_sort() {
    std::cout << "========= DatetimeIndex.sort_values() ====================";

    pandas::DatetimeIndex idx = pandas::date_range("2024-01-01", "2024-01-05", std::nullopt, "D");

identical (pd_test_1_all.cpp:5883)

}

void pd_test_categorical_index_identical() {
    std::cout << "========= identical ===================================";

    pandas::CategoricalArray arr({"a", "b"});
    pandas::CategoricalIndex idx1(arr, "same_name");
    pandas::CategoricalIndex idx2(arr, "same_name");
    pandas::CategoricalIndex idx3(arr, "diff_name");

    bool passed = (idx1.identical(idx2) && !idx1.identical(idx3));
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_identical()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_identical failed");
    }

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

// ============================================================================
// Inherited Operations Tests

inferred_type (pd_test_1_all.cpp:5270)

}

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

    pandas::CategoricalArray arr({"apple", "banana", "apple", "cherry"});
    pandas::CategoricalIndex idx(arr, "fruits");

    bool passed = (idx.size() == 4 && !idx.empty() &&
                   idx.name().has_value() && *idx.name() == "fruits" &&
                   idx.inferred_type() == "categorical");
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_categorical_index_array_constructor()" << std::endl;
        throw std::runtime_error("pd_test_categorical_index_array_constructor failed");
    }

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

void pd_test_categorical_index_values_constructor() {
    std::cout << "========= values constructor ==========================";

item (pd_test_3_all.cpp:3712)

    // Test is_interval (always false for base Index)
    if (int_idx.is_interval()) {
        throw std::runtime_error("base Index should not be interval");
    }

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

void pd_test_3_all_index_item() {
    std::cout << "========= Index.item() =============================";

    pandas::Index<numpy::int64> idx1({42});
    numpy::int64 val = idx1.item();

    if (val != 42) {
        throw std::runtime_error("item() should return 42");
    }

    // Test error for size != 1
    pandas::Index<numpy::int64> idx2({1, 2, 3});

memory_usage (pd_test_1_all.cpp:27063)

        }

        std::cout << "====================================== [OK] pd_test_value_counts test suite ========================== " << std::endl;
        return 0;
    }

} // namespace dataframe_tests
// ------------------- pd_test_value_counts.cpp (end) -----------------------------

// ------------------- pd_test_memory_usage.cpp (start) -----------------------------
// Tests for DataFrame.memory_usage() - pandas-compatible memory usage reporting

namespace dataframe_tests {
    namespace dataframe_tests_memory_usage {

        void pd_test_memory_usage_basic() {
            std::cout << "========= basic memory_usage =======================";

            // Create a simple DataFrame with multiple columns
            std::map<std::string, std::vector<double>> data;
            data["A"] = {1.0, 2.0, 3.0, 4.0, 5.0};

name (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;

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");
            }

nlevels (pd_test_1_all.cpp:14138)

        // =====================================================================
        // Constructor Tests
        // =====================================================================

        void pd_test_multiindex_default_constructor() {
            std::cout << "========= default constructor ========================= ";

            pandas::MultiIndex mi;

            bool passed = (mi.nlevels() == 0) && (mi.size() == 0) && mi.empty();

            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_multiindex_default_constructor()" << std::endl;
                throw std::runtime_error("pd_test_multiindex_default_constructor failed");
            }

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

        void pd_test_multiindex_from_arrays() {

putmask (pd_test_3_all.cpp:3752)

    // Should be at least sizeof index + 5 * sizeof(int64)
    if (usage < 5 * sizeof(numpy::int64)) {
        throw std::runtime_error("memory_usage too small");
    }

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

void pd_test_3_all_index_putmask() {
    std::cout << "========= Index.putmask() ==========================";

    pandas::Index<numpy::int64> idx({1, 2, 3, 4, 5});
    numpy::NDArray<numpy::bool_> mask(std::vector<size_t>{5});
    mask.setElementAt({0}, numpy::bool_(true));
    mask.setElementAt({1}, numpy::bool_(false));
    mask.setElementAt({2}, numpy::bool_(true));
    mask.setElementAt({3}, numpy::bool_(false));
    mask.setElementAt({4}, numpy::bool_(true));

    auto result = idx.putmask(mask, numpy::int64(99));

ravel (pd_test_3_all.cpp:2147)

        throw std::runtime_error("memory_usage shallow too small");
    }
    if (deep < shallow) {
        throw std::runtime_error("memory_usage deep should be >= shallow");
    }

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

void pd_test_3_all_categorical_ravel_view() {
    std::cout << "========= CategoricalArray.ravel()/view() =============";

    std::vector<std::optional<std::string>> values = {"a", "b", "c"};
    pandas::CategoricalArray arr(values);

    auto raveled = arr.ravel();
    if (raveled.size() != 3 || !raveled.equals(arr)) {
        throw std::runtime_error("ravel failed");
    }

    auto viewed = arr.view();

repeat (pd_test_3_all.cpp:2166)

    auto viewed = arr.view();
    if (viewed.size() != 3 || !viewed.equals(arr)) {
        throw std::runtime_error("view failed");
    }

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

void pd_test_3_all_categorical_repeat() {
    std::cout << "========= CategoricalArray.repeat() ===================";

    std::vector<std::optional<std::string>> values = {"a", "b"};
    pandas::CategoricalArray arr(values);

    auto result = arr.repeat(3);
    if (result.size() != 6 || *result[0] != "a" || *result[2] != "a" ||
        *result[3] != "b" || *result[5] != "b") {
        throw std::runtime_error("repeat scalar failed");
    }

repeat (pd_test_3_all.cpp:2166)

    auto viewed = arr.view();
    if (viewed.size() != 3 || !viewed.equals(arr)) {
        throw std::runtime_error("view failed");
    }

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

void pd_test_3_all_categorical_repeat() {
    std::cout << "========= CategoricalArray.repeat() ===================";

    std::vector<std::optional<std::string>> values = {"a", "b"};
    pandas::CategoricalArray arr(values);

    auto result = arr.repeat(3);
    if (result.size() != 6 || *result[0] != "a" || *result[2] != "a" ||
        *result[3] != "b" || *result[5] != "b") {
        throw std::runtime_error("repeat scalar failed");
    }

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;
}

result (pd_test_1_all.cpp:15406)

    data.setElementAt({0}, numpy::datetime64(100LL, numpy::DateTimeUnit::Nanosecond));
    data.setElementAt({1}, numpy::datetime64(200LL, numpy::DateTimeUnit::Nanosecond));

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

    pandas::DatetimeArray arr(data, mask);
    pandas::DatetimeIndexBase idx(arr, "original");

    // Create join result (int64 values)
    numpy::NDArray<numpy::int64> join_result(std::vector<size_t>{3});
    join_result.setElementAt({0}, numpy::int64(500LL));
    join_result.setElementAt({1}, numpy::int64(600LL));
    join_result.setElementAt({2}, numpy::int64(700LL));

    auto new_idx = idx._from_join_target(join_result);

    bool passed = (new_idx.size() == 3 &&
                   new_idx.name().has_value() && *new_idx.name() == "original");
    if (!passed) {

round (pd_test_1_all.cpp:1688)

    void pd_test_floating_array_rounding() {
        std::cout << "========= FloatingArray: rounding ======================= ";

        pandas::FloatingArray<double> arr({
            std::optional<double>(1.234),
            std::optional<double>(2.567),
            std::nullopt
        });

        auto rounded = arr.round(2);
        if (std::abs(rounded[0].value() - 1.23) > 0.001 ||
            std::abs(rounded[1].value() - 2.57) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_floating_array_rounding() : round(2)" << std::endl;
            throw std::runtime_error("pd_test_floating_array_rounding failed: round(2)");
        }

        if (!rounded.is_na(2)) {
            std::cout << "  [FAIL] : in pd_test_floating_array_rounding() : round should preserve NA" << std::endl;
            throw std::runtime_error("pd_test_floating_array_rounding failed: NA preservation");
        }

set_name (pd_test_1_all.cpp:11798)

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

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

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

            pandas::Index<numpy::int64> idx1{1, 2, 3};
            idx1.set_name("original");

            pandas::Index<numpy::int64> idx2(idx1);

            bool passed = (idx2.size() == 3);
            passed = passed && (idx2.name().value() == "original");
            passed = passed && idx2.equals(idx1);

            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_index_copy_constructor() : copy failed" << std::endl;
                throw std::runtime_error("pd_test_index_copy_constructor failed");

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)

slice (pd_test_1_all.cpp:17546)

// ============================================================================
// Slicing / Indexing Tests
// ============================================================================

void pd_test_period_index_slice() {
    std::cout << "========= slice method ================================";

    std::vector<int64_t> ordinals = {0, 1, 2, 3, 4};
    pandas::PeriodIndex idx(ordinals, "D");

    pandas::PeriodIndex sliced = idx.slice(1, 4);

    bool passed = (sliced.size() == 3 &&
                   sliced[0].has_value() && *sliced[0] == 1);
    if (!passed) {
        std::cout << "  [FAIL] : in pd_test_period_index_slice()" << std::endl;
        throw std::runtime_error("pd_test_period_index_slice failed");
    }

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

slice_indexer (pd_test_3_all.cpp:711)

    }

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

// ============================================================================
// Category 6: Index Indexer Methods
// ============================================================================

void pd_test_3_all_index_indexers() {
    std::cout << "========= Index.get_indexer_for/non_unique/slice_indexer() ";

    std::vector<std::string> vals = {"a", "b", "c", "d", "e"};
    pandas::Index<std::string> idx(vals);

    // Test get_indexer_for()
    std::vector<std::string> target = {"b", "d", "f"};  // "f" doesn't exist
    numpy::NDArray<numpy::int64> indexer = idx.get_indexer_for(target);
    if (indexer.getSize() != 3) {
        std::cout << "  [FAIL] : in pd_test_3_all_index_indexers() : get_indexer_for size mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_index_indexers failed: get_indexer_for size");

slice_locs (pd_test_1_all.cpp:18275)

        }

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

    void pd_test_range_index_slice_locs() {
        std::cout << "========= slice_locs ================================== ";

        pandas::RangeIndex ri(0, 10);  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        auto [start_idx, stop_idx] = ri.slice_locs(3, 7);

        bool passed = (start_idx == 3 && stop_idx == 8);

        if (!passed) {
            std::cout << "  [FAIL] : slice_locs" << std::endl;
            throw std::runtime_error("pd_test_range_index_slice_locs failed");
        }

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

sort (pd_test_3_all.cpp:3869)

        throw std::runtime_error("last 2 positions should be NaN");
    }
    if (std::abs(result[0] - 3.0) > 0.001) {
        throw std::runtime_error("shift(-2) [0] should be 3.0");
    }

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

void pd_test_3_all_index_sort() {
    std::cout << "========= Index.sort() =============================";

    pandas::Index<numpy::int64> idx({3, 1, 4, 1, 5, 9, 2, 6});
    auto result = idx.sort();

    if (result[0] != 1 || result[1] != 1 || result[7] != 9) {
        throw std::runtime_error("sort() not working correctly");
    }

    // Test descending
    result = idx.sort(false);

sortlevel (pd_test_1_all.cpp:14676)

        void pd_test_multiindex_sortlevel() {
            std::cout << "========= sortlevel =================================== ";

            std::vector<std::vector<std::string>> arrays = {
                {"b", "a", "c"},
                {"2", "1", "3"}
            };

            pandas::MultiIndex mi = pandas::MultiIndex::from_arrays<std::string>(arrays);
            auto [sorted, indices] = mi.sortlevel(0);

            bool passed = true;

            // After sorting by level 0: a, b, c
            if (sorted[0][0] != "a" || sorted[1][0] != "b" || sorted[2][0] != "c") {
                std::cout << "  [FAIL] : not sorted correctly by level 0" << std::endl;
                passed = false;
            }

            if (!passed) {

start (pd_test_1_all.cpp:17898)

    // Constructor Tests
    // =========================================================================

    void pd_test_range_index_default_constructor() {
        std::cout << "========= default constructor ========================= ";

        pandas::RangeIndex ri;

        bool passed = (ri.size() == 0 &&
                      ri.empty() &&
                      ri.start() == 0 &&
                      ri.stop() == 0 &&
                      ri.step() == 1 &&
                      !ri.name().has_value());

        if (!passed) {
            std::cout << "  [FAIL] : default constructor" << std::endl;
            throw std::runtime_error("pd_test_range_index_default_constructor failed");
        }

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

step (pd_test_1_all.cpp:17900)

    void pd_test_range_index_default_constructor() {
        std::cout << "========= default constructor ========================= ";

        pandas::RangeIndex ri;

        bool passed = (ri.size() == 0 &&
                      ri.empty() &&
                      ri.start() == 0 &&
                      ri.stop() == 0 &&
                      ri.step() == 1 &&
                      !ri.name().has_value());

        if (!passed) {
            std::cout << "  [FAIL] : default constructor" << std::endl;
            throw std::runtime_error("pd_test_range_index_default_constructor failed");
        }

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

stop (pd_test_1_all.cpp:17899)

    // =========================================================================

    void pd_test_range_index_default_constructor() {
        std::cout << "========= default constructor ========================= ";

        pandas::RangeIndex ri;

        bool passed = (ri.size() == 0 &&
                      ri.empty() &&
                      ri.start() == 0 &&
                      ri.stop() == 0 &&
                      ri.step() == 1 &&
                      !ri.name().has_value());

        if (!passed) {
            std::cout << "  [FAIL] : default constructor" << std::endl;
            throw std::runtime_error("pd_test_range_index_default_constructor failed");
        }

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

str (pd_test_1_all.cpp:7137)

            // Test basic info() with stringstream
            std::map<std::string, std::vector<int>> data = {
                {"A", {1, 2, 3, 4, 5}},
                {"B", {10, 20, 30, 40, 50}},
                {"C", {100, 200, 300, 400, 500}}
            };
            pandas::DataFrame df(data);

            std::ostringstream oss;
            df.info(oss);
            std::string output = oss.str();

            // Verify key components
            if (output.find("<class 'pandas.core.frame.DataFrame'>") == std::string::npos) {
                std::cout << "  [FAIL] : info missing class name" << std::endl;
                throw std::runtime_error("pd_test_dataframe_info failed: missing class name");
            }
            if (output.find("RangeIndex:") == std::string::npos) {
                std::cout << "  [FAIL] : info missing RangeIndex" << std::endl;
                throw std::runtime_error("pd_test_dataframe_info failed: missing RangeIndex");
            }

type_id (pd_test_3_all.cpp:25592)

// ------------------- pd_test_value_classify (end) ------------------

// ------------------- pd_test_index_type_id (start) ------------------
namespace dataframe_tests_index_type_id {

void pd_test_index_type_id_dispatch() {
    std::cout << "========= IndexTypeId dispatch =======================";

    // RangeIndex
    ::pandas::RangeIndex ri(0, 5);
    if (ri.type_id() != ::pandas::IndexTypeId::RangeIndex)
        throw std::runtime_error("RangeIndex type_id failed");

    // Index<string>
    ::pandas::Index<std::string> si(std::vector<std::string>{"a", "b", "c"});
    if (si.type_id() != ::pandas::IndexTypeId::IndexString)
        throw std::runtime_error("Index<string> type_id failed");

    // Index<int64>
    ::pandas::Index<numpy::int64> ii(std::vector<numpy::int64>{1, 2, 3});
    if (ii.type_id() != ::pandas::IndexTypeId::IndexInt64)