Add Python-native dict/set lookup tests with wrapped class keys

- Add wrap-hash annotation and operator==/!= to Item class for Python hashability
- Add getHashValue() method that combines both value_ and name_ for proper hashing
- Update tests to use Python d[key] and 'in' operator instead of iteration
- Remove unnecessary C++ lookup functions (lookupMapIntToItem, hasKeyMapIntToItem, etc.)
- Tests now verify that wrapped classes work correctly as Python dict keys

This enables Python code like:
  result = t.createMapItemToInt(3)
  item = m.Item(1)
  assert result[item] == 10  # Direct Python dict lookup!

Author: claude

tests/test_files/wrapped_container_test.hpp

@@ -30,10 +30,20 @@ class Item {
     bool operator==(const Item& other) const {
         return value_ == other.value_ && name_ == other.name_;
     }
+    bool operator!=(const Item& other) const {
+        return !(*this == other);
+    }
 
     int getValue() const { return value_; }
     void setValue(int v) { value_ = v; }
     std::string getName() const { return name_; }
+
+    // For Python __hash__ - returns combined hash of both members
+    size_t getHashValue() const {
+        size_t h1 = std::hash<int>()(value_);
+        size_t h2 = std::hash<std::string>()(name_);
+        return h1 ^ (h2 << 1);
+    }
 };
 
 // Hash function for Item - required for unordered_map/unordered_set
@@ -119,20 +129,6 @@ class WrappedContainerTest {
         return result;
     }
 
-    // Lookup Item by key - returns Item value_ or -1 if not found
-    int lookupMapIntToItem(const std::map<int, Item>& m, int key) {
-        auto it = m.find(key);
-        if (it != m.end()) {
-            return it->second.value_;
-        }
-        return -1;
-    }
-
-    // Check if key exists in map
-    bool hasKeyMapIntToItem(const std::map<int, Item>& m, int key) {
-        return m.count(key) > 0;
-    }
-
     // ========================================
     // MAP WITH WRAPPED CLASS AS KEY
     // ========================================
@@ -248,20 +244,6 @@ class WrappedContainerTest {
         return result;
     }
 
-    // Lookup Item by key in unordered_map - returns Item value_ or -1 if not found
-    int lookupUnorderedMapIntToItem(const std::unordered_map<int, Item>& m, int key) {
-        auto it = m.find(key);
-        if (it != m.end()) {
-            return it->second.value_;
-        }
-        return -1;
-    }
-
-    // Check if key exists in unordered_map
-    bool hasKeyUnorderedMapIntToItem(const std::unordered_map<int, Item>& m, int key) {
-        return m.count(key) > 0;
-    }
-
     // ========================================
     // UNORDERED_MAP WITH WRAPPED CLASS AS BOTH KEY AND VALUE
     // ========================================
@@ -357,20 +339,6 @@ class WrappedContainerTest {
         return result;
     }
 
-    // Check if Item exists in unordered_set (membership test using hash)
-    bool hasItemUnorderedSet(const std::unordered_set<Item>& items, const Item& item) {
-        return items.count(item) > 0;
-    }
-
-    // Find Item and return its value_ or -1 if not found
-    int findItemUnorderedSet(const std::unordered_set<Item>& items, const Item& item) {
-        auto it = items.find(item);
-        if (it != items.end()) {
-            return it->value_;
-        }
-        return -1;
-    }
-
     // ========================================
     // NESTED CONTAINERS: list<vector<int>>
     // ========================================

tests/test_files/wrapped_container_test.pxd

@@ -13,7 +13,11 @@ from libcpp cimport bool
 cdef extern from "wrapped_container_test.hpp":
 
     # A simple wrapped class used in containers
+    # wrap-hash and operator== enable Python dict/set lookups with d[item]
     cdef cppclass Item:
+        # wrap-hash:
+        #   getHashValue()
+
         int value_
         libcpp_string name_
 
@@ -22,9 +26,13 @@ cdef extern from "wrapped_container_test.hpp":
         Item(int v, libcpp_string n)
         Item(Item&)
 
