diff --git a/profiling/common/src/SwTrace.cpp b/profiling/common/src/SwTrace.cpp
index 5860d8c..c25baad 100644
--- a/profiling/common/src/SwTrace.cpp
+++ b/profiling/common/src/SwTrace.cpp
@@ -33,7 +33,10 @@
                                   unsigned int& offset,
                                   const unsigned int& packetLength)
 {
-    ARM_PIPE_ASSERT(packetBuffer);
+    if (packetBuffer == nullptr)
+    {
+        throw ProfilingException("SwTrace.cpp: Attempting to read a null buffer");
+    }
 
     unsigned int uint32_t_size = sizeof(uint32_t);
 
diff --git a/profiling/server/src/basePipeServer/BasePipeServer.cpp b/profiling/server/src/basePipeServer/BasePipeServer.cpp
index 81f58a5..96e8e24 100644
--- a/profiling/server/src/basePipeServer/BasePipeServer.cpp
+++ b/profiling/server/src/basePipeServer/BasePipeServer.cpp
@@ -207,6 +207,12 @@
     // And the rest of the data if there is any.
     if (dataLength > 0)
     {
+        if (data == nullptr)
+        {
+            throw ProfilingException(
+                "basePipeServer: SendPacket: Attempting to send a non-zero length data packet with a null data pointer"
+                );
+        }
         memcpy((packet.data() + 8), data, dataLength);
     }
     EchoPacket(PacketDirection::Sending, packet.data(), packet.size());
diff --git a/samples/ObjectDetection/include/delegate/ArmnnNetworkExecutor.hpp b/samples/ObjectDetection/include/delegate/ArmnnNetworkExecutor.hpp
index 557ec8a..9c8583e 100644
--- a/samples/ObjectDetection/include/delegate/ArmnnNetworkExecutor.hpp
+++ b/samples/ObjectDetection/include/delegate/ArmnnNetworkExecutor.hpp
@@ -151,18 +151,24 @@
 }
 
 template<typename Tout>
