diff --git a/src/armnnUtils/CsvReader.cpp b/src/armnnUtils/CsvReader.cpp
new file mode 100644
index 0000000..5b66c94
--- /dev/null
+++ b/src/armnnUtils/CsvReader.cpp
@@ -0,0 +1,63 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "CsvReader.hpp"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/tokenizer.hpp>
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+using Tokenizer = boost::tokenizer<boost::escaped_list_separator<char>>;
+
+namespace armnnUtils
+{
+
+CsvRow ParseLine(const std::string& csvLine)
+{
+    Tokenizer tokenizer(csvLine);
+    CsvRow entry;
+
+    for (const auto &token : tokenizer)
+    {
+        entry.values.push_back(boost::trim_copy(token));
+    }
+    return entry;
+}
+
+std::vector<CsvRow> CsvReader::ParseFile(const std::string& csvFile)
+{
+    std::vector<CsvRow> result;
+
+    std::ifstream in(csvFile.c_str());
+    if (!in.is_open())
+        return result;
+
+    std::string line;
+    while (getline(in, line))
+    {
+        if(!line.empty())
+        {
+            CsvRow entry = ParseLine(line);
+            result.push_back(entry);
+        }
+    }
+    return result;
+}
+
+std::vector<CsvRow> CsvReader::ParseVector(const std::vector<std::string>& csvVector)
+{
+    std::vector<CsvRow> result;
+
+    for (auto const& line: csvVector)
+    {
+        CsvRow entry = ParseLine(line);
+        result.push_back(entry);
+    }
+    return result;
+}
+} // namespace armnnUtils
\ No newline at end of file
diff --git a/src/armnnUtils/CsvReader.hpp b/src/armnnUtils/CsvReader.hpp
new file mode 100644
index 0000000..0d52980
--- /dev/null
+++ b/src/armnnUtils/CsvReader.hpp
@@ -0,0 +1,25 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace armnnUtils
+{
+
+struct CsvRow
+{
+    std::vector<std::string> values;
+};
+
+class CsvReader
+{
+public:
+    static std::vector<CsvRow> ParseFile(const std::string& csvFile);
+
+    static std::vector<CsvRow> ParseVector(const std::vector<std::string>& csvVector);
+};
+} // namespace armnnUtils
diff --git a/src/armnnUtils/FloatingPointConverter.cpp b/src/armnnUtils/FloatingPointConverter.cpp
new file mode 100644
index 0000000..5c1a431
--- /dev/null
+++ b/src/armnnUtils/FloatingPointConverter.cpp
@@ -0,0 +1,44 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "FloatingPointConverter.hpp"
+#include "../armnn/Half.hpp"
+
+#include <boost/assert.hpp>
+
+namespace armnnUtils
+{
+
+void FloatingPointConverter::ConvertFloat32To16(const float* srcFloat32Buffer,
+                                                size_t numElements,
+                                                void* dstFloat16Buffer)
+{
+    BOOST_ASSERT(srcFloat32Buffer != nullptr);
+    BOOST_ASSERT(dstFloat16Buffer != nullptr);
+
+    armnn::Half* pHalf = reinterpret_cast<armnn::Half*>(dstFloat16Buffer);
+
+    for (size_t i = 0; i < numElements; i++)
+    {
+        pHalf[i] = armnn::Half(srcFloat32Buffer[i]);
+    }
+}
+
+void FloatingPointConverter::ConvertFloat16To32(const void* srcFloat16Buffer,
+                                                size_t numElements,
+                                                float* dstFloat32Buffer)
+{
+    BOOST_ASSERT(srcFloat16Buffer != nullptr);
+    BOOST_ASSERT(dstFloat32Buffer != nullptr);
+
+    const armnn::Half* pHalf = reinterpret_cast<const armnn::Half*>(srcFloat16Buffer);
+
+    for (size_t i = 0; i < numElements; i++)
+    {
+        dstFloat32Buffer[i] = pHalf[i];
+    }
+}
+
+} //namespace armnnUtils
diff --git a/src/armnnUtils/FloatingPointConverter.hpp b/src/armnnUtils/FloatingPointConverter.hpp
new file mode 100644
index 0000000..e879c81
--- /dev/null
+++ b/src/armnnUtils/FloatingPointConverter.hpp
@@ -0,0 +1,21 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#pragma once
+
+#include <cstddef>
+
+namespace armnnUtils
+{
+class FloatingPointConverter
+{
+public:
+    // Converts a buffer of FP32 values to FP16, and stores in the given dstFloat16Buffer.
+    // dstFloat16Buffer should be (numElements * 2) in size
+    static void ConvertFloat32To16(const float *srcFloat32Buffer, size_t numElements, void *dstFloat16Buffer);
+
+    static void ConvertFloat16To32(const void *srcFloat16Buffer, size_t numElements, float *dstFloat32Buffer);
+};
+} //namespace armnnUtils
diff --git a/src/armnnUtils/GraphTopologicalSort.hpp b/src/armnnUtils/GraphTopologicalSort.hpp
index f455289..86eb4cc 100644
--- a/src/armnnUtils/GraphTopologicalSort.hpp
+++ b/src/armnnUtils/GraphTopologicalSort.hpp
@@ -5,11 +5,14 @@
 #pragma once
 
 #include <boost/assert.hpp>