+        bool operator==(Item)
+        bool operator!=(Item)
+
         int getValue()
         void setValue(int v)
         libcpp_string getName()
+        size_t getHashValue()
 
     # Test class with methods that use containers of wrapped classes
     cdef cppclass WrappedContainerTest:
@@ -51,8 +59,6 @@ cdef extern from "wrapped_container_test.hpp":
         # ========================================
         int sumMapValues(libcpp_map[int, Item]& m)
         libcpp_map[int, Item] createMapIntToItem(int count)
-        int lookupMapIntToItem(libcpp_map[int, Item]& m, int key)
-        bool hasKeyMapIntToItem(libcpp_map[int, Item]& m, int key)
 
         # ========================================
         # MAP WITH WRAPPED CLASS AS KEY
@@ -91,8 +97,6 @@ cdef extern from "wrapped_container_test.hpp":
         # ========================================
         int sumUnorderedMapValues(libcpp_unordered_map[int, Item]& m)
         libcpp_unordered_map[int, Item] createUnorderedMapIntToItem(int count)
-        int lookupUnorderedMapIntToItem(libcpp_unordered_map[int, Item]& m, int key)
-        bool hasKeyUnorderedMapIntToItem(libcpp_unordered_map[int, Item]& m, int key)
 
         # ========================================
         # UNORDERED_MAP WITH WRAPPED CLASS AS BOTH KEY AND VALUE
@@ -122,8 +126,6 @@ cdef extern from "wrapped_container_test.hpp":
         # ========================================
         int sumUnorderedSetItems(libcpp_unordered_set[Item]& items)
         libcpp_unordered_set[Item] createUnorderedSetItems(int count)
-        bool hasItemUnorderedSet(libcpp_unordered_set[Item]& items, Item& item)
-        int findItemUnorderedSet(libcpp_unordered_set[Item]& items, Item& item)
 
         # ========================================
         # NESTED CONTAINERS: list<vector<int>>

tests/test_wrapped_containers.py

@@ -144,37 +144,6 @@ def test_map_int_to_item_create(self, wrapped_container_module):
         assert result[1].value_ == 10
         assert result[2].value_ == 20
 
-    def test_map_int_to_item_lookup(self, wrapped_container_module):
-        """Test looking up Item by key in map."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
-
-        item1 = m.Item(100)
-        item2 = m.Item(200)
-        item3 = m.Item(300)
-        map_data = {1: item1, 5: item2, 10: item3}
-
-        # Lookup existing keys
-        assert t.lookupMapIntToItem(map_data, 1) == 100
-        assert t.lookupMapIntToItem(map_data, 5) == 200
-        assert t.lookupMapIntToItem(map_data, 10) == 300
-
-        # Lookup missing key
-        assert t.lookupMapIntToItem(map_data, 999) == -1
-
-    def test_map_int_to_item_has_key(self, wrapped_container_module):
-        """Test checking if key exists in map."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
-
-        item1 = m.Item(100)
-        item2 = m.Item(200)
-        map_data = {1: item1, 2: item2}
-
-        assert t.hasKeyMapIntToItem(map_data, 1) is True
-        assert t.hasKeyMapIntToItem(map_data, 2) is True
-        assert t.hasKeyMapIntToItem(map_data, 3) is False
-        assert t.hasKeyMapIntToItem(map_data, 999) is False
 
 
 class TestMapWithWrappedClassKey:
@@ -193,16 +162,25 @@ def test_map_item_to_int_sum(self, wrapped_container_module):
         assert result == 30  # 10 + 20 (sum of keys)
 
     def test_map_item_to_int_create(self, wrapped_container_module):
-        """Test returning map<Item, int>."""
+        """Test returning map<Item, int> and using Python d[key] lookup."""
         m = wrapped_container_module
         t = m.WrappedContainerTest()
 
         result = t.createMapItemToInt(3)
         assert len(result) == 3