-void ArmnnNetworkExecutor<Tout>::PrepareTensors(const void *inputData, const size_t dataBytes)
+void ArmnnNetworkExecutor<Tout>::PrepareTensors(const void* inputData, const size_t dataBytes)
 {
     size_t inputTensorSize = m_interpreter->input_tensor(0)->bytes;
     auto * inputTensorPtr = m_interpreter->input_tensor(0)->data.raw;
     assert(inputTensorSize >= dataBytes);
+    if (inputData == nullptr)
+    {
+        const std::string errorMessage{"ArmnnNetworkExecutor: input data pointer is null"};
+        ARMNN_LOG(error) << errorMessage;
+        throw armnn::Exception(errorMessage);
+    }
     if (inputTensorPtr != nullptr)
     {
        memcpy(inputTensorPtr, inputData, inputTensorSize);
     }
     else
     {
-        const std::string errorMessage{"ArmnnNetworkExecutor: input tensor is null"};
+        const std::string errorMessage{"ArmnnNetworkExecutor: input tensor pointer is null"};
         ARMNN_LOG(error) << errorMessage;
         throw armnn::Exception(errorMessage);
     }
diff --git a/src/armnnUtils/Permute.cpp b/src/armnnUtils/Permute.cpp
index 7d15f3c..19b465b 100644
--- a/src/armnnUtils/Permute.cpp
+++ b/src/armnnUtils/Permute.cpp
@@ -9,7 +9,6 @@
 
 #include "Half.hpp"
 
-#include <cassert>
 #include <cstring>
 
 namespace
@@ -23,7 +22,13 @@
     PermuteLoop(const armnn::TensorShape& dstShape, const armnn::PermutationVector& mappings)
         : m_DstShape(dstShape)
     {
-        assert(dstShape.GetNumDimensions() == mappings.GetSize());
+        if (dstShape.GetNumDimensions() != mappings.GetSize())
+        {
+            std::stringstream msg;
+            msg << "Permute: Number of shape dimensions (" << dstShape.GetNumDimensions() <<
+                ") does not match the size of the mappings (" << mappings.GetSize() << ")";
+            throw armnn::InvalidArgumentException(msg.str());
+        }
 
         const size_type numDims = dstShape.GetNumDimensions();
 
@@ -42,9 +47,18 @@
 
     void Unroll(const void* srcData, void* dstData, size_t dataTypeSize)
     {
-        assert(srcData);
-        assert(dstData);
-        assert(dataTypeSize > 0);
+        if (srcData == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Source Data pointer is null");
+        }
+        if (dstData == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Destination Data pointer is null");
+        }
+        if (dataTypeSize == 0)
+        {
+            throw armnn::InvalidArgumentException("Permute: dataTypeSize is zero");
+        }
 
         const unsigned char* srcDataPtr = reinterpret_cast<const unsigned char*>(srcData);
         unsigned char* dstDataPtr       = reinterpret_cast<unsigned char*>(dstData);
@@ -61,13 +75,26 @@
                 const unsigned char* srcEnd, unsigned char* dstEnd,
                 size_t dataTypeSize)
     {
-        assert(srcData);
-        assert(dstData);
-        assert(srcEnd);
-        assert(dstEnd);
-        assert(srcData < srcEnd);
-        assert(dstData < dstEnd);
-        assert(dataTypeSize > 0);
+        if (srcData == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Source Data pointer is null");
+        }
+        if (dstData == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Destination Data pointer is null");
+        }
+        if (srcEnd == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Source End pointer is null");
+        }
+        if (dstEnd == nullptr)
+        {
+            throw armnn::InvalidArgumentException("Permute: Destination End pointer is null");
+        }
+        if (dataTypeSize == 0)
+        {
+            throw armnn::Exception("Permute: dataTypeSize is zero");
+        }
 
         if (dimension >= m_DstShape.GetNumDimensions())
         {
@@ -98,7 +125,13 @@
 armnn::TensorShape Permuted(const armnn::TensorShape& srcShape,
                             const armnn::PermutationVector& mappings)
 {
-    assert(srcShape.GetNumDimensions() == mappings.GetSize());
+    if (srcShape.GetNumDimensions() != mappings.GetSize())
+    {
+        std::stringstream msg;
+        msg << "Permute: Number of shape dimensions (" << srcShape.GetNumDimensions() <<
+               ") does not match the size of the mappings (" << mappings.GetSize() << ")";
+        throw armnn::InvalidArgumentException(msg.str());
+    }
 
     const unsigned int numDims = mappings.GetSize();
     unsigned int outDims[armnn::MaxNumOfTensorDimensions];
diff --git a/src/armnnUtils/Transpose.cpp b/src/armnnUtils/Transpose.cpp
index 3457cac..a8e4a1c 100644
--- a/src/armnnUtils/Transpose.cpp
+++ b/src/armnnUtils/Transpose.cpp
@@ -9,7 +9,6 @@
 
 #include "Half.hpp"
 
-#include <cassert>
 #include <cstring>
 
 namespace
@@ -23,7 +22,13 @@
     TransposeLoop(const armnn::TensorShape& srcShape, const armnn::PermutationVector& mappings)
         : m_SrcShape(srcShape)
     {
-        assert(srcShape.GetNumDimensions() == mappings.GetSize());
+        if (srcShape.GetNumDimensions() != mappings.GetSize())
+        {
+            std::stringstream msg;
+            msg << "Transpose: Number of shape dimensions (" << srcShape.GetNumDimensions() <<
+                ") does not match the size of the mappings (" << mappings.GetSize() << ")";
+            throw armnn::InvalidArgumentException(msg.str());
+        }
 
         const size_type numDims = srcShape.GetNumDimensions();
 
@@ -42,9 +47,18 @@
 
     void Unroll(const void* srcData, void* dstData, size_t dataTypeSize)
     {
-        assert(srcData);
-        assert(dstData);
-        assert(dataTypeSize > 0);
+        if (srcData == nullptr)
+        {
+            throw armnn::Exception("Transpose: Source Data pointer is null");
+        }
+        if (dstData == nullptr)
+        {
+            throw armnn::Exception("Transpose: Destination Data pointer is null");
+        }
+        if (dataTypeSize == 0)
+        {
+            throw armnn::Exception("Transpose: dataTypeSize is zero");
+        }
 
         const unsigned char* srcDataPtr = reinterpret_cast<const unsigned char*>(srcData);
         unsigned char* dstDataPtr       = reinterpret_cast<unsigned char*>(dstData);
@@ -61,13 +75,26 @@
                 const unsigned char* srcEnd, unsigned char* dstEnd,
                 size_t dataTypeSize)
     {
-        assert(srcData);
-        assert(dstData);
-        assert(srcEnd);
-        assert(dstEnd);
-        assert(srcData < srcEnd);
-        assert(dstData < dstEnd);
-        assert(dataTypeSize > 0);
+        if (srcData == nullptr)
+        {
+            throw armnn::Exception("Transpose: Source Data pointer is null");
+        }
+        if (dstData == nullptr)
+        {
+            throw armnn::Exception("Transpose: Destination Data pointer is null");
+        }
+        if (srcEnd == nullptr)
+        {
+            throw armnn::Exception("Transpose: Source End pointer is null");
+        }
+        if (dstEnd == nullptr)
+        {
+            throw armnn::Exception("Transpose: Destination End is zero");
+        }
+        if (dataTypeSize == 0)
+        {
+            throw armnn::Exception("Transpose: dataTypeSize is invalid");
+        }
 
         if (dimension >= m_SrcShape.GetNumDimensions())
         {
@@ -97,7 +124,13 @@
 
 armnn::TensorShape TransposeTensorShape(const armnn::TensorShape& srcShape, const armnn::PermutationVector& mappings)
 {
-    assert(srcShape.GetNumDimensions() == mappings.GetSize());
+    if (srcShape.GetNumDimensions() != mappings.GetSize())
+    {
+        std::stringstream msg;
+        msg << "Transpose: Number of shape dimensions (" << srcShape.GetNumDimensions() <<
+            ") does not match the size of the mappings (" << mappings.GetSize() << ")";
+        throw armnn::InvalidArgumentException(msg.str());
+    }
 
     const unsigned int numDims = mappings.GetSize();
     unsigned int outDims[armnn::MaxNumOfTensorDimensions];
diff --git a/src/backends/backendsCommon/TensorHandle.cpp b/src/backends/backendsCommon/TensorHandle.cpp
index d55fca2..bc221ad 100644
--- a/src/backends/backendsCommon/TensorHandle.cpp
+++ b/src/backends/backendsCommon/TensorHandle.cpp
@@ -103,12 +103,30 @@
 
 void ScopedTensorHandle::CopyOutTo(void* memory) const
 {
-    memcpy(memory, GetTensor<void>(), GetTensorInfo().GetNumBytes());
+    const void* src = GetTensor<void>();
+    if (src == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyOutTo called with a null src pointer");
+    }
+    if (memory == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyOutTo called with a null dest pointer");
+    }
+    memcpy(memory, src, GetTensorInfo().GetNumBytes());
 }
 
 void ScopedTensorHandle::CopyInFrom(const void* memory)
 {
-    memcpy(GetTensor<void>(), memory, GetTensorInfo().GetNumBytes());
+    void* dest = GetTensor<void>();
+    if (dest == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyInFrom called with a null dest pointer");
+    }
+    if (memory == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyInFrom called with a null src pointer");
+    }
+    memcpy(dest, memory, GetTensorInfo().GetNumBytes());
 }
 
 void ScopedTensorHandle::CopyFrom(const ScopedTensorHandle& other)
@@ -118,8 +136,17 @@
 
 void ScopedTensorHandle::CopyFrom(const void* srcMemory, unsigned int numBytes)
 {
-    ARMNN_ASSERT(GetTensor<void>() == nullptr);
-    ARMNN_ASSERT(GetTensorInfo().GetNumBytes() == numBytes);
+    if (GetTensor<void>() != nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyFrom called on an already allocated TensorHandle");
+    }
+    if (GetTensorInfo().GetNumBytes() != numBytes)
+    {
+        std::stringstream msg;
+        msg << "TensorHandle:CopyFrom: Number of bytes in the tensor info (" << GetTensorInfo().GetNumBytes() <<
+            ") does not match the number of bytes being copied (" << numBytes << ")";
+        throw armnn::Exception(msg.str());
+    }
 
     if (srcMemory)
     {
diff --git a/src/backends/backendsCommon/WorkloadUtils.cpp b/src/backends/backendsCommon/WorkloadUtils.cpp
index 3aea667..28d01ec 100644
--- a/src/backends/backendsCommon/WorkloadUtils.cpp
+++ b/src/backends/backendsCommon/WorkloadUtils.cpp
@@ -18,8 +18,14 @@
 armnn::ConstTensor PermuteTensor(const ConstTensorHandle* tensor,
                                  const PermutationVector& permutationVector, void* permuteBuffer)
 {
-    ARMNN_ASSERT_MSG(tensor, "Invalid input tensor");
-    ARMNN_ASSERT_MSG(permuteBuffer, "Invalid permute buffer");
+    if (tensor == nullptr)
+    {
+        throw armnn::InvalidArgumentException("WorkloadUtils: PermuteTensor: Null input tensor pointer");
+    }
+    if (permuteBuffer == nullptr)
+    {
+        throw armnn::InvalidArgumentException("WorkloadUtils: PermuteTensor: Null permute buffer pointer");
+    }
 
     TensorInfo tensorInfo = tensor->GetTensorInfo();
 
@@ -231,8 +237,14 @@
                                                      DataLayout dataLayout,
                                                      void* permuteBuffer)
 {
-    ARMNN_ASSERT_MSG(weightTensor, "Invalid input tensor");
-    ARMNN_ASSERT_MSG(permuteBuffer, "Invalid permute buffer");
+    if (weightTensor == nullptr)
+    {
+        throw armnn::InvalidArgumentException("WorkloadUtils: PermuteTensor: Null input tensor pointer");
+    }
+    if (permuteBuffer == nullptr)
+    {
+        throw armnn::InvalidArgumentException("WorkloadUtils: PermuteTensor: Null permute buffer pointer");
+    }
 
     auto multiplier    = weightTensor->GetTensorInfo().GetShape()[0];
     auto inputChannels = weightTensor->GetTensorInfo().GetShape()[1];
diff --git a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
index 3cfd614..f277403 100644
--- a/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
+++ b/src/backends/backendsCommon/test/layerTests/ReverseV2TestImpl.cpp
@@ -63,13 +63,22 @@
         axisHandle->Allocate();
         outputHandle->Allocate();
 
-        CopyDataToITensorHandle(inputHandle.get(), input.data());
-        CopyDataToITensorHandle(axisHandle.get(), axis.data());
+        if (input.data() != nullptr)
+        {
+            CopyDataToITensorHandle(inputHandle.get(), input.data());
+        }
+        if (axis.data() != nullptr)
+        {
+            CopyDataToITensorHandle(axisHandle.get(), axis.data());
+        }
 
         workload->PostAllocationConfigure();
         ExecuteWorkload(*workload, memoryManager);
 
-        CopyDataFromITensorHandle(outputActual.data(), outputHandle.get());
+        if (outputActual.data() != nullptr)
+        {
+            CopyDataFromITensorHandle(outputActual.data(), outputHandle.get());
+        }
 
         return LayerTestResult<T, NumDims>(outputActual,
                                            outputExpected,
@@ -98,7 +107,7 @@
         3, 4
     }, qScale, qOffset);
 
-    std::vector<int> axis = armnnUtils::QuantizedVector<int>({}, qScale, qOffset);
+    std::vector<int> axis = armnnUtils::QuantizedVector<int>({1, 1}, qScale, qOffset);
 
     std::vector<T> outputExpected = armnnUtils::QuantizedVector<T>({
         1, 2,
diff --git a/src/backends/reference/RefTensorHandle.cpp b/src/backends/reference/RefTensorHandle.cpp
index cce992c..07f497c 100644
--- a/src/backends/reference/RefTensorHandle.cpp
+++ b/src/backends/reference/RefTensorHandle.cpp
@@ -101,16 +101,30 @@
 
 void RefTensorHandle::CopyOutTo(void* dest) const
 {
-    const void *src = GetPointer();
-    ARMNN_ASSERT(src);
-    memcpy(dest, src, m_TensorInfo.GetNumBytes());
+    const void* src = GetPointer();
+    if (src == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyOutTo called with a null src pointer");
+    }
+    if (dest == nullptr)
+    {
+        throw NullPointerException("TensorHandle::CopyOutTo called with a null dest pointer");
+    }
+    memcpy(dest, src, GetTensorInfo().GetNumBytes());
 }
 
 void RefTensorHandle::CopyInFrom(const void* src)
 {
-    void *dest = GetPointer();
-    ARMNN_ASSERT(dest);
-    memcpy(dest, src, m_TensorInfo.GetNumBytes());
+    void* dest = GetPointer();
+    if (dest == nullptr)
+    {
+        throw NullPointerException("RefTensorHandle::CopyInFrom called with a null dest pointer");
+    }
+    if (src == nullptr)
+    {
+        throw NullPointerException("RefTensorHandle::CopyInFrom called with a null src pointer");
+    }
+    memcpy(dest, src, GetTensorInfo().GetNumBytes());
 }
 
 MemorySourceFlags RefTensorHandle::GetImportFlags() const
diff --git a/src/backends/reference/workloads/Slice.cpp b/src/backends/reference/workloads/Slice.cpp
index d6836c6..534a063 100644
--- a/src/backends/reference/workloads/Slice.cpp
+++ b/src/backends/reference/workloads/Slice.cpp
@@ -20,11 +20,28 @@
     const TensorShape& inputShape = inputInfo.GetShape();
     const unsigned int numDims    = inputShape.GetNumDimensions();
 
-    ARMNN_ASSERT(descriptor.m_Begin.size() == numDims);
-    ARMNN_ASSERT(descriptor.m_Size.size()  == numDims);
-
     constexpr unsigned int maxNumDims = 4;
-    ARMNN_ASSERT(numDims <= maxNumDims);
+    if (descriptor.m_Begin.size() != numDims)
+    {
+        std::stringstream msg;
+        msg << "Slice: Number of dimensions (" << numDims <<
+            ") does not match the Begin vector in the descriptor (" << descriptor.m_Begin.size() << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+    if (descriptor.m_Size.size() != numDims)
+    {
+        std::stringstream msg;
+        msg << "Slice: Number of dimensions (" << numDims <<
+            ") does not match the Size vector in the descriptor (" << descriptor.m_Size.size() << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+    if (numDims > maxNumDims)
+    {
+        std::stringstream msg;
+        msg << "Slice: Number of dimensions (" << numDims <<
+            ") is greater than the maximum supported (" << maxNumDims << ")";
+        throw InvalidArgumentException(msg.str());
+    }
 
     std::vector<unsigned int> paddedInput(4);
     std::vector<unsigned int> paddedBegin(4);
@@ -63,15 +80,47 @@
     unsigned int size2  = paddedSize[2];
     unsigned int size3  = paddedSize[3];
 
-    ARMNN_ASSERT(begin0 + size0 <= dim0);
-    ARMNN_ASSERT(begin1 + size1 <= dim1);
-    ARMNN_ASSERT(begin2 + size2 <= dim2);
-    ARMNN_ASSERT(begin3 + size3 <= dim3);
+    if (begin0 + size0 > dim0)
+    {
+        std::stringstream msg;
+        msg << "Slice: begin0 + size0 (" << (begin0 + size0) <<
+            ") exceeds dim0 (" << dim0 << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+    if (begin1 + size1 > dim1)
+    {
+        std::stringstream msg;
+        msg << "Slice: begin1 + size1 (" << (begin1 + size1) <<
+            ") exceeds dim2 (" << dim1 << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+    if (begin2 + size2 > dim2)
+    {
+        std::stringstream msg;
+        msg << "Slice: begin2 + size2 (" << (begin2 + size2) <<
+            ") exceeds dim2 (" << dim2 << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+    if (begin3 + size3 > dim3)
+    {
+        std::stringstream msg;
+        msg << "Slice: begin3 + size3 (" << (begin3 + size3) <<
+            ") exceeds dim3 (" << dim3 << ")";
+        throw InvalidArgumentException(msg.str());
+    }
+
+    if (inputData == nullptr)
+    {
+        throw armnn::NullPointerException("Slice: Null inputData pointer");
+    }
+    if (outputData == nullptr)
+    {
+        throw armnn::NullPointerException("Slice: Null outputData pointer");
+    }
 
     const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData);
     unsigned char* output      = reinterpret_cast<unsigned char*>(outputData);
 
-    IgnoreUnused(dim0);
     for (unsigned int idx0 = begin0; idx0 < begin0 + size0; ++idx0)
     {
         for (unsigned int idx1 = begin1; idx1 < begin1 + size1; ++idx1)
diff --git a/src/backends/reference/workloads/StridedSlice.cpp b/src/backends/reference/workloads/StridedSlice.cpp
index c5fb121..68600c9 100644
--- a/src/backends/reference/workloads/StridedSlice.cpp
+++ b/src/backends/reference/workloads/StridedSlice.cpp
@@ -93,6 +93,15 @@
                   void* outputData,
                   unsigned int dataTypeSize)
 {
+    if (inputData == nullptr)
+    {
+        throw armnn::InvalidArgumentException("Slice: Null inputData pointer");
+    }
+    if (outputData == nullptr)
+    {
+        throw armnn::InvalidArgumentException("Slice: Null outputData pointer");
+    }
+
     const unsigned char* input = reinterpret_cast<const unsigned char*>(inputData);
     unsigned char* output = reinterpret_cast<unsigned char*>(outputData);
 
diff --git a/src/backends/tosaReference/TosaRefTensorHandle.cpp b/src/backends/tosaReference/TosaRefTensorHandle.cpp
index 38d02f1..aaffc8a 100644
--- a/src/backends/tosaReference/TosaRefTensorHandle.cpp
+++ b/src/backends/tosaReference/TosaRefTensorHandle.cpp
@@ -100,16 +100,30 @@
 
 void TosaRefTensorHandle::CopyOutTo(void* dest) const
 {
-    const void *src = GetPointer();
-    ARMNN_ASSERT(src);
-    memcpy(dest, src, m_TensorInfo.GetNumBytes());
+    const void* src = GetPointer();
+    if (src == nullptr)
+    {
+        throw NullPointerException("TosaRefTensorHandle::CopyOutTo called with a null src pointer");
+    }
+    if (dest == nullptr)
+    {
+        throw NullPointerException("TosaRefTensorHandle::CopyOutTo called with a null dest pointer");
+    }
+    memcpy(dest, src, GetTensorInfo().GetNumBytes());
 }
 
 void TosaRefTensorHandle::CopyInFrom(const void* src)
 {
-    void *dest = GetPointer();
-    ARMNN_ASSERT(dest);
-    memcpy(dest, src, m_TensorInfo.GetNumBytes());
+    void* dest = GetPointer();
+    if (dest == nullptr)
+    {
+        throw NullPointerException("TosaRefTensorHandle::CopyInFrom called with a null dest pointer");
+    }
+    if (src == nullptr)
+    {
+        throw NullPointerException("TosaRefTensorHandle::CopyInFrom called with a null src pointer");
+    }
+    memcpy(dest, src, GetTensorInfo().GetNumBytes());
 }
 
 bool TosaRefTensorHandle::Import(void* memory, MemorySource source)
diff --git a/src/dynamic/sample/SampleTensorHandle.cpp b/src/dynamic/sample/SampleTensorHandle.cpp
index c008618..80554aa 100644
--- a/src/dynamic/sample/SampleTensorHandle.cpp
+++ b/src/dynamic/sample/SampleTensorHandle.cpp
@@ -136,15 +136,29 @@
 
 void SampleTensorHandle::CopyOutTo(void* dest) const
 {
-    const void *src = GetPointer();
-    ARMNN_ASSERT(src);
+    const void* src = GetPointer();
+    if (dest == nullptr)
+    {
+        throw armnn::Exception("SampleTensorHandle:CopyOutTo: Destination Ptr is null");
+    }
+    if (src == nullptr)
+    {
+        throw armnn::Exception("SampleTensorHandle:CopyOutTo: Source Ptr is null");
+    }
     memcpy(dest, src, m_TensorInfo.GetNumBytes());
 }
 
 void SampleTensorHandle::CopyInFrom(const void* src)
 {
-    void *dest = GetPointer();
-    ARMNN_ASSERT(dest);
+    void* dest = GetPointer();
+    if (src == nullptr)
+    {
+        throw armnn::Exception("SampleTensorHandle:CopyInFrom: Source Ptr is null");
+    }
+    if (dest == nullptr)
+    {
+        throw armnn::Exception("SampleTensorHandle:CopyInFrom: Destination Ptr is null");
+    }
     memcpy(dest, src, m_TensorInfo.GetNumBytes());
 }