+#include <boost/optional.hpp>
 
 #include <functional>
 #include <map>
+#include <stack>
 #include <vector>
 
+
 namespace armnnUtils
 {
 
@@ -22,51 +25,88 @@
     Visited,
 };
 
+
+template <typename TNodeId>
+boost::optional<TNodeId> GetNextChild(TNodeId node,
+                                      std::function<std::vector<TNodeId>(TNodeId)> getIncomingEdges,
+                                      std::map<TNodeId, NodeState>& nodeStates)
+{
+    for (TNodeId childNode : getIncomingEdges(node))
+    {
+        if (nodeStates.find(childNode) == nodeStates.end())
+        {
+            return childNode;
+        }
+        else
+        {
+            if (nodeStates.find(childNode)->second == NodeState::Visiting)
+            {
+                return childNode;
+            }
+        }
+    }
+
+    return {};
+}
+
 template<typename TNodeId>
-bool Visit(
-    TNodeId current,
+bool TopologicallySort(
+    TNodeId initialNode,
     std::function<std::vector<TNodeId>(TNodeId)> getIncomingEdges,
     std::vector<TNodeId>& outSorted,
     std::map<TNodeId, NodeState>& nodeStates)
 {
-    auto currentStateIt = nodeStates.find(current);
-    if (currentStateIt != nodeStates.end())
+    std::stack<TNodeId> nodeStack;
+
+    // If the node is never visited we should search it
+    if (nodeStates.find(initialNode) == nodeStates.end())
     {
-        if (currentStateIt->second == NodeState::Visited)
-        {
-            return true;
-        }
-        if (currentStateIt->second == NodeState::Visiting)
-        {
-            return false;
-        }
-        else
-        {
-            BOOST_ASSERT(false);
-        }
+        nodeStack.push(initialNode);
     }
 
-    nodeStates[current] = NodeState::Visiting;
-
-    for (TNodeId inputNode : getIncomingEdges(current))
+    while (!nodeStack.empty())
     {
-        Visit(inputNode, getIncomingEdges, outSorted, nodeStates);
+        TNodeId current = nodeStack.top();
+
+        nodeStates[current] = NodeState::Visiting;
+
+        boost::optional<TNodeId> nextChildOfCurrent = GetNextChild(current, getIncomingEdges, nodeStates);
+
+        if (nextChildOfCurrent)
+        {
+            TNodeId nextChild = nextChildOfCurrent.get();
+
+            // If the child has not been searched, add to the stack and iterate over this node
+            if (nodeStates.find(nextChild) == nodeStates.end())
+            {
+                nodeStack.push(nextChild);
+                continue;
+            }
+
+            // If we re-encounter a node being visited there is a cycle
+            if (nodeStates[nextChild] == NodeState::Visiting)
+            {
+                return false;
+            }
+        }
+
+        nodeStack.pop();
+
+        nodeStates[current] = NodeState::Visited;
+        outSorted.push_back(current);
     }
 
-    nodeStates[current] = NodeState::Visited;
-
-    outSorted.push_back(current);
     return true;
 }
 
 }
 
