Add integration tests

Cargo.toml

@@ -41,7 +41,11 @@ closure = []
 embed = []
 
 [workspace]
-members = ["crates/macros", "crates/cli"]
+members = [
+    "crates/macros",
+    "crates/cli",
+    "tests"
+]
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docs"]

guide/src/types/binary.md

@@ -45,7 +45,7 @@ pub fn test_binary(input: Binary<u32>) -> Binary<u32> {
 ```php
 <?php
 
-$data = pack('*L', [1, 2, 3, 4, 5]);
-$output = unpack('*L', test_binary($data));
+$data = pack('L*', 1, 2, 3, 4, 5);
+$output = unpack('L*', test_binary($data));
 var_dump($output); // array(5) { [0] => 5, [1] => 4, [2] => 3, [3] => 2, [4] => 1 }
 ```

src/args.rs

@@ -87,7 +87,7 @@ impl<'a> Arg<'a> {
     {
         self.zval
             .as_mut()
-            .and_then(|zv| T::from_zval_mut(zv))
+            .and_then(|zv| T::from_zval_mut(zv.dereference_mut()))
             .ok_or(self)
     }
 
@@ -98,7 +98,9 @@ impl<'a> Arg<'a> {
     where
         T: FromZvalMut<'a>,
     {
-        self.zval.as_mut().and_then(|zv| T::from_zval_mut(zv))
+        self.zval
+            .as_mut()
+            .and_then(|zv| T::from_zval_mut(zv.dereference_mut()))
     }
 
     /// Attempts to return a reference to the arguments internal Zval.

src/closure.rs

@@ -171,6 +171,7 @@ class_derives!(Closure);
 ///
 /// This trait is automatically implemented on functions with up to 8
 /// parameters.
+#[allow(clippy::missing_safety_doc)]
 pub unsafe trait PhpClosure {
     /// Invokes the closure.
     fn invoke<'a>(&'a mut self, parser: ArgParser<'a, '_>, ret: &mut Zval);

src/types/zval.rs

@@ -51,6 +51,25 @@ impl Zval {
         }
     }
 
+    /// Dereference the zval, if it is a reference.
+    pub fn dereference(&self) -> &Self {
+        return self.reference().or_else(|| self.indirect()).unwrap_or(self);
+    }
+
+    /// Dereference the zval mutable, if it is a reference.
+    pub fn dereference_mut(&mut self) -> &mut Self {
+        // TODO: probably more ZTS work is needed here
+        if self.is_reference() {
+            #[allow(clippy::unwrap_used)]
+            return self.reference_mut().unwrap();
+        }
+        if self.is_indirect() {
+            #[allow(clippy::unwrap_used)]
+            return self.indirect_mut().unwrap();
+        }
+        self
+    }
+
     /// Returns the value of the zval if it is a long.
     pub fn long(&self) -> Option<ZendLong> {
         if self.is_long() {

src/zend/_type.rs

@@ -1,14 +1,12 @@
-use std::{
-    ffi::{c_void, CString},
-    ptr,
-};
+use std::{ffi::c_void, ptr};
 
 use crate::{
     ffi::{
         zend_type, IS_MIXED, MAY_BE_ANY, MAY_BE_BOOL, _IS_BOOL, _ZEND_IS_VARIADIC_BIT,
         _ZEND_SEND_MODE_SHIFT, _ZEND_TYPE_NAME_BIT, _ZEND_TYPE_NULLABLE_BIT,
     },
     flags::DataType,
+    types::ZendStr,
 };
 
 /// Internal Zend type.
@@ -82,7 +80,7 @@ impl ZendType {
         allow_null: bool,
     ) -> Option<Self> {
         Some(Self {
-            ptr: CString::new(class_name).ok()?.into_raw() as *mut c_void,
+            ptr: ZendStr::new(class_name, true).into_raw().as_ptr() as *mut c_void,
             type_mask: _ZEND_TYPE_NAME_BIT
                 | (if allow_null {
                     _ZEND_TYPE_NULLABLE_BIT

src/zend/try_catch.rs

@@ -35,12 +35,13 @@ pub fn try_catch<R, F: FnMut() -> R + RefUnwindSafe>(func: F) -> Result<R, Catch
 
 /// PHP propose a try catch mechanism in C using setjmp and longjmp (bailout)
 /// It store the arg of setjmp into the bailout field of the global executor
-/// If a bailout is triggered, the executor will jump to the setjmp and restore the previous setjmp
+/// If a bailout is triggered, the executor will jump to the setjmp and restore
+/// the previous setjmp
 ///
 /// try_catch_first allow to use this mechanism
 ///
-/// This functions differs from ['try_catch'] as it also initialize the bailout mechanism
-/// for the first time
+/// This functions differs from ['try_catch'] as it also initialize the bailout
+/// mechanism for the first time
 ///
 /// # Returns
 ///

tests/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tests"
+version = "0.0.0"
+edition = "2021"
+publish = false
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+ext-php-rs = { path = "../", features = ["closure"] }
+
+[lib]
+crate-type = ["cdylib"]

tests/src/integration/_utils.php

@@ -0,0 +1,11 @@
+<?php
+
+function assert_exception_thrown(callable $callback): void
+{
+    try {
+        call_user_func($callback);
+    } catch (\Throwable $th) {
+        return;
+    }
+    throw new Exception("Excption was not thrown", 255);
+}

tests/src/integration/array.php

@@ -0,0 +1,26 @@
+<?php
+
+require('_utils.php');
+
+// Tests sequential arrays
+$array = test_array(['a', 'b', 'c']);
+
+assert(is_array($array));
+assert(count($array) === 3);
+assert(in_array('a', $array));
+assert(in_array('b', $array));
+assert(in_array('c', $array));
+
+// Tests associative arrays
+$assoc = test_array_assoc([
+    'a' => '1',
+    'b' => '2',
+    'c' => '3'
+]);
+
+assert(array_key_exists('a', $assoc));
+assert(array_key_exists('b', $assoc));
+assert(array_key_exists('c', $assoc));
+assert(in_array('1', $assoc));
+assert(in_array('2', $assoc));
+assert(in_array('3', $assoc));

tests/src/integration/array.rs

@@ -0,0 +1,4 @@
+#[test]
+fn binary_works() {
+    assert!(crate::integration::run_php("array.php"));
+}

tests/src/integration/binary.php

@@ -0,0 +1,13 @@
+<?php
+
+require('_utils.php');
+
+$bin = test_binary(pack('L*', 1, 2, 3, 4, 5));
+$result = unpack('L*', $bin);
+
+assert(count($result) === 5);
+assert(in_array(1, $result));
+assert(in_array(2, $result));
+assert(in_array(3, $result));
+assert(in_array(4, $result));
+assert(in_array(5, $result));

tests/src/integration/binary.rs

@@ -0,0 +1,4 @@
+#[test]
+fn binary_works() {
+    assert!(crate::integration::run_php("binary.php"));
+}

tests/src/integration/bool.php

@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(test_bool(true) === true);
+assert(test_bool(false) === false);

tests/src/integration/bool.rs

@@ -0,0 +1,4 @@
+#[test]
+fn bool_works() {
+    assert!(crate::integration::run_php("bool.php"));
+}

tests/src/integration/callable.php

@@ -0,0 +1,5 @@
+<?php
+
+require('_utils.php');
+
+assert(test_callable(fn (string $a) => $a, 'test') === 'test');

tests/src/integration/callable.rs

@@ -0,0 +1,4 @@
+#[test]
+fn callable_works() {
+    assert!(crate::integration::run_php("callable.php"));
+}

tests/src/integration/class.php

@@ -0,0 +1,21 @@
+<?php
+
+require('_utils.php');
+
+// Tests constructor
+$class = test_class('lorem ipsum', 2022);
+assert($class instanceof TestClass);
+
+// Tests getter/setter
+assert($class->getString() === 'lorem ipsum');
+$class->setString('dolor et');
+assert($class->getString() === 'dolor et');
+
+assert($class->getNumber() === 2022);
+$class->setNumber(2023);
+assert($class->getNumber() === 2023);
+
+// Tests #prop decorator
+assert($class->boolean);
+$class->boolean = false;
+assert($class->boolean === false);

tests/src/integration/class.rs

@@ -0,0 +1,4 @@
+#[test]
+fn class_works() {
+    assert!(crate::integration::run_php("class.php"));
+}

tests/src/integration/closure.php

@@ -0,0 +1,14 @@
+<?php
+
+require('_utils.php');
+
+$v = test_closure();
+
+// Closure
+assert($v('works') === 'works');
+
+// Closure once
+$closure = test_closure_once('test');
+
+assert(call_user_func($closure) === 'test');
+assert_exception_thrown($closure);

tests/src/integration/closure.rs

@@ -0,0 +1,4 @@
+#[test]
+fn closure_works() {
+    assert!(crate::integration::run_php("closure.php"));
+}

tests/src/integration/nullable.php

@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(is_null(test_nullable()));
+assert(!is_null(test_nullable('value')));

tests/src/integration/nullable.rs

@@ -0,0 +1,4 @@
+#[test]
+fn nullable_works() {
+    assert!(crate::integration::run_php("nullable.php"));
+}

tests/src/integration/number.php

@@ -0,0 +1,18 @@
+<?php
+
+require('_utils.php');
+
+// Signed
+assert(test_number_signed(-12) === -12);
+assert(test_number_signed(0) === 0);
+assert(test_number_signed(12) === 12);
+
+// Unsigned
+assert(test_number_unsigned(0) === 0);
+assert(test_number_unsigned(12) === 12);
+assert_exception_thrown(fn () => test_number_unsigned(-12));
+
+// Float
+assert(round(test_number_float(-1.2), 2) === round(-1.2, 2));
+assert(round(test_number_float(0.0), 2) === round(0.0, 2));
+assert(round(test_number_float(1.2), 2) === round(1.2, 2));

tests/src/integration/number.rs

@@ -0,0 +1,4 @@
+#[test]
+fn number_works() {
+    assert!(crate::integration::run_php("number.php"));
+}

tests/src/integration/object.php

@@ -0,0 +1,16 @@
+<?php
+
+$obj = new stdClass;
+$obj->string = 'string';
+$obj->bool = true;
+$obj->number = 2022;
+$obj->array = [
+    1, 2, 3
+];
+
+$test = test_object($obj);
+
+assert($test->string === 'string');
+assert($test->bool === true);
+assert($test->number === 2022);
+assert($test->array === [1, 2, 3]);

tests/src/integration/object.rs

@@ -0,0 +1,4 @@
+#[test]
+fn object_works() {
+    assert!(crate::integration::run_php("object.php"));
+}

tests/src/integration/string.php

@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(test_str('abc') === 'abc');
+assert(test_string('abc') === 'abc');

tests/src/integration/string.rs

@@ -0,0 +1,4 @@
+#[test]
+fn string_works() {
+    assert!(crate::integration::run_php("string.php"));
+}