Add integration tests for function arguments.

Author: jmjoy

phper/src/arrays.rs

@@ -31,6 +31,7 @@ impl Array {
         &mut self.inner
     }
 
+    // TODO key should be int or string.
     pub fn insert(&mut self, key: impl AsRef<str>, value: Val) {
         let key = key.as_ref();
         let value = EBox::new(value);
@@ -64,3 +65,13 @@ impl Drop for Array {
         }
     }
 }
+
+impl Clone for Array {
+    fn clone(&self) -> Self {
+        let mut other = Self::new();
+        unsafe {
+            zend_hash_copy(other.as_mut_ptr(), self.as_ptr() as *mut _, None);
+        }
+        other
+    }
+}

phper/src/objects.rs

@@ -4,6 +4,7 @@ use crate::{
     values::{SetVal, Val},
     ClassNotFoundError,
 };
+use phper_alloc::EBox;
 use std::{
     mem::{forget, zeroed},
     ptr::null_mut,
@@ -109,6 +110,13 @@ impl Object {
             }
         }
     }
+
+    pub fn clone_obj(&self) -> EBox<Self> {
+        unsafe {
+            let new_obj = zend_objects_clone_obj(self.as_ptr() as *mut _).cast();
+            EBox::from_raw(new_obj)
+        }
+    }
 }
 
 impl Drop for Object {

phper/src/values.rs

@@ -149,7 +149,7 @@ impl Val {
         if self.get_type().is_long() {
             unsafe { Ok(self.inner.value.lval) }
         } else {
-            Err(self.must_be_type_error("long").into())
+            Err(self.must_be_type_error("int").into())
         }
     }
 

tests/integration/src/arguments.rs

@@ -1,4 +1,6 @@
-use phper::{functions::Argument, modules::Module, values::Val};
+use phper::{
+    alloc::EBox, arrays::Array, functions::Argument, modules::Module, objects::Object, values::Val,
+};
 
 pub fn integrate(module: &mut Module) {
     integrate_arguments(module);
@@ -8,6 +10,68 @@ fn integrate_arguments(module: &mut Module) {
     module.add_function(
         "integrate_arguments_null",
         |arguments: &mut [Val]| arguments[0].as_null(),
-        vec![Argument::by_val("n")],
+        vec![Argument::by_val("a")],
+    );
+
+    module.add_function(
+        "integrate_arguments_long",
+        |arguments: &mut [Val]| -> phper::Result<i64> {
+            let a = arguments[0].as_long()?;
+            let b = arguments[1].as_long_value();
+            Ok(a + b)
+        },
+        vec![Argument::by_val("a"), Argument::by_val("b")],
+    );
+
+    module.add_function(
+        "integrate_arguments_double",
+        |arguments: &mut [Val]| arguments[0].as_double(),
+        vec![Argument::by_val("a")],
+    );
+
+    module.add_function(
+        "integrate_arguments_string",
+        |arguments: &mut [Val]| -> phper::Result<String> {
+            let a = arguments[0].as_string()?;
+            let b = arguments[1].as_string_value()?;
+            Ok(format!("{}, {}", a, b))
+        },
+        vec![Argument::by_val("a"), Argument::by_val("b")],
+    );
+
+    module.add_function(
+        "integrate_arguments_array",
+        |arguments: &mut [Val]| -> phper::Result<EBox<Array>> {
+            let a = arguments[0].as_array()?;
+            let mut a = a.clone();
+            a.insert("foo", Val::new("bar"));
+            Ok(EBox::new(a))
+        },
+        vec![Argument::by_val("a")],
+    );
+
+    module.add_function(
+        "integrate_arguments_object",
+        |arguments: &mut [Val]| -> phper::Result<EBox<Object>> {
+            let a = arguments[0].as_object()?;
+            let mut a = a.clone_obj();
+            a.set_property("foo", Val::new("bar"));
+            Ok(a)
+        },
+        vec![Argument::by_val("a")],
+    );
+
+    module.add_function(
+        "integrate_arguments_optional",
+        |arguments: &mut [Val]| -> phper::Result<String> {
+            let a = arguments[0].as_string()?;
+            let b = arguments
+                .get(1)
+                .map(|b| b.as_bool())
+                .transpose()?
+                .unwrap_or_default();
+            Ok(format!("{}: {}", a, b))
+        },
+        vec![Argument::by_val("a"), Argument::by_val_optional("b")],
     );
 }

tests/integration/tests/php/arguments.php

@@ -5,3 +5,27 @@
 assert_eq(integrate_arguments_null(null), null);
 assert_throw(function () { integrate_arguments_null(); }, "ArgumentCountError", 0, "integrate_arguments_null(): expects at least 1 parameter(s), 0 given");
 assert_throw(function () { integrate_arguments_null(1); }, "TypeError", 0, "type error: must be of type null, int given");
+
+assert_eq(integrate_arguments_long(1, 2), 3);
+assert_eq(integrate_arguments_long(1, "2"), 3);
+assert_throw(function () { integrate_arguments_long("1", "2"); }, "TypeError", 0, "type error: must be of type int, string given");
+
+assert_eq(integrate_arguments_double(1.0), 1.0);
+assert_throw(function () { integrate_arguments_double(1); }, "TypeError", 0, "type error: must be of type float, int given");
+
+assert_eq(integrate_arguments_string("hello", "world"), "hello, world");
+assert_eq(integrate_arguments_string("hello", 123), "hello, 123");
+assert_throw(function () { integrate_arguments_string(1, 2); }, "TypeError", 0, "type error: must be of type string, int given");
+
+assert_eq(integrate_arguments_array(["a" => 1]), ["a" => 1, "foo" => "bar"]);
+assert_throw(function () { integrate_arguments_array(null); }, "TypeError", 0, "type error: must be of type array, null given");
+
+$obj = new stdClass();
+$obj->a = 1;
+assert_object(integrate_arguments_object($obj), "stdClass", ["a" => 1, "foo" => "bar"]);
+assert_throw(function () { integrate_arguments_object(1); }, "TypeError", 0, "type error: must be of type object, int given");
+
+assert_throw(function () { integrate_arguments_optional(); }, "ArgumentCountError", 0, "integrate_arguments_optional(): expects at least 1 parameter(s), 0 given");
+assert_eq(integrate_arguments_optional("foo"), "foo: false");
+assert_eq(integrate_arguments_optional("foo", true), "foo: true");
+assert_eq(integrate_arguments_optional("foo", true, "bar"), "foo: true");