[add] automock to some traits and make lambda-platform a default member.

Author: vmarcella

Cargo.toml

@@ -9,5 +9,6 @@ members = [
 
 default-members = [
     "lambda",
+    "crates/lambda-platform",
     "tools/lambda_rs_demo"
 ]

crates/lambda-platform/src/gfx/gpu.rs

@@ -7,18 +7,14 @@ use gfx_hal::{
     PhysicalDevice,
     QueueFamily,
   },
-  pso::ShaderStageFlags,
   queue::{
     Queue,
     QueueGroup,
   },
-  window::{
-    Extent2D,
-    PresentError,
-    PresentationSurface,
-    Suboptimal,
-  },
+  window::Extent2D,
 };
+#[cfg(test)]
+use mockall::automock;
 
 use super::{
   command::CommandBuffer,
@@ -35,14 +31,12 @@ pub struct GpuBuilder {
 }
 
 impl GpuBuilder {
-  #[inline]
   pub fn new() -> Self {
     return Self {
       render_queue_type: RenderQueueType::Graphical,
     };
   }
 
-  #[inline]
   pub fn with_render_queue_type(mut self, queue_type: RenderQueueType) -> Self {
     self.render_queue_type = queue_type;
     return self;
@@ -94,7 +88,7 @@ pub struct Gpu<B: gfx_hal::Backend> {
   queue_group: QueueGroup<B>,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub enum RenderQueueType {
   Compute,
   Graphical,
@@ -204,6 +198,14 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
   }
 }
 
+#[cfg(test)]
+mod tests {
+  #[test]
+  fn test_gpu_builder() {
+    assert_eq!(2 + 2, 4);
+  }
+}
+
 // --------------------------------- GPU INTERNALS -----------------------------
 
 pub mod internal {

crates/lambda-platform/src/gfx/mod.rs

@@ -19,6 +19,10 @@ use gfx_hal::Instance as _;
 
 pub struct InstanceBuilder {}
 
+#[cfg(test)]
+use mockall::automock;
+
+#[cfg_attr(test, automock)]
 impl InstanceBuilder {
   pub fn new() -> Self {
     return Self {};

crates/lambda-platform/src/gfx/shader.rs

@@ -2,6 +2,8 @@ use gfx_hal::{
   device::Device,
   pso::Specialization as ShaderSpecializations,
 };
+#[cfg(test)]
+use mockall::automock;
 
 use super::gpu;
 
@@ -19,6 +21,7 @@ pub struct ShaderModuleBuilder {
   specializations: ShaderSpecializations<'static>,
 }
 
+#[cfg_attr(test, automock)]
 impl ShaderModuleBuilder {
   pub fn new() -> Self {
     return Self {
@@ -74,11 +77,10 @@ pub struct ShaderModule<RenderBackend: gfx_hal::Backend> {
   shader_type: ShaderModuleType,
 }
 
+#[cfg_attr(test, automock)]
 impl<RenderBackend: gfx_hal::Backend> ShaderModule<RenderBackend> {
   /// Destroy the shader module and free the memory on the GPU.
   pub fn destroy(self, gpu: &mut gpu::Gpu<RenderBackend>) {
-    // TODO(vmarcella): Add documentation for the shader module.
-    println!("Destroying shader module.");
     unsafe {
       gpu::internal::logical_device_for(gpu)
         .destroy_shader_module(self.shader_module)
@@ -91,7 +93,7 @@ impl<RenderBackend: gfx_hal::Backend> ShaderModule<RenderBackend> {
   }
 
   /// Get the specializations being applied to the current shader module.
-  pub fn specializations(&self) -> &ShaderSpecializations {
+  pub fn specializations(&self) -> &ShaderSpecializations<'static> {
     return &self.specializations;
   }
 }
@@ -121,6 +123,13 @@ mod tests {
       super::ShaderSpecializations::default().data
     );
   }
+
+  #[test]
+  fn shader_builder_builds_correctly() {
+    let shader_builder = super::ShaderModuleBuilder::new()
+      .with_entry_name("test")
+      .with_specializations(super::ShaderSpecializations::default());
+  }
 }
 
 /// Internal functions for the shader module. User applications most likely

crates/lambda-platform/src/gfx/surface.rs

@@ -74,15 +74,16 @@ pub struct Swapchain {
   format: gfx_hal::format::Format,
 }
 
+#[cfg_attr(test, automock)]
 impl<RenderBackend: gfx_hal::Backend> Surface<RenderBackend> {
   /// Apply a swapchain to the current surface. This is required whenever a
   /// swapchain has been invalidated (I.E. by window resizing)
-  pub fn apply_swapchain(
+  pub fn apply_swapchain<'surface>(
     &mut self,
     gpu: &Gpu<RenderBackend>,
     swapchain: Swapchain,
     timeout_in_nanoseconds: u64,
-  ) -> Result<(), &str> {
+  ) -> Result<(), &'surface str> {
     let device = super::gpu::internal::logical_device_for(gpu);
     self.extent = Some(swapchain.config.extent);
 
@@ -128,13 +129,11 @@ impl<RenderBackend: gfx_hal::Backend> Surface<RenderBackend> {
   }
 
   /// private function to invalidate the surface swapchain.
-  #[inline]
   fn invalidate_swapchain(&mut self) {
     self.swapchain_is_valid = false;
   }
 
   /// Destroy the current surface and it's underlying resources.
-  #[inline]
   pub fn destroy(self, instance: &Instance<RenderBackend>) {
     println!("Destroying the surface: {}", self.name);
 
@@ -199,6 +198,7 @@ impl SwapchainBuilder {
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::gfx::MockInstanceBuilder;
 
   #[test]
   fn test_surface_builder() {
@@ -217,6 +217,18 @@ mod tests {
     let swapchain_builder = SwapchainBuilder::new().with_size(1920, 1080);
     assert_eq!(swapchain_builder.size, (1920, 1080));
   }
+
+  #[test]
+  fn test_surface_builder_e2e() {
+    //let instance = MockInstanceBuilder::new().build("TestInstance");
+    let surface_builder = SurfaceBuilder::new().with_name("TestSurface");
+    //let surface = surface_builder.build(&instance);
+
+    //assert_eq!(surface.name, "TestSurface".to_string());
+    //assert_eq!(surface.swapchain_is_valid, false);
+    //assert_eq!(surface.image, None);
+    //assert_eq!(surface.frame_buffer_attachment, None);
+  }
 }
 
 /// Internal functions to work with the gfx-hal surface components