test(class): add extends and implements tests

Refs: #326

Author: Xenira

src/builders/class.rs

@@ -372,3 +372,98 @@ impl ClassBuilder {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::test::test_function;
+
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        let class = ClassBuilder::new("Foo");
+        assert_eq!(class.name, "Foo");
+        assert_eq!(class.extends, None);
+        assert_eq!(class.interfaces, vec![]);
+        assert_eq!(class.methods.len(), 0);
+        assert_eq!(class.object_override, None);
+        assert_eq!(class.properties, vec![]);
+        assert_eq!(class.constants.len(), 0);
+        assert_eq!(class.register, None);
+        assert_eq!(class.docs, &[] as DocComments);
+    }
+
+    #[test]
+    fn test_extends() {
+        let extends: ClassEntryInfo = (|| todo!(), "Bar");
+        let class = ClassBuilder::new("Foo").extends(extends);
+        assert_eq!(class.extends, Some(extends));
+    }
+
+    #[test]
+    fn test_implements() {
+        let implements: ClassEntryInfo = (|| todo!(), "Bar");
+        let class = ClassBuilder::new("Foo").implements(implements);
+        assert_eq!(class.interfaces, vec![implements]);
+    }
+
+    #[test]
+    fn test_method() {
+        let method = FunctionBuilder::new("foo", test_function);
+        let class = ClassBuilder::new("Foo").method(method, MethodFlags::Public);
+        assert_eq!(class.methods.len(), 1);
+    }
+
+    #[test]
+    fn test_property() {
+        let class = ClassBuilder::new("Foo").property("bar", PropertyFlags::Public, &["Doc 1"]);
+        assert_eq!(
+            class.properties,
+            vec![(
+                "bar".to_string(),
+                PropertyFlags::Public,
+                &["Doc 1"] as DocComments
+            )]
+        );
+    }
+
+    #[test]
+    fn test_constant() {
+        let class = ClassBuilder::new("Foo")
+            .constant("bar", 42, &["Doc 1"])
+            .expect("Failed to create constant");
+        assert_eq!(class.constants.len(), 1);
+        assert_eq!(class.constants[0].0, "bar");
+        assert_eq!(class.constants[0].2, &["Doc 1"] as DocComments);
+    }
+
+    #[test]
+    fn test_dyn_constant() {
+        let class = ClassBuilder::new("Foo")
+            .dyn_constant("bar", &42, &["Doc 1"])
+            .expect("Failed to create constant");
+        assert_eq!(class.constants.len(), 1);
+        assert_eq!(class.constants[0].0, "bar");
+        assert_eq!(class.constants[0].2, &["Doc 1"] as DocComments);
+    }
+
+    #[test]
+    fn test_flags() {
+        let class = ClassBuilder::new("Foo").flags(ClassFlags::Abstract);
+        assert_eq!(class.ce.ce_flags, ClassFlags::Abstract.bits());
+    }
+
+    #[test]
+    fn test_registration() {
+        let class = ClassBuilder::new("Foo").registration(|_| {});
+        assert!(class.register.is_some());
+    }
+
+    #[test]
+    fn test_docs() {
+        let class = ClassBuilder::new("Foo").docs(&["Doc 1"]);
+        assert_eq!(class.docs, &["Doc 1"] as DocComments);
+    }
+
+    // TODO: Test the register function
+}

src/builders/module.rs

