test(array): add BTreeMap tests

Refs: extphprs#535

Author: Xenira

src/types/array/conversions/btree_map.rs

@@ -108,3 +108,197 @@ where
         zval.array().and_then(|arr| arr.try_into().ok())
     }
 }
+
+#[cfg(test)]
+#[cfg(feature = "embed")]
+#[allow(clippy::unwrap_used)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use crate::boxed::ZBox;
+    use crate::convert::{FromZval, IntoZval};
+    use crate::embed::Embed;
+    use crate::error::Error;
+    use crate::types::{ArrayKey, ZendHashTable, Zval};
+
+    #[test]
+    fn test_hash_table_try_from_btree_mab() {
+        Embed::run(|| {
+            let mut map = BTreeMap::new();
+            map.insert("key1", "value1");
+            map.insert("key2", "value2");
+            map.insert("key3", "value3");
+
+            let ht: ZBox<ZendHashTable> = map.try_into().unwrap();
+            assert_eq!(ht.len(), 3);
+            assert_eq!(ht.get("key1").unwrap().string().unwrap(), "value1");
+            assert_eq!(ht.get("key2").unwrap().string().unwrap(), "value2");
+            assert_eq!(ht.get("key3").unwrap().string().unwrap(), "value3");
+
+            let mut map_i64 = BTreeMap::new();
+            map_i64.insert(1, "value1");
+            map_i64.insert(2, "value2");
+            map_i64.insert(3, "value3");
+
+            let ht_i64: ZBox<ZendHashTable> = map_i64.try_into().unwrap();
+            assert_eq!(ht_i64.len(), 3);
+            assert_eq!(ht_i64.get(1).unwrap().string().unwrap(), "value1");
+            assert_eq!(ht_i64.get(2).unwrap().string().unwrap(), "value2");
+            assert_eq!(ht_i64.get(3).unwrap().string().unwrap(), "value3");
+        });
+    }
+
+    #[test]
+    fn test_btree_map_into_zval() {
+        Embed::run(|| {
+            let mut map = BTreeMap::new();
+            map.insert("key1", "value1");
+            map.insert("key2", "value2");
+            map.insert("key3", "value3");
+
+            let zval = map.into_zval(false).unwrap();
+            assert!(zval.is_array());
+            let ht: &ZendHashTable = zval.array().unwrap();
+            assert_eq!(ht.len(), 3);
+            assert_eq!(ht.get("key1").unwrap().string().unwrap(), "value1");
+            assert_eq!(ht.get("key2").unwrap().string().unwrap(), "value2");
+            assert_eq!(ht.get("key3").unwrap().string().unwrap(), "value3");
+
+            let mut map_i64 = BTreeMap::new();
+            map_i64.insert(1, "value1");
+            map_i64.insert(2, "value2");
+            map_i64.insert(3, "value3");
+            let zval_i64 = map_i64.into_zval(false).unwrap();
+            assert!(zval_i64.is_array());
+            let ht_i64: &ZendHashTable = zval_i64.array().unwrap();
+            assert_eq!(ht_i64.len(), 3);
+            assert_eq!(ht_i64.get(1).unwrap().string().unwrap(), "value1");
+            assert_eq!(ht_i64.get(2).unwrap().string().unwrap(), "value2");
+            assert_eq!(ht_i64.get(3).unwrap().string().unwrap(), "value3");
+        });
+    }
+
+    #[test]
+    fn test_btree_map_from_zval() {
+        Embed::run(|| {
+            let mut ht = ZendHashTable::new();
+            ht.insert("key1", "value1").unwrap();
+            ht.insert("key2", "value2").unwrap();
+            ht.insert("key3", "value3").unwrap();
+            let mut zval = Zval::new();
+            zval.set_hashtable(ht);
+
+            let map = BTreeMap::<String, String>::from_zval(&zval).unwrap();
+            assert_eq!(map.len(), 3);
+            assert_eq!(map.get("key1").unwrap(), "value1");
+            assert_eq!(map.get("key2").unwrap(), "value2");
+            assert_eq!(map.get("key3").unwrap(), "value3");
+
+            let mut ht_i64 = ZendHashTable::new();
+            ht_i64.insert(1, "value1").unwrap();
+            ht_i64.insert("2", "value2").unwrap();
+            ht_i64.insert(3, "value3").unwrap();
+            let mut zval_i64 = Zval::new();
+            zval_i64.set_hashtable(ht_i64);
+
+            let map_i64 = BTreeMap::<i64, String>::from_zval(&zval_i64).unwrap();
+            assert_eq!(map_i64.len(), 3);
+            assert_eq!(map_i64.get(&1).unwrap(), "value1");
+            assert_eq!(map_i64.get(&2).unwrap(), "value2");
+            assert_eq!(map_i64.get(&3).unwrap(), "value3");
+
+            let mut ht_mixed = ZendHashTable::new();
+            ht_mixed.insert("key1", "value1").unwrap();
+            ht_mixed.insert(2, "value2").unwrap();
+            ht_mixed.insert("3", "value3").unwrap();
+            let mut zval_mixed = Zval::new();
+            zval_mixed.set_hashtable(ht_mixed);
+
+            let map_mixed = BTreeMap::<String, String>::from_zval(&zval_mixed);
+            assert!(map_mixed.is_some());
+        });
+    }
+
+    #[test]
+    fn test_btree_map_array_key_from_zval() {
+        Embed::run(|| {
+            let mut ht = ZendHashTable::new();
+            ht.insert("key1", "value1").unwrap();
+            ht.insert(2, "value2").unwrap();
+            ht.insert("3", "value3").unwrap();
+            let mut zval = Zval::new();
+            zval.set_hashtable(ht);
+
+            let map = BTreeMap::<ArrayKey, String>::from_zval(&zval).unwrap();
+            assert_eq!(map.len(), 3);
+            assert_eq!(
+                map.get(&ArrayKey::String("key1".to_string())).unwrap(),
+                "value1"
+            );
+            assert_eq!(map.get(&ArrayKey::Long(2)).unwrap(), "value2");
+            assert_eq!(map.get(&ArrayKey::Long(3)).unwrap(), "value3");
+        });
+    }
+
+    #[test]
+    fn test_btree_map_i64_v_try_from_hash_table() {
+        Embed::run(|| {
+            let mut ht = ZendHashTable::new();
+            ht.insert(1, "value1").unwrap();
+            ht.insert("2", "value2").unwrap();
+
+            let map: BTreeMap<i64, String> = ht.as_ref().try_into().unwrap();
+            assert_eq!(map.len(), 2);
+            assert_eq!(map.get(&1).unwrap(), "value1");
+            assert_eq!(map.get(&2).unwrap(), "value2");
+
+            let mut ht2 = ZendHashTable::new();
+            ht2.insert("key1", "value1").unwrap();
+            ht2.insert("key2", "value2").unwrap();
+
+            let map_err: crate::error::Result<BTreeMap<i64, String>> = ht2.as_ref().try_into();
+            assert!(map_err.is_err());
+            assert!(matches!(map_err.unwrap_err(), Error::InvalidProperty));
+        });
+    }
+
+    #[test]
+    fn test_btree_map_string_v_try_from_hash_table() {
+        Embed::run(|| {
+            let mut ht = ZendHashTable::new();
+            ht.insert("key1", "value1").unwrap();
+            ht.insert("key2", "value2").unwrap();
+
+            let map: BTreeMap<String, String> = ht.as_ref().try_into().unwrap();
+            assert_eq!(map.len(), 2);
+            assert_eq!(map.get("key1").unwrap(), "value1");
+            assert_eq!(map.get("key2").unwrap(), "value2");
+
+            let mut ht2 = ZendHashTable::new();
+            ht2.insert(1, "value1").unwrap();
+            ht2.insert(2, "value2").unwrap();
+
+            let map2: crate::error::Result<BTreeMap<String, String>> = ht2.as_ref().try_into();
+            assert!(map2.is_ok());
+        });
+    }
+
+    #[test]
+    fn test_btree_map_array_key_v_try_from_hash_table() {
+        Embed::run(|| {
+            let mut ht = ZendHashTable::new();
+            ht.insert("key1", "value1").unwrap();
+            ht.insert(2, "value2").unwrap();
+            ht.insert("3", "value3").unwrap();
+
+            let map: BTreeMap<ArrayKey, String> = ht.as_ref().try_into().unwrap();
+            assert_eq!(map.len(), 3);
+            assert_eq!(
+                map.get(&ArrayKey::String("key1".to_string())).unwrap(),
+                "value1"
+            );
+            assert_eq!(map.get(&ArrayKey::Long(2)).unwrap(), "value2");
+            assert_eq!(map.get(&ArrayKey::Long(3)).unwrap(), "value3");
+        });
+    }
+}