-// Sorts an directed acyclic graph (DAG) into a flat list such that all inputs to a node are before the node itself.
+// Sorts a directed acyclic graph (DAG) into a flat list such that all inputs to a node are before the node itself.
 // Returns true if successful or false if there is an error in the graph structure (e.g. it contains a cycle).
 // The graph is defined entirely by the "getIncomingEdges" function which the user provides. For a given node,
 // it must return the list of nodes which are required to come before it.
 // "targetNodes" is the list of nodes where the search begins - i.e. the nodes that you want to evaluate.
-// The implementation is based on https://en.wikipedia.org/wiki/Topological_sorting#Depth-first_search
+// This is an iterative implementation based on https://en.wikipedia.org/wiki/Topological_sorting#Depth-first_search
 template<typename TNodeId, typename TTargetNodes>
 bool GraphTopologicalSort(
     const TTargetNodes& targetNodes,
@@ -78,7 +118,7 @@
 
     for (TNodeId targetNode : targetNodes)
     {
-        if (!Visit(targetNode, getIncomingEdges, outSorted, nodeStates))
+        if (!TopologicallySort(targetNode, getIncomingEdges, outSorted, nodeStates))
         {
             return false;
         }
diff --git a/src/armnnUtils/HeapProfiling.hpp b/src/armnnUtils/HeapProfiling.hpp
index febcbfe..4ba38f5 100644
--- a/src/armnnUtils/HeapProfiling.hpp
+++ b/src/armnnUtils/HeapProfiling.hpp
@@ -9,8 +9,8 @@
 #include <string>
 #include <cstddef>
 
-// this is conditional so we can change the environment variable
-// at build time
+// This is conditional so we can change the environment variable
+// at build time.
 #ifndef ARMNN_HEAP_PROFILE_DUMP_DIR
 #define ARMNN_HEAP_PROFILE_DUMP_DIR "ARMNN_HEAP_PROFILE_DUMP_DIR"
 #endif // ARMNN_HEAP_PROFILE_DUMP_DIR
@@ -24,12 +24,12 @@
     ~ScopedHeapProfiler();
 
 private:
-    // Location comes from the ARMNN_HEAP_PROFILE_DUMP_DIR
-    // if not available then it dumps to /tmp
+    // Location comes from the ARMNN_HEAP_PROFILE_DUMP_DIR.
+    // If it is not available then it dumps to /tmp.
     std::string m_Location;
     std::string m_Tag;
 
-    // No default construction and copying
+    // No default construction and copying.
     ScopedHeapProfiler() = delete;
     ScopedHeapProfiler(const ScopedHeapProfiler &) = delete;
     ScopedHeapProfiler & operator=(const ScopedHeapProfiler &) = delete;
diff --git a/src/armnnUtils/LeakChecking.cpp b/src/armnnUtils/LeakChecking.cpp
index ac12fe0..83aa5d8 100644
--- a/src/armnnUtils/LeakChecking.cpp
+++ b/src/armnnUtils/LeakChecking.cpp
@@ -8,6 +8,9 @@
 #include "LeakChecking.hpp"
 #include "gperftools/heap-checker.h"
 
+namespace armnnUtils
+{
+
 struct ScopedLeakChecker::Impl
 {
     HeapLeakChecker m_LeakChecker;
@@ -59,4 +62,20 @@
 {
 }
 
+void LocalLeakCheckingOnly()
+{
+    auto * globalChecker = HeapLeakChecker::GlobalChecker();
+    if (globalChecker)
+    {
+        // Don't care about global leaks and make sure we won't report any.
+        // This is because leak checking supposed to run in well defined
+        // contexts through the ScopedLeakChecker, otherwise we risk false
+        // positives because of external factors.
+        globalChecker->NoGlobalLeaks();
+        globalChecker->CancelGlobalCheck();
+    }
+}
+
+} // namespace armnnUtils
+
 #endif // ARMNN_LEAK_CHECKING_ENABLED
diff --git a/src/armnnUtils/LeakChecking.hpp b/src/armnnUtils/LeakChecking.hpp
index b65befe..22b3b67 100644
--- a/src/armnnUtils/LeakChecking.hpp
+++ b/src/armnnUtils/LeakChecking.hpp
@@ -19,7 +19,7 @@
     ScopedLeakChecker(const std::string & name);
     ~ScopedLeakChecker();
 
-    // forwarding these to Google Performance Tools
+    // Forwarding these to Google Performance Tools.
     static bool IsActive();
     bool NoLeaks();
     // Note that the following two functions only work after
@@ -29,12 +29,12 @@
     ssize_t ObjectsLeaked() const;
 
 private:
-    // hide imlementation so we don't litter other's namespaces
-    // with heap checker related stuff
+    // Hides imlementation so we don't litter other's namespaces
+    // with heap checker related stuff.
     struct Impl;
     std::unique_ptr<Impl> m_Impl;
 
-    // No default construction and copying
+    // No default construction and copying.
     ScopedLeakChecker() = delete;
     ScopedLeakChecker(const ScopedLeakChecker &) = delete;
     ScopedLeakChecker & operator=(const ScopedLeakChecker &) = delete;
@@ -47,16 +47,19 @@
     ~ScopedDisableLeakChecking();
 
 private:
-    // hide imlementation so we don't litter other's namespaces
-    // with heap checker related stuff
+    // Hides imlementation so we don't litter other's namespaces
+    // with heap checker related stuff.
     struct Impl;
     std::unique_ptr<Impl> m_Impl;
 
-    // No copying
+    // No copying.
     ScopedDisableLeakChecking(const ScopedDisableLeakChecking &) = delete;
     ScopedDisableLeakChecking & operator=(const ScopedDisableLeakChecking &) = delete;
 };
 
+// disable global leak checks starting from 'main'
+void LocalLeakCheckingOnly();
+
 } // namespace armnnUtils
 
 #define ARMNN_SCOPED_LEAK_CHECKER(TAG) \
@@ -77,6 +80,9 @@
 #define ARMNN_DISABLE_LEAK_CHECKING_IN_SCOPE() \
     armnnUtils::ScopedDisableLeakChecking __disable_leak_checking_in_scope__
 
+#define ARMNN_LOCAL_LEAK_CHECKING_ONLY() \
+    armnnUtils::LocalLeakCheckingOnly()
+
 #else // ARMNN_LEAK_CHECKING_ENABLED
 
 #define ARMNN_SCOPED_LEAK_CHECKER(TAG)
@@ -85,5 +91,6 @@
 #define ARMNN_BYTES_LEAKED_IN_SCOPE() 0
 #define ARMNN_OBJECTS_LEAKED_IN_SCOPE() 0
 #define ARMNN_DISABLE_LEAK_CHECKING_IN_SCOPE()
+#define ARMNN_LOCAL_LEAK_CHECKING_ONLY()
 
 #endif // ARMNN_LEAK_CHECKING_ENABLED
diff --git a/src/armnnUtils/Logging.cpp b/src/armnnUtils/Logging.cpp
index 95978d4..4d759a3 100644
--- a/src/armnnUtils/Logging.cpp
+++ b/src/armnnUtils/Logging.cpp
@@ -47,7 +47,7 @@
     // stdout, so we have to explicitly disable logging in this case.
     core->set_logging_enabled(printToStandardOutput || printToDebugOutput);
 
-    // Setup severity filter
+    // Sets up severity filter.
     boost::log::trivial::severity_level boostSeverity;
     switch (severity)
     {
diff --git a/src/armnnUtils/ParserFlatbuffersFixture.hpp b/src/armnnUtils/ParserFlatbuffersFixture.hpp
deleted file mode 100644
index 16f9620..0000000
--- a/src/armnnUtils/ParserFlatbuffersFixture.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// See LICENSE file in the project root for full license information.
-//
-
-#pragma once
-
-namespace armnnUtils
-{
-
-}
diff --git a/src/armnnUtils/ParserPrototxtFixture.hpp b/src/armnnUtils/ParserPrototxtFixture.hpp
index 81e3057..e2e6459 100644
--- a/src/armnnUtils/ParserPrototxtFixture.hpp
+++ b/src/armnnUtils/ParserPrototxtFixture.hpp
@@ -6,11 +6,15 @@
 #pragma once
 
 #include "armnn/IRuntime.hpp"
+#include "armnnOnnxParser/IOnnxParser.hpp"
 #include "test/TensorHelpers.hpp"
+#include "VerificationHelpers.hpp"
+
+#include <boost/format.hpp>
 #include <string>
 
-
-// TODO davbec01 (14/05/18) : put these into armnnUtils namespace
+namespace armnnUtils
+{
 
 template<typename TParser>
 struct ParserPrototxtFixture
@@ -19,14 +23,15 @@
         : m_Parser(TParser::Create())
         , m_NetworkIdentifier(-1)
     {
-        m_Runtimes.push_back(armnn::IRuntime::Create(armnn::Compute::CpuRef));
+        armnn::IRuntime::CreationOptions options;
+        m_Runtimes.push_back(std::make_pair(armnn::IRuntime::Create(options), armnn::Compute::CpuRef));
 
 #if ARMCOMPUTENEON_ENABLED
-        m_Runtimes.push_back(armnn::IRuntime::Create(armnn::Compute::CpuAcc));
+        m_Runtimes.push_back(std::make_pair(armnn::IRuntime::Create(options), armnn::Compute::CpuAcc));
 #endif
 
 #if ARMCOMPUTECL_ENABLED
-        m_Runtimes.push_back(armnn::IRuntime::Create(armnn::Compute::GpuAcc));
+        m_Runtimes.push_back(std::make_pair(armnn::IRuntime::Create(options), armnn::Compute::GpuAcc));
 #endif
     }
 
@@ -38,10 +43,11 @@
         const std::string& outputName);
     void Setup(const std::map<std::string, armnn::TensorShape>& inputShapes,
         const std::vector<std::string>& requestedOutputs);
+    void Setup();
     /// @}
 
     /// Executes the network with the given input tensor and checks the result against the given output tensor.
-    /// This overload assumes the network has a single input and a single output.
+    /// This overload assumes that the network has a single input and a single output.
     template <std::size_t NumOutputDimensions>
     void RunTest(const std::vector<float>& inputData, const std::vector<float>& expectedOutputData);
 
@@ -53,7 +59,7 @@
 
     std::string                                         m_Prototext;
     std::unique_ptr<TParser, void(*)(TParser* parser)>  m_Parser;
-    std::vector<armnn::IRuntimePtr>                     m_Runtimes;
+    std::vector<std::pair<armnn::IRuntimePtr, armnn::Compute>> m_Runtimes;
     armnn::NetworkId                                    m_NetworkIdentifier;
 
     /// If the single-input-single-output overload of Setup() is called, these will store the input and output name
@@ -68,7 +74,7 @@
 void ParserPrototxtFixture<TParser>::SetupSingleInputSingleOutput(const std::string& inputName,
     const std::string& outputName)
 {
-    // Store the input and output name so they don't need to be passed to the single-input-single-output RunTest().
+    // Stores the input and output name so they don't need to be passed to the single-input-single-output RunTest().
     m_SingleInputName = inputName;
     m_SingleOutputName = outputName;
     Setup({ }, { outputName });
@@ -79,7 +85,7 @@
     const std::string& inputName,
     const std::string& outputName)
 {
-    // Store the input and output name so they don't need to be passed to the single-input-single-output RunTest().
+    // Stores the input and output name so they don't need to be passed to the single-input-single-output RunTest().
     m_SingleInputName = inputName;
     m_SingleOutputName = outputName;
     Setup({ { inputName, inputTensorShape } }, { outputName });
@@ -91,16 +97,39 @@
 {
     for (auto&& runtime : m_Runtimes)
     {
+        std::string errorMessage;
+
         armnn::INetworkPtr network =
             m_Parser->CreateNetworkFromString(m_Prototext.c_str(), inputShapes, requestedOutputs);
-
-        auto optimized = Optimize(*network, runtime->GetDeviceSpec());
-
-        armnn::Status ret = runtime->LoadNetwork(m_NetworkIdentifier, move(optimized));
-
+        auto optimized = Optimize(*network, { runtime.second, armnn::Compute::CpuRef }, runtime.first->GetDeviceSpec());
+        armnn::Status ret = runtime.first->LoadNetwork(m_NetworkIdentifier, move(optimized), errorMessage);
         if (ret != armnn::Status::Success)
         {
-            throw armnn::Exception("LoadNetwork failed");
+            throw armnn::Exception(boost::str(
+                boost::format("LoadNetwork failed with error: '%1%' %2%")
+                              % errorMessage
+                              % CHECK_LOCATION().AsString()));
+        }
+    }
+}
+
+template<typename TParser>
+void ParserPrototxtFixture<TParser>::Setup()
+{
+    for (auto&& runtime : m_Runtimes)
+    {
+        std::string errorMessage;
+
+        armnn::INetworkPtr network =
+            m_Parser->CreateNetworkFromString(m_Prototext.c_str());
+        auto optimized = Optimize(*network, { runtime.second, armnn::Compute::CpuRef }, runtime.first->GetDeviceSpec());
+        armnn::Status ret = runtime.first->LoadNetwork(m_NetworkIdentifier, move(optimized), errorMessage);
+        if (ret != armnn::Status::Success)
+        {
+            throw armnn::Exception(boost::str(
+                boost::format("LoadNetwork failed with error: '%1%' %2%")
+                              % errorMessage
+                              % CHECK_LOCATION().AsString()));
         }
     }
 }
@@ -122,7 +151,7 @@
     {
         using BindingPointInfo = std::pair<armnn::LayerBindingId, armnn::TensorInfo>;
 
-        // Setup the armnn input tensors from the given vectors.
+        // Sets up the armnn input tensors from the given vectors.
         armnn::InputTensors inputTensors;
         for (auto&& it : inputData)
         {
@@ -130,7 +159,7 @@
             inputTensors.push_back({ bindingInfo.first, armnn::ConstTensor(bindingInfo.second, it.second.data()) });
         }
 
-        // Allocate storage for the output tensors to be written to and setup the armnn output tensors.
+        // Allocates storage for the output tensors to be written to and sets up the armnn output tensors.
         std::map<std::string, boost::multi_array<float, NumOutputDimensions>> outputStorage;
         armnn::OutputTensors outputTensors;
         for (auto&& it : expectedOutputData)
@@ -141,14 +170,27 @@
                 { bindingInfo.first, armnn::Tensor(bindingInfo.second, outputStorage.at(it.first).data()) });
         }
 
-        runtime->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);
+        runtime.first->EnqueueWorkload(m_NetworkIdentifier, inputTensors, outputTensors);
 
-        // Compare each output tensor to the expected values
+        // Compares each output tensor to the expected values.
         for (auto&& it : expectedOutputData)
         {
             BindingPointInfo bindingInfo = m_Parser->GetNetworkOutputBindingInfo(it.first);
+            if (bindingInfo.second.GetNumElements() != it.second.size())
+            {
+                throw armnn::Exception(
+                    boost::str(
+                        boost::format("Output tensor %1% is expected to have %2% elements. "
+                                      "%3% elements supplied. %4%") %
+                                      it.first %
+                                      bindingInfo.second.GetNumElements() %
+                                      it.second.size() %
+                                      CHECK_LOCATION().AsString()));
+            }
             auto outputExpected = MakeTensor<float, NumOutputDimensions>(bindingInfo.second, it.second);
             BOOST_TEST(CompareTensors(outputExpected, outputStorage[it.first]));
         }
     }
 }
