test(macro): Add test for magic method call

Author: Norbytus

tests/src/integration/magic_method.php

@@ -0,0 +1,38 @@
+<?php
+
+$magicMethod = new MagicMethod();
+
+// __set
+$magicMethod->count = 10;
+// __get
+assert(10 === $magicMethod->count);
+assert(null === $magicMethod->test);
+
+//__isset
+assert(true === isset($magicMethod->count));
+assert(false === isset($magicMethod->noCount));
+
+// __unset
+unset($magicMethod->count);
+assert(0 === $magicMethod->count);
+
+// __toString
+assert("0" === $magicMethod->__toString());
+assert("0" === (string) $magicMethod);
+
+// __invoke
+assert(34 === $magicMethod(34));
+
+// __debugInfo
+$debug = print_r($magicMethod, true);
+$expectedDebug = "MagicMethod Object\n(\n    [count] => 0\n)\n";
+assert($expectedDebug === $debug);
+
+// __call
+assert("Hello" === $magicMethod->callMagicMethod(1, 2, 3));
+assert(null === $magicMethod->callUndefinedMagicMethod());
+
+file_put_contents('/tmp/test.txt', MagicMethod::callStaticSomeMagic(1, 2, 3));
+// __call_static
+assert("Hello from static call 1 2 3" === MagicMethod::callStaticSomeMagic(1, 2, 3));
+assert(null === MagicMethod::callUndefinedStaticSomeMagic());

tests/src/integration/magic_method.rs

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

tests/src/lib.rs

@@ -2,6 +2,7 @@
 use ext_php_rs::{
     binary::Binary,
     boxed::ZBox,
+    convert::IntoZval,
     prelude::*,
     types::{ArrayKey, ZendHashTable, ZendObject, Zval},
     zend::ProcessGlobals,
@@ -210,6 +211,10 @@ impl TestClass {
     pub fn set_number(&mut self, number: i32) {
         self.number = number;
     }
+
+    pub fn static_call(name: String) -> String {
+        format!("Hello {name}")
+    }
 }
 
 #[php_function]
@@ -221,10 +226,100 @@ pub fn test_class(string: String, number: i32) -> TestClass {
     }
 }
 
+#[php_class]
+pub struct MagicMethod(i64);
+
+#[php_impl]
+impl MagicMethod {
+    pub fn __construct() -> Self {
+        Self(0)
+    }
+
+    pub fn __destruct(&self) {}
+
+    pub fn __call(&self, name: String, _arguments: HashMap<String, &Zval>) -> Zval {
+        let mut z = Zval::new();
+        if name == "callMagicMethod" {
+            let s = "Hello".to_string();
+
+            let _ = z.set_string(s.as_str(), false);
+            z
+        } else {
+            z.set_null();
+            z
+        }
+    }
+
+    pub fn __call_static(name: String, arguments: HashMap<String, &Zval>) -> Zval {
+        let mut zval = Zval::new();
+        if name == "callStaticSomeMagic" {
+            let concat_args = format!(
+                "Hello from static call {}",
+                arguments
+                    .iter()
+                    .filter(|(_, v)| v.is_long())
+                    .map(|(_, s)| s.long().unwrap().to_string())
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            );
+
+            let _ = zval.set_string(&concat_args, false);
+            zval
+        } else {
+            zval.set_null();
+            zval
+        }
+    }
+
+    pub fn __get(&self, name: String) -> Zval {
+        let mut v = Zval::new();
+        v.set_null();
+        if name == "count" {
+            v.set_long(self.0);
+        }
+
+        v
+    }
+
+    pub fn __set(&mut self, prop_name: String, val: &Zval) {
+        if val.is_long() && prop_name == "count" {
+            self.0 = val.long().unwrap()
+        }
+    }
+
+    pub fn __isset(&self, prop_name: String) -> bool {
+        "count" == prop_name
+    }
+
+    pub fn __unset(&mut self, prop_name: String) {
+        if prop_name == "count" {
+            self.0 = 0;
+        }
+    }
+
+    pub fn __to_string(&self) -> String {
+        self.0.to_string()
+    }
+
+    pub fn __invoke(&self, n: i64) -> i64 {
+        self.0 + n
+    }
+
+    pub fn __debug_info(&self) -> HashMap<String, Zval> {
+        let mut h: HashMap<String, Zval> = HashMap::new();
+        let mut z = Zval::new();
+        z.set_long(self.0);
+        h.insert("count".to_string(), z);
+
+        h
+    }
+}
+
 #[php_module]
 pub fn build_module(module: ModuleBuilder) -> ModuleBuilder {
     module
         .class::<TestClass>()
+        .class::<MagicMethod>()
         .function(wrap_function!(test_str))
         .function(wrap_function!(test_string))
         .function(wrap_function!(test_bool))
@@ -317,6 +412,7 @@ mod integration {
     mod closure;
     mod globals;
     mod iterator;
+    mod magic_method;
     mod nullable;
     mod number;
     mod object;