tests/src/integration/array/array.php

@@ -42,10 +42,25 @@
     2 => '2',
     '3' => '3',
 ]);
+$assoc_keys = test_btree_map([
+    'a' => '1',
+    2 => '2',
+    '3' => '3',
+]);
+assert($assoc_keys === [
+    2 => '2',
+    '3' => '3',
+    'a' => '1',
+]);
 
 $assoc_keys = test_array_assoc_array_keys(['foo', 'bar', 'baz']);
 assert($assoc_keys === [
     0 => 'foo',
     1 => 'bar',
     2 => 'baz',
 ]);
+assert(test_btree_map(['foo', 'bar', 'baz']) === [
+    0 => 'foo',
+    1 => 'bar',
+    2 => 'baz',
+]);

tests/src/integration/array/mod.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 
 use ext_php_rs::{
     convert::IntoZval,
@@ -24,6 +24,11 @@ pub fn test_array_assoc_array_keys(a: Vec<(ArrayKey, String)>) -> Vec<(ArrayKey,
     a
 }
 
+#[php_function]
+pub fn test_btree_map(a: BTreeMap<ArrayKey, String>) -> BTreeMap<ArrayKey, String> {
+    a
+}
+
 #[php_function]
 pub fn test_array_keys() -> Zval {
     let mut ht = HashTable::new();
@@ -41,6 +46,7 @@ pub fn build_module(builder: ModuleBuilder) -> ModuleBuilder {
         .function(wrap_function!(test_array))
         .function(wrap_function!(test_array_assoc))
         .function(wrap_function!(test_array_assoc_array_keys))
+        .function(wrap_function!(test_btree_map))
         .function(wrap_function!(test_array_keys))
 }