add: wip buffer tests

src/allocator/scratch_allocator.rs

@@ -88,7 +88,7 @@ impl<A: Allocator> ScratchAllocator<A> {
     /// # use phobos::*;
     /// # use anyhow::Result;
     /// fn make_scratch_allocator<A: Allocator>(device: Device, alloc: &mut A) -> Result<ScratchAllocator<A>> {
-    ///     ScratchAllocator::new(device, alloc, 1024 as usize)
+    ///     ScratchAllocator::new(device, alloc, 1024 as u64)
     /// }
     /// ```
     pub fn new(

tests/allocator.rs

@@ -8,7 +8,7 @@ mod framework;
 
 #[test]
 pub fn basic_allocator_usage() -> Result<()> {
-    let context = framework::make_context()?;
+    let context = framework::make_context().expect("Can initialize context.");
     let mut allocator = context.allocator.clone();
     let allocation = allocator.allocate(
         "allocation",
@@ -32,7 +32,7 @@ pub fn basic_allocator_usage() -> Result<()> {
 
 #[test]
 pub fn cpu_to_gpu_is_mappable() -> Result<()> {
-    let context = framework::make_context()?;
+    let context = framework::make_context().expect("Can initialize context.");
     let mut allocator = context.allocator.clone();
     let allocation = allocator.allocate(
         "allocation",
@@ -55,7 +55,7 @@ const CHUNK_SIZE: u64 = 32768;
 
 #[test]
 pub fn make_scratch_allocator() -> Result<()> {
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
 
     let _scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, CHUNK_SIZE)?;
@@ -64,7 +64,7 @@ pub fn make_scratch_allocator() -> Result<()> {
 
 #[test]
 pub fn use_scratch_allocator() -> Result<()> {
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
     let mut scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, CHUNK_SIZE)?;
     // Try allocating a buffer that should fit in the scratch allocator's memory.
@@ -75,7 +75,7 @@ pub fn use_scratch_allocator() -> Result<()> {
 #[test]
 pub fn use_entire_scratch_allocator() -> Result<()> {
     // Try allocating the entire scratch allocator's memory for a single buffer
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
     let mut scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, CHUNK_SIZE)?;
     let _buffer = scratch_allocator.allocate(1024 as u64)?;
@@ -84,7 +84,7 @@ pub fn use_entire_scratch_allocator() -> Result<()> {
 
 #[test]
 pub fn scratch_allocator_allocate_new_chunks() -> Result<()> {
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
     let mut scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, 1024)?;
     // First allocate a smaller buffer
@@ -96,7 +96,7 @@ pub fn scratch_allocator_allocate_new_chunks() -> Result<()> {
 
 #[test]
 pub fn reset_scratch_allocator() -> Result<()> {
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
     let mut scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, CHUNK_SIZE)?;
     // Allocate a first buffer.
@@ -109,7 +109,7 @@ pub fn reset_scratch_allocator() -> Result<()> {
 
 #[test]
 pub fn scratch_allocator_mass_allocate() -> Result<()> {
-    let mut context = framework::make_context()?;
+    let mut context = framework::make_context().expect("Can initialize context.");
     let mut scratch_allocator =
         ScratchAllocator::new(context.device.clone(), &mut context.allocator, CHUNK_SIZE)?;
 

tests/buffer.rs

@@ -0,0 +1,134 @@
+use anyhow::Result;
+use ash::vk;
+use ash::vk::Handle;
+
+use phobos::{Buffer, MemoryType};
+
+mod framework;
+
+#[test]
+pub fn alloc_buffer() -> Result<()> {
+    let mut context = framework::make_context().expect("Can initialize context.");
+
+    const ALLOC_SIZE: u64 = 1024u64;
+
+    let buffer = Buffer::new(
+        context.device.clone(),
+        &mut context.allocator,
+        ALLOC_SIZE,
+        MemoryType::GpuOnly,
+    )?;
+
+    assert_ne!(unsafe { buffer.handle().as_raw() }, 0, "Buffer handle should not be null.");
+    assert!(
+        buffer.size() >= ALLOC_SIZE,
+        "Allocated buffer should at least fit requested size."
+    );
+    assert_ne!(buffer.address(), 0, "Buffer device address should not be null.");
+
+    Ok(())
+}
+
+#[test]
+pub fn alloc_aligned_buffer() -> Result<()> {
+    let mut context = framework::make_context().expect("Can initialize context.");
+
+    const ALLOC_SIZE: u64 = 1000u64;
+    const ALIGN: u64 = 128;
+
+    let buffer = Buffer::new_aligned(
+        context.device.clone(),
+        &mut context.allocator,
+        ALLOC_SIZE,
+        ALIGN,
+        MemoryType::GpuOnly,
+    )?;
+
+    assert_ne!(unsafe { buffer.handle().as_raw() }, 0, "Buffer handle should not be null.");
+    assert!(
+        buffer.size() >= ALLOC_SIZE,
+        "Allocated buffer should at least fit requested size."
+    );
+    assert_eq!(buffer.size() % ALIGN, 0, "Buffer size should be aligned correctly.");
+    assert_eq!(buffer.address() % ALIGN, 0, "Buffer address should be aligned correctly.");
+
+    Ok(())
+}
+
+#[test]
+pub fn buffer_view_full() -> Result<()> {
+    let mut context = framework::make_context().expect("Can initialize context.");
+
+    const ALLOC_SIZE: u64 = 1024u64;
+
+    let buffer = Buffer::new(
+        context.device.clone(),
+        &mut context.allocator,
+        ALLOC_SIZE,
+        MemoryType::GpuOnly,
+    )?;
+
+    let view = buffer.view_full();
+    assert_eq!(view.address(), buffer.address(), "Full view should have same address as buffer");
+    assert_eq!(view.offset(), 0, "Full view should have zero offset");
+    assert_eq!(view.size(), buffer.size(), "Full view should have same size as buffer");
+    assert_eq!(
+        unsafe { view.handle() },
+        unsafe { buffer.handle() },
+        "View and buffer should refer to the same buffer"
+    );
+
+    Ok(())
+}
+
+#[test]
+pub fn buffer_view() -> Result<()> {
+    let mut context = framework::make_context().expect("Can initialize context.");
+
+    const ALLOC_SIZE: u64 = 1024u64;
+
+    let buffer = Buffer::new(
+        context.device.clone(),
+        &mut context.allocator,
+        ALLOC_SIZE,
+        MemoryType::GpuOnly,
+    )?;
+
+    let view = buffer
+        .view(ALLOC_SIZE / 2, ALLOC_SIZE / 2)
+        .expect("Can view second half of buffer");
+    assert_eq!(
+        view.address(),
+        buffer.address() + ALLOC_SIZE / 2,
+        "Buffer address respects pointer arithmetic"
+    );
+    assert_eq!(view.offset(), ALLOC_SIZE / 2, "View should have correct offset");
+    assert_eq!(view.size(), ALLOC_SIZE / 2, "View should have correct size");
+    assert_eq!(
+        unsafe { view.handle() },
+        unsafe { buffer.handle() },
+        "View and buffer should refer to the same buffer"
+    );
+
+    Ok(())
+}
+
+#[test]
+pub fn invalid_buffer_view() -> Result<()> {
+    let mut context = framework::make_context().expect("Can initialize context.");
+
+    const ALLOC_SIZE: u64 = 1024u64;
+
+    let buffer = Buffer::new(
+        context.device.clone(),
+        &mut context.allocator,
+        ALLOC_SIZE,
+        MemoryType::GpuOnly,
+    )?;
+
+    buffer
+        .view(0u64, ALLOC_SIZE * 2)
+        .expect_err("Cannot create view outside of buffer range");
+
+    Ok(())
+}

tests/init.rs

@@ -55,7 +55,7 @@ pub fn requesting_raytracing_does_not_fail() -> Result<()> {
 
 #[test]
 pub fn vulkan_loaded() -> Result<()> {
-    let context = framework::make_context()?;
+    let context = framework::make_context().expect("Can initialize context.");
     let handle = context.instance.handle();
     assert_ne!(handle.as_raw(), 0, "VkInstance handle should not be zero");
     let loader = unsafe { context.instance.loader() };
@@ -65,7 +65,7 @@ pub fn vulkan_loaded() -> Result<()> {
 
 #[test]
 pub fn valid_device() -> Result<()> {
-    let context = framework::make_context()?;
+    let context = framework::make_context().expect("Can initialize context.");
     let handle = unsafe { context.device.handle() };
     assert_ne!(handle.handle().as_raw(), 0, "VkDevice handle should not be zero");
     // Also try a vulkan function call on it to make sure it is loaded properly