1 files changed, 44 insertions, 13 deletions

diff --git a/notcuda/src/impl/test.rs b/notcuda/src/impl/test.rs
index dbd2eff..b6ed926 100644
--- a/notcuda/src/impl/test.rs
+++ b/notcuda/src/impl/test.rs
@@ -1,8 +1,12 @@
 #![allow(non_snake_case)]
 
-use crate::{cuda::CUstream, r#impl as notcuda};
-use crate::r#impl::CUresult;
-use crate::{cuda::CUuuid, r#impl::Encuda};
+use crate::cuda as notcuda;
+use crate::cuda::CUstream;
+use crate::cuda::CUuuid;
+use crate::{
+    cuda::{CUdevice, CUdeviceptr},
+    r#impl::CUresult,
+};
 use ::std::{
     ffi::c_void,
     os::raw::{c_int, c_uint},
@@ -37,48 +41,63 @@ pub trait CudaDriverFns {
     fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: c_int) -> CUresult;
     fn cuDevicePrimaryCtxGetState(dev: c_int, flags: *mut c_uint, active: *mut c_int) -> CUresult;
     fn cuStreamGetCtx(hStream: CUstream, pctx: *mut *mut c_void) -> CUresult;
+    fn cuStreamCreate(stream: *mut CUstream, flags: c_uint) -> CUresult;
+    fn cuMemFree_v2(mem: *mut c_void) -> CUresult;
+    fn cuStreamDestroy_v2(stream: CUstream) -> CUresult;
 }
 
 pub struct NotCuda();
 
 impl CudaDriverFns for NotCuda {
     fn cuInit(_flags: c_uint) -> CUresult {
-        crate::cuda::cuInit(_flags as _)
+        notcuda::cuInit(_flags as _)
     }
 
     fn cuCtxCreate_v2(pctx: *mut *mut c_void, flags: c_uint, dev: c_int) -> CUresult {
-        notcuda::context::create_v2(pctx as *mut _, flags, notcuda::device::Index(dev)).encuda()
+        notcuda::cuCtxCreate_v2(pctx as *mut _, flags, CUdevice(dev))
     }
 
     fn cuCtxDestroy_v2(ctx: *mut c_void) -> CUresult {
-        notcuda::context::destroy_v2(ctx as *mut _)
+        notcuda::cuCtxDestroy_v2(ctx as *mut _)
     }
 
     fn cuCtxPopCurrent_v2(pctx: *mut *mut c_void) -> CUresult {
-        notcuda::context::pop_current_v2(pctx as *mut _)
+        notcuda::cuCtxPopCurrent_v2(pctx as *mut _)
     }
 
     fn cuCtxGetApiVersion(ctx: *mut c_void, version: *mut c_uint) -> CUresult {
-        notcuda::context::get_api_version(ctx as *mut _, version)
+        notcuda::cuCtxGetApiVersion(ctx as *mut _, version)
     }
 
     fn cuCtxGetCurrent(pctx: *mut *mut c_void) -> CUresult {
-        notcuda::context::get_current(pctx as *mut _).encuda()
+        notcuda::cuCtxGetCurrent(pctx as *mut _)
     }
     fn cuMemAlloc_v2(dptr: *mut *mut c_void, bytesize: usize) -> CUresult {
-        notcuda::memory::alloc_v2(dptr as *mut _, bytesize)
+        notcuda::cuMemAlloc_v2(dptr as *mut _, bytesize)
     }
 
     fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: c_int) -> CUresult {
-        notcuda::device::get_uuid(uuid, notcuda::device::Index(dev)).encuda()
+        notcuda::cuDeviceGetUuid(uuid, CUdevice(dev))
     }
 
     fn cuDevicePrimaryCtxGetState(dev: c_int, flags: *mut c_uint, active: *mut c_int) -> CUresult {
-        notcuda::device::primary_ctx_get_state(notcuda::device::Index(dev), flags, active).encuda()
+        notcuda::cuDevicePrimaryCtxGetState(CUdevice(dev), flags, active)
     }
 
     fn cuStreamGetCtx(hStream: CUstream, pctx: *mut *mut c_void) -> CUresult {
-        crate::cuda::cuStreamGetCtx(hStream, pctx as _)
+        notcuda::cuStreamGetCtx(hStream, pctx as _)
+    }
+
+    fn cuStreamCreate(stream: *mut CUstream, flags: c_uint) -> CUresult {
+        notcuda::cuStreamCreate(stream, flags)
+    }
+
+    fn cuMemFree_v2(dptr: *mut c_void) -> CUresult {
+        notcuda::cuMemFree_v2(CUdeviceptr(dptr as _))
+    }
+
+    fn cuStreamDestroy_v2(stream: CUstream) -> CUresult {
+        notcuda::cuStreamDestroy_v2(stream)
     }
 }
 
@@ -123,4 +142,16 @@ impl CudaDriverFns for Cuda {
     fn cuStreamGetCtx(hStream: CUstream, pctx: *mut *mut c_void) -> CUresult {
         unsafe { CUresult(cuda::cuStreamGetCtx(hStream as _, pctx as _) as c_uint) }
     }
+
+    fn cuStreamCreate(stream: *mut CUstream, flags: c_uint) -> CUresult {
+        unsafe { CUresult(cuda::cuStreamCreate(stream as _, flags as _) as c_uint) }
+    }
+
+    fn cuMemFree_v2(mem: *mut c_void) -> CUresult {
+        unsafe { CUresult(cuda::cuMemFree_v2(mem as _) as c_uint) }
+    }
+
+    fn cuStreamDestroy_v2(stream: CUstream) -> CUresult {
+        unsafe { CUresult(cuda::cuStreamDestroy_v2(stream as _) as c_uint) }
+    }
 }