+
+} // namespace armnnUtils
diff --git a/src/armnnUtils/Permute.cpp b/src/armnnUtils/Permute.cpp
index 58e5858..ba842db 100644
--- a/src/armnnUtils/Permute.cpp
+++ b/src/armnnUtils/Permute.cpp
@@ -107,7 +107,7 @@
     PermuteLoop(dstShape, mappings).Unroll(src, dst);
 }
 
-// Instantiate for types
+// Instantiates for types.
 template void Permute(const armnn::TensorShape& dstShape, const armnn::PermutationVector& mappings,
                       const float* src, float* dst);
 template void Permute(const armnn::TensorShape& dstShape, const armnn::PermutationVector& mappings,
diff --git a/src/armnnUtils/VerificationHelpers.cpp b/src/armnnUtils/VerificationHelpers.cpp
new file mode 100644
index 0000000..301aa4c
--- /dev/null
+++ b/src/armnnUtils/VerificationHelpers.cpp
@@ -0,0 +1,74 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include "VerificationHelpers.hpp"
+#include <boost/format.hpp>
+#include <armnn/Exceptions.hpp>
+
+using namespace armnn;
+
+namespace armnnUtils
+{
+
+void CheckValidSize(std::initializer_list<size_t> validInputCounts,
+                    size_t actualValue,
+                    const char* validExpr,
+                    const char* actualExpr,
+                    const CheckLocation& location)
+{
+    bool isValid = std::any_of(validInputCounts.begin(),
+                               validInputCounts.end(),
+                               [&actualValue](size_t x) { return x == actualValue; } );
+    if (!isValid)
+    {
+        throw ParseException(
+            boost::str(
+                boost::format("%1% = %2% is not valid, not in {%3%}. %4%") %
+                              actualExpr %
+                              actualValue %
+                              validExpr %
+                              location.AsString()));
+    }
+}
+
+uint32_t NonNegative(const char* expr,
+                     int32_t value,
+                     const CheckLocation& location)
+{
+    if (value < 0)
+    {
+        throw ParseException(
+            boost::str(
+                boost::format("'%1%' must be non-negative, received: %2% at %3%") %
+                              expr %
+                              value %
+                              location.AsString() ));
+    }
+    else
+    {
+        return static_cast<uint32_t>(value);
+    }
+}
+
+int32_t VerifyInt32(const char* expr,
+                     int64_t value,
+                     const armnn::CheckLocation& location)
+{
+    if (value < std::numeric_limits<int>::min()  || value > std::numeric_limits<int>::max())
+    {
+        throw ParseException(
+            boost::str(
+                boost::format("'%1%' must should fit into a int32 (ArmNN don't support int64), received: %2% at %3%") %
+                              expr %
+                              value %
+                              location.AsString() ));
+    }
+    else
+    {
+        return static_cast<int32_t>(value);
+    }
+}
+
+}// armnnUtils
diff --git a/src/armnnUtils/VerificationHelpers.hpp b/src/armnnUtils/VerificationHelpers.hpp
new file mode 100644
index 0000000..8e3550c
--- /dev/null
+++ b/src/armnnUtils/VerificationHelpers.hpp
@@ -0,0 +1,35 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+#include <iostream>
+#include <sstream>
+
+#include <armnn/Exceptions.hpp>
+
+namespace armnnUtils
+{
+
+void CheckValidSize(std::initializer_list<size_t> validInputCounts,
+                    size_t actualValue,
+                    const char* validExpr,
+                    const char* actualExpr,
+                    const armnn::CheckLocation& location);
+
+uint32_t NonNegative(const char* expr,
+                     int32_t value,
+                     const armnn::CheckLocation& location);
+
+int32_t VerifyInt32(const char* expr,
+                    int64_t value,
+                    const armnn::CheckLocation& location);
+
+}//armnnUtils
+
+#define CHECKED_INT32(VALUE) armnnUtils::VerifyInt32(#VALUE, VALUE, CHECK_LOCATION())
+
+#define CHECK_VALID_SIZE(ACTUAL, ...) \
+armnnUtils::CheckValidSize({__VA_ARGS__}, ACTUAL, #__VA_ARGS__, #ACTUAL, CHECK_LOCATION())
+
+#define CHECKED_NON_NEGATIVE(VALUE) armnnUtils::NonNegative(#VALUE, VALUE, CHECK_LOCATION())