Add classes implements method and errors tests. (#90)

Author: jmjoy

phper/src/classes.rs

@@ -36,6 +36,18 @@ use std::{
     rc::Rc,
 };
 
+/// Predefined interface `Iterator`.
+#[inline]
+pub fn iterator_class<'a>() -> &'a ClassEntry {
+    unsafe { ClassEntry::from_ptr(zend_ce_iterator) }
+}
+
+/// Predefined interface `ArrayAccess`.
+#[inline]
+pub fn array_access_class<'a>() -> &'a ClassEntry {
+    unsafe { ClassEntry::from_ptr(zend_ce_arrayaccess) }
+}
+
 /// Wrapper of [crate::sys::zend_class_entry].
 #[repr(transparent)]
 pub struct ClassEntry {
@@ -128,9 +140,8 @@ impl ClassEntry {
         }
     }
 
-    #[allow(clippy::useless_conversion)]
-    pub fn instance_of(&self, parent: &ClassEntry) -> bool {
-        unsafe { phper_instanceof_function(self.as_ptr(), parent.as_ptr()) != false.into() }
+    pub fn is_instance_of(&self, parent: &ClassEntry) -> bool {
+        unsafe { phper_instanceof_function(self.as_ptr(), parent.as_ptr()) }
     }
 }
 
@@ -164,6 +175,7 @@ pub struct ClassEntity<T> {
     method_entities: Vec<MethodEntity>,
     property_entities: Vec<PropertyEntity>,
     parent: Option<Box<dyn Fn() -> &'static ClassEntry>>,
+    interfaces: Vec<Box<dyn Fn() -> &'static ClassEntry>>,
     _p: PhantomData<(*mut (), T)>,
 }
 
@@ -189,6 +201,7 @@ impl<T: 'static> ClassEntity<T> {
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
+            interfaces: Vec::new(),
             _p: PhantomData,
         }
     }
@@ -234,6 +247,10 @@ impl<T: 'static> ClassEntity<T> {
         self.parent = Some(Box::new(parent));
     }
 
+    pub fn implements(&mut self, interface: impl Fn() -> &'static ClassEntry + 'static) {
+        self.interfaces.push(Box::new(interface));
+    }
+
     #[allow(clippy::useless_conversion)]
     pub(crate) unsafe fn init(&mut self) -> *mut zend_class_entry {
         let parent: *mut zend_class_entry = self
@@ -251,6 +268,11 @@ impl<T: 'static> ClassEntity<T> {
             parent.cast(),
         );
 
+        for interface in &self.interfaces {
+            let interface_ce = interface().as_ptr();
+            zend_class_implements(class_ce, 1, interface_ce);
+        }
+
         *phper_get_create_object(class_ce) = Some(create_object);
 
         class_ce

phper/src/errors.rs

