diff --git a/Cargo.toml b/Cargo.toml
index 0deea94671..29553ff7a7 100644
--- a/Cargo.toml
+++ b/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"]
diff --git a/guide/src/types/binary.md b/guide/src/types/binary.md
index aa296b16cd..74f9f9de3b 100644
--- a/guide/src/types/binary.md
+++ b/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 }
 ```
diff --git a/src/args.rs b/src/args.rs
index 7cd3f62d4a..4bc928f1f0 100644
--- a/src/args.rs
+++ b/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.
diff --git a/src/closure.rs b/src/closure.rs
index 03e02653c7..d9884d133b 100644
--- a/src/closure.rs
+++ b/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);
diff --git a/src/types/zval.rs b/src/types/zval.rs
index f031214f32..d997d53d1f 100644
--- a/src/types/zval.rs
+++ b/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() {
diff --git a/src/zend/_type.rs b/src/zend/_type.rs
index 4342e3fcf4..dc2ba47830 100644
--- a/src/zend/_type.rs
+++ b/src/zend/_type.rs
@@ -1,7 +1,4 @@
-use std::{
-    ffi::{c_void, CString},
-    ptr,
-};
+use std::{ffi::c_void, ptr};
 
 use crate::{
     ffi::{
@@ -9,6 +6,7 @@ use crate::{
         _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
diff --git a/src/zend/try_catch.rs b/src/zend/try_catch.rs
index 2f0696ce72..5d3f56889b 100644
--- a/src/zend/try_catch.rs
+++ b/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
 ///
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
new file mode 100644
index 0000000000..55aef21025
--- /dev/null
+++ b/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"]
\ No newline at end of file
diff --git a/tests/src/integration/_utils.php b/tests/src/integration/_utils.php
new file mode 100644
index 0000000000..2201e1f4f0
--- /dev/null
+++ b/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);
+}
diff --git a/tests/src/integration/array.php b/tests/src/integration/array.php
new file mode 100644
index 0000000000..b17a99eca5
--- /dev/null
+++ b/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));
diff --git a/tests/src/integration/array.rs b/tests/src/integration/array.rs
new file mode 100644
index 0000000000..447ece1bde
--- /dev/null
+++ b/tests/src/integration/array.rs
@@ -0,0 +1,4 @@
+#[test]
+fn binary_works() {
+    assert!(crate::integration::run_php("array.php"));
+}
diff --git a/tests/src/integration/binary.php b/tests/src/integration/binary.php
new file mode 100644
index 0000000000..30cbd429f7
--- /dev/null
+++ b/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));
\ No newline at end of file
diff --git a/tests/src/integration/binary.rs b/tests/src/integration/binary.rs
new file mode 100644
index 0000000000..b47abc3886
--- /dev/null
+++ b/tests/src/integration/binary.rs
@@ -0,0 +1,4 @@
+#[test]
+fn binary_works() {
+    assert!(crate::integration::run_php("binary.php"));
+}
diff --git a/tests/src/integration/bool.php b/tests/src/integration/bool.php
new file mode 100644
index 0000000000..8ebc6a98f9
--- /dev/null
+++ b/tests/src/integration/bool.php
@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(test_bool(true) === true);
+assert(test_bool(false) === false);
diff --git a/tests/src/integration/bool.rs b/tests/src/integration/bool.rs
new file mode 100644
index 0000000000..aadf22aa97
--- /dev/null
+++ b/tests/src/integration/bool.rs
@@ -0,0 +1,4 @@
+#[test]
+fn bool_works() {
+    assert!(crate::integration::run_php("bool.php"));
+}
diff --git a/tests/src/integration/callable.php b/tests/src/integration/callable.php
new file mode 100644
index 0000000000..992cd16167
--- /dev/null
+++ b/tests/src/integration/callable.php
@@ -0,0 +1,5 @@
+<?php
+
+require('_utils.php');
+
+assert(test_callable(fn (string $a) => $a, 'test') === 'test');
diff --git a/tests/src/integration/callable.rs b/tests/src/integration/callable.rs
new file mode 100644
index 0000000000..1d4ac2d512
--- /dev/null
+++ b/tests/src/integration/callable.rs
@@ -0,0 +1,4 @@
+#[test]
+fn callable_works() {
+    assert!(crate::integration::run_php("callable.php"));
+}
diff --git a/tests/src/integration/class.php b/tests/src/integration/class.php
new file mode 100644
index 0000000000..568cafbb17
--- /dev/null
+++ b/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);
diff --git a/tests/src/integration/class.rs b/tests/src/integration/class.rs
new file mode 100644
index 0000000000..525220e859
--- /dev/null
+++ b/tests/src/integration/class.rs
@@ -0,0 +1,4 @@
+#[test]
+fn class_works() {
+    assert!(crate::integration::run_php("class.php"));
+}
diff --git a/tests/src/integration/closure.php b/tests/src/integration/closure.php
new file mode 100644
index 0000000000..7ebe6b79b2
--- /dev/null
+++ b/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);
diff --git a/tests/src/integration/closure.rs b/tests/src/integration/closure.rs
new file mode 100644
index 0000000000..fad7e3c255
--- /dev/null
+++ b/tests/src/integration/closure.rs
@@ -0,0 +1,4 @@
+#[test]
+fn closure_works() {
+    assert!(crate::integration::run_php("closure.php"));
+}
diff --git a/tests/src/integration/nullable.php b/tests/src/integration/nullable.php
new file mode 100644
index 0000000000..f3ba326818
--- /dev/null
+++ b/tests/src/integration/nullable.php
@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(is_null(test_nullable()));
+assert(!is_null(test_nullable('value')));
diff --git a/tests/src/integration/nullable.rs b/tests/src/integration/nullable.rs
new file mode 100644
index 0000000000..5fc911722b
--- /dev/null
+++ b/tests/src/integration/nullable.rs
@@ -0,0 +1,4 @@
+#[test]
+fn nullable_works() {
+    assert!(crate::integration::run_php("nullable.php"));
+}
diff --git a/tests/src/integration/number.php b/tests/src/integration/number.php
new file mode 100644
index 0000000000..822faf93c3
--- /dev/null
+++ b/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));
diff --git a/tests/src/integration/number.rs b/tests/src/integration/number.rs
new file mode 100644
index 0000000000..94a518c4c8
--- /dev/null
+++ b/tests/src/integration/number.rs
@@ -0,0 +1,4 @@
+#[test]
+fn number_works() {
+    assert!(crate::integration::run_php("number.php"));
+}
diff --git a/tests/src/integration/object.php b/tests/src/integration/object.php
new file mode 100644
index 0000000000..c0b4c3fac5
--- /dev/null
+++ b/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]);
diff --git a/tests/src/integration/object.rs b/tests/src/integration/object.rs
new file mode 100644
index 0000000000..11f70dbb7d
--- /dev/null
+++ b/tests/src/integration/object.rs
@@ -0,0 +1,4 @@
+#[test]
+fn object_works() {
+    assert!(crate::integration::run_php("object.php"));
+}
diff --git a/tests/src/integration/string.php b/tests/src/integration/string.php
new file mode 100644
index 0000000000..63e111f56d
--- /dev/null
+++ b/tests/src/integration/string.php
@@ -0,0 +1,6 @@
+<?php
+
+require('_utils.php');
+
+assert(test_str('abc') === 'abc');
+assert(test_string('abc') === 'abc');
diff --git a/tests/src/integration/string.rs b/tests/src/integration/string.rs
new file mode 100644
index 0000000000..8f95dd5df4
--- /dev/null
+++ b/tests/src/integration/string.rs
@@ -0,0 +1,4 @@
+#[test]
+fn string_works() {
+    assert!(crate::integration::run_php("string.php"));
+}
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
new file mode 100644
index 0000000000..88a6b19b4c
--- /dev/null
+++ b/tests/src/lib.rs
@@ -0,0 +1,177 @@
+#![cfg_attr(windows, feature(abi_vectorcall))]
+use ext_php_rs::{binary::Binary, prelude::*, types::ZendObject, types::Zval};
+use std::collections::HashMap;
+
+#[php_function]
+pub fn test_str(a: &str) -> &str {
+    a
+}
+
+#[php_function]
+pub fn test_string(a: String) -> String {
+    a
+}
+
+#[php_function]
+pub fn test_bool(a: bool) -> bool {
+    a
+}
+
+#[php_function]
+pub fn test_number_signed(a: i32) -> i32 {
+    a
+}
+
+#[php_function]
+pub fn test_number_unsigned(a: u32) -> u32 {
+    a
+}
+
+#[php_function]
+pub fn test_number_float(a: f32) -> f32 {
+    a
+}
+
+#[php_function]
+pub fn test_array(a: Vec<String>) -> Vec<String> {
+    a
+}
+
+#[php_function]
+pub fn test_array_assoc(a: HashMap<String, String>) -> HashMap<String, String> {
+    a
+}
+
+#[php_function]
+pub fn test_binary(a: Binary<u32>) -> Binary<u32> {
+    a
+}
+
+#[php_function]
+pub fn test_nullable(a: Option<String>) -> Option<String> {
+    a
+}
+
+#[php_function]
+pub fn test_object(a: &mut ZendObject) -> &mut ZendObject {
+    a
+}
+
+#[php_function]
+pub fn test_closure() -> Closure {
+    Closure::wrap(Box::new(|a| a) as Box<dyn Fn(String) -> String>)
+}
+
+#[php_function]
+pub fn test_closure_once(a: String) -> Closure {
+    Closure::wrap_once(Box::new(move || a) as Box<dyn FnOnce() -> String>)
+}
+
+#[php_function]
+pub fn test_callable(call: ZendCallable, a: String) -> Zval {
+    call.try_call(vec![&a]).expect("Failed to call function")
+}
+
+#[php_class]
+pub struct TestClass {
+    string: String,
+    number: i32,
+    #[prop]
+    boolean: bool,
+}
+
+#[php_impl]
+impl TestClass {
+    #[getter]
+    pub fn get_string(&self) -> String {
+        self.string.to_string()
+    }
+
+    #[setter]
+    pub fn set_string(&mut self, string: String) {
+        self.string = string;
+    }
+
+    #[getter]
+    pub fn get_number(&self) -> i32 {
+        self.number
+    }
+
+    #[setter]
+    pub fn set_number(&mut self, number: i32) {
+        self.number = number;
+    }
+}
+
+#[php_function]
+pub fn test_class(string: String, number: i32) -> TestClass {
+    TestClass {
+        string,
+        number,
+        boolean: true,
+    }
+}
+
+#[php_module]
+pub fn get_module(module: ModuleBuilder) -> ModuleBuilder {
+    module
+}
+
+#[cfg(test)]
+mod integration {
+    use std::process::Command;
+    use std::sync::Once;
+
+    static BUILD: Once = Once::new();
+
+    fn setup() {
+        BUILD.call_once(|| {
+            assert!(Command::new("cargo")
+                .arg("build")
+                .output()
+                .expect("failed to build extension")
+                .status
+                .success());
+        });
+    }
+
+    pub fn run_php(file: &str) -> bool {
+        setup();
+        let output = Command::new("php")
+            .arg(format!(
+                "-dextension=../target/debug/libtests.{}",
+                std::env::consts::DLL_EXTENSION
+            ))
+            .arg("-dassert.active=1")
+            .arg("-dassert.exception=1")
+            .arg("-dzend.assertions=1")
+            .arg(format!("src/integration/{}", file))
+            .output()
+            .expect("failed to run php file");
+        if output.status.success() {
+            true
+        } else {
+            panic!(
+                "
+                status: {}
+                stdout: {}
+                stderr: {}
+                ",
+                output.status,
+                String::from_utf8(output.stdout).unwrap(),
+                String::from_utf8(output.stderr).unwrap()
+            );
+        }
+    }
+
+    mod array;
+    mod binary;
+    mod bool;
+    mod callable;
+    mod class;
+    mod closure;
+    mod nullable;
+    mod number;
+    mod object;
+    mod string;
+}