@@ -304,3 +304,86 @@ impl TryFrom<ModuleBuilder<'_>> for (ModuleEntry, ModuleStartup) {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::test::{
+        test_deactivate_function, test_function, test_info_function, test_startup_shutdown_function,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        let builder = ModuleBuilder::new("test", "1.0");
+        assert_eq!(builder.name, "test");
+        assert_eq!(builder.version, "1.0");
+        assert!(builder.functions.is_empty());
+        assert!(builder.constants.is_empty());
+        assert!(builder.classes.is_empty());
+        assert!(builder.startup_func.is_none());
+        assert!(builder.shutdown_func.is_none());
+        assert!(builder.request_startup_func.is_none());
+        assert!(builder.request_shutdown_func.is_none());
+        assert!(builder.post_deactivate_func.is_none());
+        assert!(builder.info_func.is_none());
+    }
+
+    #[test]
+    fn test_startup_function() {
+        let builder =
+            ModuleBuilder::new("test", "1.0").startup_function(test_startup_shutdown_function);
+        assert!(builder.startup_func.is_some());
+    }
+
+    #[test]
+    fn test_shutdown_function() {
+        let builder =
+            ModuleBuilder::new("test", "1.0").shutdown_function(test_startup_shutdown_function);
+        assert!(builder.shutdown_func.is_some());
+    }
+
+    #[test]
+    fn test_request_startup_function() {
+        let builder = ModuleBuilder::new("test", "1.0")
+            .request_startup_function(test_startup_shutdown_function);
+        assert!(builder.request_startup_func.is_some());
+    }
+
+    #[test]
+    fn test_request_shutdown_function() {
+        let builder = ModuleBuilder::new("test", "1.0")
+            .request_shutdown_function(test_startup_shutdown_function);
+        assert!(builder.request_shutdown_func.is_some());
+    }
+
+    #[test]
+    fn test_set_post_deactivate_function() {
+        let builder =
+            ModuleBuilder::new("test", "1.0").post_deactivate_function(test_deactivate_function);
+        assert!(builder.post_deactivate_func.is_some());
+    }
+
+    #[test]
+    fn test_set_info_function() {
+        let builder = ModuleBuilder::new("test", "1.0").info_function(test_info_function);
+        assert!(builder.info_func.is_some());
+    }
+
+    #[test]
+    fn test_add_function() {
+        let builder =
+            ModuleBuilder::new("test", "1.0").function(FunctionBuilder::new("test", test_function));
+        assert_eq!(builder.functions.len(), 1);
+    }
+
+    #[test]
+    fn test_add_constant() {
+        let builder =
+            ModuleBuilder::new("test", "1.0").constant(("TEST_CONST", 42, DocComments::default()));
+        assert_eq!(builder.constants.len(), 1);
+        assert_eq!(builder.constants[0].0, "TEST_CONST");
+        // TODO: Check if the value is 42
+        assert_eq!(builder.constants[0].2, DocComments::default());
+    }
+}

src/describe/abi.rs

@@ -17,6 +17,7 @@ use std::{fmt::Display, ops::Deref, vec::Vec as StdVec};
 
 /// An immutable, ABI-stable [`Vec`][std::vec::Vec].
 #[repr(C)]
+#[derive(Debug)]
 pub struct Vec<T> {
     ptr: *mut T,
     len: usize,
@@ -48,8 +49,18 @@ impl<T> From<StdVec<T>> for Vec<T> {
     }
 }
 
+impl<T> PartialEq for Vec<T>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.len == other.len && self.as_ref() == other.as_ref()
+    }
+}
+
 /// An immutable, ABI-stable borrowed [`&'static str`][str].
 #[repr(C)]
+#[derive(Debug)]
 pub struct Str {
     ptr: *const u8,
     len: usize,
@@ -86,8 +97,15 @@ impl Display for Str {
     }
 }
 
+impl PartialEq for Str {
+    fn eq(&self, other: &Self) -> bool {
+        self.len == other.len && self.str() == other.str()
+    }
+}
+
 /// An ABI-stable String
 #[repr(C)]
+#[derive(Debug, PartialEq)]
 pub struct RString {
     inner: Vec<u8>,
 }
@@ -134,6 +152,7 @@ impl Display for RString {
 
 /// An ABI-stable [`Option`][std::option::Option].
 #[repr(C, u8)]
+#[derive(Debug)]
 pub enum Option<T> {
     /// [`Option::Some`][std::option::Option::Some] variant.
     Some(T),
@@ -149,3 +168,16 @@ impl<T> From<std::option::Option<T>> for Option<T> {
         }
     }
 }
+
+impl<T> PartialEq for Option<T>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Some(a), Self::Some(b)) => a == b,
+            (Self::None, Self::None) => true,
+            _ => false,
+        }
+    }
+}