@@ -184,8 +184,8 @@ pub enum Error {
 }
 
 impl Error {
-    pub fn boxed(e: impl error::Error + 'static) -> Self {
-        Self::Boxed(Box::new(e))
+    pub fn boxed(e: impl Into<Box<dyn error::Error>> + 'static) -> Self {
+        Self::Boxed(e.into())
     }
 
     pub fn throw(t: impl Throwable) -> Self {
@@ -283,7 +283,7 @@ pub struct ThrowObject(ZObject);
 
 impl ThrowObject {
     pub fn new(obj: ZObject) -> result::Result<Self, NotImplementThrowableError> {
-        if !obj.get_class().instance_of(throwable_class()) {
+        if !obj.get_class().is_instance_of(throwable_class()) {
             return Err(NotImplementThrowableError);
         }
         Ok(Self(obj))

tests/integration/src/classes.rs

@@ -9,14 +9,17 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    classes::{ClassEntity, Visibility},
+    alloc::RefClone,
+    classes::{array_access_class, iterator_class, ClassEntity, Visibility},
     functions::Argument,
     modules::Module,
     values::ZVal,
 };
+use std::collections::HashMap;
 
 pub fn integrate(module: &mut Module) {
     integrate_a(module);
+    integrate_foo(module);
 }
 
 fn integrate_a(module: &mut Module) {
@@ -48,3 +51,79 @@ fn integrate_a(module: &mut Module) {
 
     module.add_class(class);
 }
+
+struct Foo {
+    position: usize,
+    array: HashMap<i64, ZVal>,
+}
+
+fn integrate_foo(module: &mut Module) {
+    let mut class = ClassEntity::new_with_state_constructor("IntegrationTest\\Foo", || Foo {
+        position: 0,
+        array: Default::default(),
+    });
+
+    class.implements(iterator_class);
+    class.implements(array_access_class);
+
+    // Implement Iterator interface.
+    class.add_method("current", Visibility::Public, |this, _arguments| {
+        let state = this.as_state();
+        Ok::<_, phper::Error>(format!("Current: {}", state.position))
+    });
+    class.add_method("key", Visibility::Public, |this, _arguments| {
+        let state = this.as_state();
+        Ok::<_, phper::Error>(state.position as i64)
+    });
+    class.add_method("next", Visibility::Public, |this, _arguments| {
+        let state = this.as_mut_state();
+        state.position += 1;
+    });
+    class.add_method("rewind", Visibility::Public, |this, _arguments| {
+        let state = this.as_mut_state();
+        state.position = 0;
+    });
+    class.add_method("valid", Visibility::Public, |this, _arguments| {
+        let state = this.as_state();
+        state.position < 3
+    });
+
+    // Implement ArrayAccess interface.
+    class
+        .add_method("offsetExists", Visibility::Public, |this, arguments| {
+            let offset = arguments[0].expect_long()?;
+            let state = this.as_state();
+            Ok::<_, phper::Error>(state.array.get(&offset).is_some())
+        })
+        .argument(Argument::by_val("offset"));
+
+    class
+        .add_method("offsetGet", Visibility::Public, |this, arguments| {
+            let offset = arguments[0].expect_long()?;
+            let state = this.as_mut_state();
+            let val = state.array.get_mut(&offset).map(|val| val.ref_clone());
+            Ok::<_, phper::Error>(val)
+        })
+        .argument(Argument::by_val("offset"));
+
+    class
+        .add_method("offsetSet", Visibility::Public, |this, arguments| {
+            let offset = arguments[0].expect_long()?;
+            let value = arguments[1].clone();
+            let state = this.as_mut_state();
+            state.array.insert(offset, value);
+            Ok::<_, phper::Error>(())
+        })
+        .arguments([Argument::by_val("offset"), Argument::by_val("value")]);
+
+    class
+        .add_method("offsetUnset", Visibility::Public, |this, arguments| {
+            let offset = arguments[0].expect_long()?;
+            let state = this.as_mut_state();
+            state.array.remove(&offset);
+            Ok::<_, phper::Error>(())
+        })
+        .argument(Argument::by_val("offset"));
+
+    module.add_class(class);
+}

tests/integration/src/errors.rs

@@ -0,0 +1,26 @@
+// Copyright (c) 2022 PHPER Framework Team
+// PHPER is licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan
+// PSL v2. You may obtain a copy of Mulan PSL v2 at:
+//          http://license.coscl.org.cn/MulanPSL2
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY
+// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+
+use phper::modules::Module;
+use std::io;
+
+pub fn integrate(_module: &mut Module) {
+    {
+        let e = phper::Error::boxed("something wrong");
+        assert!(matches!(e, phper::Error::Boxed(..)));
+        assert_eq!(e.to_string(), "something wrong");
+    }
+
+    {
+        let e = phper::Error::boxed(io::Error::new(io::ErrorKind::Other, "oh no!"));
+        assert!(matches!(e, phper::Error::Boxed(..)));
+        assert_eq!(e.to_string(), "oh no!");
+    }
+}

tests/integration/src/lib.rs

@@ -14,6 +14,7 @@ mod arguments;
 mod arrays;
 mod classes;
 mod constants;
+mod errors;
 mod functions;
 mod ini;
 mod objects;
@@ -39,6 +40,7 @@ pub fn get_module() -> Module {
     values::integrate(&mut module);
     constants::integrate(&mut module);
     ini::integrate(&mut module);
+    errors::integrate(&mut module);
 
     module
 }

tests/integration/tests/php/classes.php

@@ -28,3 +28,20 @@
 
 $property_name = $reflection_class->getProperty("name");
 assert_true($property_name->isPrivate());
+
+
+$foo = new \IntegrationTest\Foo();
+
+// Test implementation of Iterator interface.
+$tmp_arr = [];
+foreach ($foo as $key => $value) {
+    $tmp_arr[] = [$key, $value];
+}
+assert_eq($tmp_arr, [[0, 'Current: 0'], [1, 'Current: 1'], [2, 'Current: 2']]);
+
+// Test implementation of ArrayAccess interface.
+assert_eq($foo[10], null);
+$foo[10] = "10";
+assert_eq($foo[10], "10");
+unset($foo[10]);
+assert_eq($foo[10], null);