-        # Values should be 0, 10, 20 for keys with value_ 0, 1, 2
-        keys_values = [(k.value_, v) for k, v in result.items()]
-        keys_values.sort()
-        assert keys_values == [(0, 0), (1, 10), (2, 20)]
+
+        # Direct Python dict lookup with wrapped class key - NOT iteration!
+        key0 = m.Item(0)
+        key1 = m.Item(1)
+        key2 = m.Item(2)
+        assert result[key0] == 0
+        assert result[key1] == 10
+        assert result[key2] == 20
+
+        # Test 'in' operator
+        assert key1 in result
+        missing = m.Item(999)
+        assert missing not in result
 
 
 class TestNestedVectorOfWrappedClass:
@@ -300,16 +278,26 @@ def test_unordered_map_item_to_int_sum(self, wrapped_container_module):
         assert result == 30  # 10 + 20 (sum of keys)
 
     def test_unordered_map_item_to_int_create(self, wrapped_container_module):
-        """Test returning unordered_map<Item, int>."""
+        """Test returning unordered_map<Item, int> and using Python d[key] lookup."""
         m = wrapped_container_module
         t = m.WrappedContainerTest()
 
         result = t.createUnorderedMapItemToInt(3)
         assert len(result) == 3
-        # Values should be 0, 10, 20 for keys with value_ 0, 1, 2
-        keys_values = [(k.value_, v) for k, v in result.items()]
-        keys_values.sort()
-        assert keys_values == [(0, 0), (1, 10), (2, 20)]
+
+        # Direct Python dict lookup with wrapped class key - NOT iteration!
+        # This tests that the wrapped Item class has proper __hash__ and __eq__
+        key0 = m.Item(0)
+        key1 = m.Item(1)
+        key2 = m.Item(2)
+        assert result[key0] == 0
+        assert result[key1] == 10
+        assert result[key2] == 20
+
+        # Test 'in' operator (uses hash)
+        assert key1 in result
+        missing = m.Item(999)
+        assert missing not in result
 
 
 class TestUnorderedMapWithWrappedClassValue:
@@ -338,37 +326,6 @@ def test_unordered_map_int_to_item_create(self, wrapped_container_module):
         assert result[1].value_ == 10
         assert result[2].value_ == 20
 
-    def test_unordered_map_int_to_item_lookup(self, wrapped_container_module):
-        """Test looking up Item by key in unordered_map (hash-based O(1) lookup)."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
-
-        item1 = m.Item(100)
-        item2 = m.Item(200)
-        item3 = m.Item(300)
-        map_data = {1: item1, 5: item2, 10: item3}
-
-        # Lookup existing keys - tests hash-based access
-        assert t.lookupUnorderedMapIntToItem(map_data, 1) == 100
-        assert t.lookupUnorderedMapIntToItem(map_data, 5) == 200
-        assert t.lookupUnorderedMapIntToItem(map_data, 10) == 300
-
-        # Lookup missing key
-        assert t.lookupUnorderedMapIntToItem(map_data, 999) == -1
-
-    def test_unordered_map_int_to_item_has_key(self, wrapped_container_module):
-        """Test checking if key exists in unordered_map (hash-based O(1) lookup)."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
-
-        item1 = m.Item(100)
-        item2 = m.Item(200)
-        map_data = {1: item1, 2: item2}
-
-        assert t.hasKeyUnorderedMapIntToItem(map_data, 1) is True
-        assert t.hasKeyUnorderedMapIntToItem(map_data, 2) is True
-        assert t.hasKeyUnorderedMapIntToItem(map_data, 3) is False
-        assert t.hasKeyUnorderedMapIntToItem(map_data, 999) is False
 
 
 class TestUnorderedMapWithWrappedClassBoth:
@@ -491,63 +448,34 @@ def test_unordered_set_items_sum(self, wrapped_container_module):
         assert result == 60
 
     def test_unordered_set_items_create(self, wrapped_container_module):
-        """Test returning unordered_set<Item>."""
+        """Test returning unordered_set<Item> and using Python 'in' operator."""
         m = wrapped_container_module
         t = m.WrappedContainerTest()
 
         items = t.createUnorderedSetItems(3)
         assert len(items) == 3
-        values = sorted([item.value_ for item in items])
-        assert values == [0, 10, 20]
-
-    def test_unordered_set_has_item(self, wrapped_container_module):
-        """Test checking if Item exists in unordered_set (hash-based O(1) membership test)."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
 
+        # Direct Python 'in' operator with wrapped class - NOT iteration!
+        # This tests that the wrapped Item class has proper __hash__ and __eq__
+        item0 = m.Item(0)
         item1 = m.Item(10)
         item2 = m.Item(20)
-        item3 = m.Item(30)
-        items = {item1, item2, item3}
-
-        # Items that should be found (tests hash function)
-        search_item1 = m.Item(10)
-        search_item2 = m.Item(20)
-        assert t.hasItemUnorderedSet(items, search_item1) is True
-        assert t.hasItemUnorderedSet(items, search_item2) is True
-
-        # Item that should NOT be found
-        missing_item = m.Item(999)
-        assert t.hasItemUnorderedSet(items, missing_item) is False
-
-    def test_unordered_set_find_item(self, wrapped_container_module):
-        """Test finding Item in unordered_set and returning its value (hash-based O(1) lookup)."""
-        m = wrapped_container_module
-        t = m.WrappedContainerTest()
+        assert item0 in items
+        assert item1 in items
+        assert item2 in items
 
-        item1 = m.Item(10)
-        item2 = m.Item(20)
-        item3 = m.Item(30)
-        items = {item1, item2, item3}
-
-        # Find existing items - tests hash-based lookup
-        search_item1 = m.Item(10)
-        search_item2 = m.Item(30)
-        assert t.findItemUnorderedSet(items, search_item1) == 10
-        assert t.findItemUnorderedSet(items, search_item2) == 30
-
-        # Find missing item should return -1
-        missing_item = m.Item(999)
-        assert t.findItemUnorderedSet(items, missing_item) == -1
+        # Test missing item
+        missing = m.Item(999)
+        assert missing not in items
 
     def test_unordered_set_two_member_hash(self, wrapped_container_module):
         """Test that hash function uses both value_ AND name_ members.
 
         This verifies that items with the same value_ but different name_
         are treated as different items (different hash + equality check).
+        Uses Python's native 'in' operator - no C++ lookup functions.
         """
         m = wrapped_container_module
-        t = m.WrappedContainerTest()
 
         # Create items with same value but different names
         item_alice = m.Item(100, b"alice")
@@ -559,24 +487,22 @@ def test_unordered_set_two_member_hash(self, wrapped_container_module):
         # All three should be in the set (even though two have same value_)
         assert len(items) == 3, "Set should have 3 items despite same value_"
 
-        # Search for exact match (value_ AND name_ must match)
+        # Search for exact match using Python 'in' (value_ AND name_ must match)
         search_alice = m.Item(100, b"alice")
         search_bob = m.Item(100, b"bob")
 
-        assert t.hasItemUnorderedSet(items, search_alice) is True, \
-            "Should find alice (100, 'alice')"
-        assert t.hasItemUnorderedSet(items, search_bob) is True, \
-            "Should find bob (100, 'bob')"
+        assert search_alice in items, "Should find alice (100, 'alice')"
+        assert search_bob in items, "Should find bob (100, 'bob')"
 
         # Search with wrong name should NOT find item
         # Same value_ but different name_ = different hash/different item
         wrong_name = m.Item(100, b"eve")
-        assert t.hasItemUnorderedSet(items, wrong_name) is False, \
+        assert wrong_name not in items, \
             "Should NOT find (100, 'eve') - name doesn't match"
 
         # Search with wrong value should NOT find item
         wrong_value = m.Item(999, b"alice")
-        assert t.hasItemUnorderedSet(items, wrong_value) is False, \
+        assert wrong_value not in items, \
             "Should NOT find (999, 'alice') - value doesn't match"