diff --git a/src/backends/cl/test/ClLayerTests.cpp b/src/backends/cl/test/ClLayerTests.cpp
index a4f824a..d5e9419 100755
--- a/src/backends/cl/test/ClLayerTests.cpp
+++ b/src/backends/cl/test/ClLayerTests.cpp
@@ -248,9 +248,9 @@
 ARMNN_AUTO_TEST_CASE(SimpleReshapeUint8, SimpleReshapeUint8Test)
 
 // Pad
-ARMNN_AUTO_TEST_CASE(Pad2d, Pad2dTest)
-ARMNN_AUTO_TEST_CASE(Pad3d, Pad3dTest)
-ARMNN_AUTO_TEST_CASE(Pad4d, Pad4dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat322d, PadFloat322dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat323d, PadFloat323dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat324d, PadFloat324dTest)
 
 // Permute
 ARMNN_AUTO_TEST_CASE(SimplePermuteFloat32, SimplePermuteFloat32Test)
diff --git a/src/backends/reference/RefWorkloadFactory.cpp b/src/backends/reference/RefWorkloadFactory.cpp
index 4d157d4..b1f9d6c 100644
--- a/src/backends/reference/RefWorkloadFactory.cpp
+++ b/src/backends/reference/RefWorkloadFactory.cpp
@@ -249,7 +249,7 @@
 std::unique_ptr<IWorkload> RefWorkloadFactory::CreatePad(const PadQueueDescriptor& descriptor,
                                                  const WorkloadInfo& info) const
 {
-    return MakeWorkload<RefPadWorkload, NullWorkload>(descriptor, info);
+    return MakeWorkload<RefPadFloat32Workload, RefPadUint8Workload>(descriptor, info);
 }
 
 
diff --git a/src/backends/reference/test/RefLayerTests.cpp b/src/backends/reference/test/RefLayerTests.cpp
index 259739b..9f044cd 100644
--- a/src/backends/reference/test/RefLayerTests.cpp
+++ b/src/backends/reference/test/RefLayerTests.cpp
@@ -213,9 +213,13 @@
 ARMNN_AUTO_TEST_CASE(L2Normalization4d, L2Normalization4dTest)
 
 // Pad
-ARMNN_AUTO_TEST_CASE(Pad2d, Pad2dTest)
-ARMNN_AUTO_TEST_CASE(Pad3d, Pad3dTest)
-ARMNN_AUTO_TEST_CASE(Pad4d, Pad4dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat322d, PadFloat322dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat323d, PadFloat323dTest)
+ARMNN_AUTO_TEST_CASE(PadFloat324d, PadFloat324dTest)
+
+ARMNN_AUTO_TEST_CASE(PadUint82d, PadUint82dTest)
+ARMNN_AUTO_TEST_CASE(PadUint83d, PadUint83dTest)
+ARMNN_AUTO_TEST_CASE(PadUint84d, PadUint84dTest)
 
 ARMNN_AUTO_TEST_CASE(L2Normalization1dNhwc, L2Normalization1dNhwcTest)
 ARMNN_AUTO_TEST_CASE(L2Normalization2dNhwc, L2Normalization2dNhwcTest)
diff --git a/src/backends/reference/workloads/Pad.cpp b/src/backends/reference/workloads/Pad.cpp
index 5c85931..a50fa23 100644
--- a/src/backends/reference/workloads/Pad.cpp
+++ b/src/backends/reference/workloads/Pad.cpp
@@ -5,24 +5,22 @@
 
 #include "Pad.hpp"
 #include "backends/WorkloadData.hpp"
-
 #include <boost/numeric/conversion/cast.hpp>
 #include "TensorBufferArrayView.hpp"
-
 #include <cmath>
 #include <cstddef>
 #include <functional>
 #include <limits>
 #include <cassert>
 
-
 namespace armnn
 {
+template <typename T>
 void Pad(const TensorInfo& inputInfo,
          const TensorInfo& outputInfo,
          std::vector<std::pair<unsigned int, unsigned int>> m_PadList,
-         const float* inputData,
-         float* outData)
+         const T* inputData,
+         T* outData)
 {
     unsigned int numOutputElements = outputInfo.GetNumElements();
 
@@ -30,10 +28,12 @@
     TensorShape inputShape = inputInfo.GetShape();
 
     unsigned int numInputDimensions = inputShape.GetNumDimensions();
-    #ifndef NDEBUG
-    unsigned int numOutputDimensions = outputShape.GetNumDimensions();
 
+    #ifndef NDEBUG
+
+    unsigned int numOutputDimensions = outputShape.GetNumDimensions();
     assert(numInputDimensions == numOutputDimensions);
+
     #endif
 
     unsigned int inputBatches = 0;
@@ -51,29 +51,27 @@
     }
 
     switch(numInputDimensions) {
+
         case 1:
 
             inputWidth = inputShape[0];
 
             for (unsigned int w = 0; w < inputWidth ; w++)
             {
-
                 outData[w+std::get<0>(m_PadList[0])] = inputData[w];
-
             }
 
             break;
+
         case 2  :
 
             inputHeight = inputShape[0];
             inputWidth = inputShape[1];
-
             outputHeight = outputShape[0];
             outputWidth = outputShape[1];
 
             for (unsigned int h = 0; h < inputHeight; h++)
             {
-
                 for (unsigned int w = 0; w < inputWidth ; w++)
                 {
                     outData[(h+std::get<0>(m_PadList[0]))*outputWidth
@@ -82,25 +80,22 @@
             }
 
             break;
+
         case 3  :
 
             inputChannels = inputShape[0];
             inputHeight = inputShape[1];
             inputWidth = inputShape[2];
-
             outputChannels = outputShape[0];
             outputHeight = outputShape[1];
             outputWidth = outputShape[2];
 
             for (unsigned int c = 0; c < inputChannels; c++)
             {
-
                 for (unsigned int h = 0; h < inputHeight; h++)
                 {
-
                     for (unsigned int w = 0; w < inputWidth ; w++)
                     {
-
                         outData[(c+std::get<0>(m_PadList[0]))*outputHeight*outputWidth
                         + (h+std::get<0>(m_PadList[1]))*outputWidth
                         + (w+std::get<0>(m_PadList[2]))] = inputData[c * inputHeight * inputWidth
@@ -111,13 +106,13 @@
             }
 
             break;
+
         case 4  :
 
             inputBatches = inputShape[0];
             inputChannels = inputShape[1];
             inputHeight = inputShape[2];
             inputWidth = inputShape[3];
-
             outputChannels = outputShape[1];
             outputHeight = outputShape[2];
             outputWidth = outputShape[3];
@@ -126,13 +121,10 @@
             {
                 for (unsigned int c = 0; c < inputChannels; c++)
                 {
-
                     for (unsigned int h = 0; h < inputHeight; h++)
                     {
-
                         for (unsigned int w = 0; w < inputWidth ; w++)
                         {
-
                             outData[(b+std::get<0>(m_PadList[0])) * outputChannels * outputHeight * outputWidth
                                    + (c+std::get<0>(m_PadList[1])) * outputHeight * outputWidth
                                    + (h+std::get<0>(m_PadList[2])) * outputWidth
@@ -141,7 +133,6 @@
                                                                              + c * inputHeight * inputWidth
                                                                              + h * inputWidth
                                                                              + w];
-
                         }
                     }
                 }
@@ -150,9 +141,20 @@
             break;
 
         default :
+
             break;
     }
-
 }
 
-} //namespace armnn
+template void Pad<float>(const TensorInfo& inputInfo,
+                         const TensorInfo& outputInfo,
+                         std::vector<std::pair<unsigned int, unsigned int>> m_PadList,
+                         const float* inputData,
+                         float* outData);
+template void Pad<uint8_t>(const TensorInfo& inputInfo,
+                           const TensorInfo& outputInfo,
+                           std::vector<std::pair<unsigned int, unsigned int>> m_PadList,
+                           const uint8_t* inputData,
+                           uint8_t* outData);
+
+} //namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/Pad.hpp b/src/backends/reference/workloads/Pad.hpp
index ed80ef8..42318d6 100644
--- a/src/backends/reference/workloads/Pad.hpp
+++ b/src/backends/reference/workloads/Pad.hpp
@@ -12,9 +12,10 @@
 
 namespace armnn
 {
+template <typename T>
 void Pad(const TensorInfo& inputInfo,
-        const TensorInfo& outputInfo,
-        std::vector<std::pair<unsigned int, unsigned int>> m_PadList,
-        const float* inputData,
-        float* outData);
+         const TensorInfo& outputInfo,
+         std::vector<std::pair<unsigned int, unsigned int>> m_PadList,
+         const T* inputData,
+         T* outData);
 } //namespace armnn
diff --git a/src/backends/reference/workloads/RefPadWorkload.cpp b/src/backends/reference/workloads/RefPadWorkload.cpp
index 233fbe4..b41c2de 100644
--- a/src/backends/reference/workloads/RefPadWorkload.cpp
+++ b/src/backends/reference/workloads/RefPadWorkload.cpp
@@ -10,28 +10,31 @@
 
 #include "Profiling.hpp"
 
+#include "TypeUtils.hpp"
+
 #include <vector>
 
 namespace armnn
 {
 
-RefPadWorkload::RefPadWorkload(const PadQueueDescriptor& descriptor, const WorkloadInfo& info)
-  :BaseWorkload<PadQueueDescriptor>(descriptor, info) {}
-
-
-void RefPadWorkload::Execute() const
+template <armnn::DataType DataType>
+void RefPadWorkload<DataType>::Execute() const
 {
+    using T = ResolveType<DataType>;
 
     ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, "RefPadWorkload_Execute");
 
     const TensorInfo& inputInfo = GetTensorInfo(m_Data.m_Inputs[0]);
     const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]);
 
-    const float* inputData = GetInputTensorDataFloat(0, m_Data);
-    float* outputData = GetOutputTensorDataFloat(0, m_Data);
+    const T* inputData = GetInputTensorData<T>(0, m_Data);
+    T* outputData = GetOutputTensorData<T>(0, m_Data);
 
 
     Pad(inputInfo, outputInfo, m_Data.m_Parameters.m_PadList, inputData, outputData);
 }
 
+template class RefPadWorkload<DataType::Float32>;
+template class RefPadWorkload<DataType::QuantisedAsymm8>;
+
 } //namespace armnn
\ No newline at end of file
diff --git a/src/backends/reference/workloads/RefPadWorkload.hpp b/src/backends/reference/workloads/RefPadWorkload.hpp
index 7ff117d..938fcf2 100644
--- a/src/backends/reference/workloads/RefPadWorkload.hpp
+++ b/src/backends/reference/workloads/RefPadWorkload.hpp
@@ -5,17 +5,32 @@
 
 #pragma once
 
-#include "backends/Workload.hpp"
-#include "backends/WorkloadData.hpp"
+#include <backends/Workload.hpp>
+#include <backends/WorkloadData.hpp>
+
+#include <armnn/TypesUtils.hpp>
 
 namespace armnn
 {
 
-class RefPadWorkload : public BaseWorkload<PadQueueDescriptor>
+template <armnn::DataType DataType>
+class RefPadWorkload : public TypedWorkload<PadQueueDescriptor, DataType>
 {
 public:
-    explicit RefPadWorkload (const PadQueueDescriptor& descriptor, const WorkloadInfo& info);
-    virtual void Execute() const override;
+
+    static const std::string& GetName()
+    {
+        static const std::string name = std::string("RefPad") + GetDataTypeName(DataType) + "Workload";
+        return name;
+    }
+
+    using TypedWorkload<PadQueueDescriptor, DataType>::m_Data;
+    using TypedWorkload<PadQueueDescriptor, DataType>::TypedWorkload;
+
+    void Execute() const override;
 };
 
+using RefPadFloat32Workload = RefPadWorkload<DataType::Float32>;
+using RefPadUint8Workload   = RefPadWorkload<DataType::QuantisedAsymm8>;
+
 } //namespace armnn
diff --git a/src/backends/reference/workloads/RefPermuteWorkload.hpp b/src/backends/reference/workloads/RefPermuteWorkload.hpp
index 841a080..50caa3e 100644
--- a/src/backends/reference/workloads/RefPermuteWorkload.hpp
+++ b/src/backends/reference/workloads/RefPermuteWorkload.hpp
@@ -31,4 +31,4 @@
 using RefPermuteFloat32Workload = RefPermuteWorkload<DataType::Float32>;
 using RefPermuteUint8Workload   = RefPermuteWorkload<DataType::QuantisedAsymm8>;
 
-} //namespace armnn
+} //namespace armnn
\ No newline at end of file
diff --git a/src/backends/test/LayerTests.cpp b/src/backends/test/LayerTests.cpp
index 95f2a32..e762152 100755
--- a/src/backends/test/LayerTests.cpp
+++ b/src/backends/test/LayerTests.cpp
@@ -3441,123 +3441,120 @@
 
 } // anonymous namespace
 
-LayerTestResult<float, 2> Pad2dTest(armnn::IWorkloadFactory& workloadFactory)
+template<typename T>
+LayerTestResult<T, 2> Pad2dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
 {
-    const armnn::TensorShape inputShape{ 3, 3 };
-    const armnn::TensorShape outputShape{ 7, 7 };
+  const armnn::TensorShape inputShape{ 3, 3 };
+  const armnn::TensorShape outputShape{ 7, 7 };
 
-    const armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-    const armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
+  const armnn::TensorInfo inputTensorInfo(inputShape, armnn::GetDataType<T>());
+  const armnn::TensorInfo outputTensorInfo(outputShape, armnn::GetDataType<T>());
 
-
-    std::vector<float> inputValues
+  std::vector<T> inputValues(
+    QuantizedVector<T>(qScale, qOffset,
     {
+      // Height (3) x Width (3)
+      4, 8, 6,
+      7, 4, 4,
+      3, 2, 4
+    }));
 
-        // Height (3) x Width (3)
-        4.0f, 8.0f, 6.0f,
-        7.0f, 4.0f, 4.0f,
-        3.0f, 2.0f, 4.0f
-
-    };
-
-    std::vector<float> expectedOutputValues
+ std::vector<T> expectedOutputValues(
+  QuantizedVector<T>(qScale, qOffset,
     {
+      0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0,
+      0, 0, 4, 8, 6, 0, 0,
+      0, 0, 7, 4, 4, 0, 0,
+      0, 0, 3, 2, 4, 0, 0,
+      0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0
+    }));
 
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 7.0f, 4.0f, 4.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 3.0f, 2.0f, 4.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
+  auto inputTensor = MakeTensor<T, 2>(inputTensorInfo, std::vector<T>(inputValues));
 
-    };
+  LayerTestResult<T, 2> result(outputTensorInfo);
+  result.outputExpected = MakeTensor<T, 2>(outputTensorInfo, std::vector<T>(expectedOutputValues));
 
-    auto inputTensor = MakeTensor<float, 2>(inputTensorInfo, std::vector<float>(inputValues));
+  std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
+  std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
 
-    LayerTestResult<float, 2> result(outputTensorInfo);
-    result.outputExpected = MakeTensor<float, 2>(outputTensorInfo, std::vector<float>(expectedOutputValues));
+  armnn::PadQueueDescriptor descriptor;
 
-    std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
-    std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
+  std::vector<std::pair<unsigned int, unsigned int>> PadList;
+  PadList.push_back(std::pair<unsigned int, unsigned int>(2,2));
+  PadList.push_back(std::pair<unsigned int, unsigned int>(2,2));
 
-    armnn::PadQueueDescriptor descriptor;
+  descriptor.m_Parameters.m_PadList = PadList;
+  armnn::WorkloadInfo info;
 
-    std::vector<std::pair<unsigned int, unsigned int>> PadList;
-    PadList.push_back(std::pair<unsigned int, unsigned int>(2,2));
-    PadList.push_back(std::pair<unsigned int, unsigned int>(2,2));
+  AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
+  AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
 
-    descriptor.m_Parameters.m_PadList = PadList;
-    armnn::WorkloadInfo info;
+  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePad(descriptor, info);
 
-    AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
-    AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
+  inputHandle->Allocate();
+  outputHandle->Allocate();
 
-    std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePad(descriptor, info);
+  CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
 
-    inputHandle->Allocate();
-    outputHandle->Allocate();
+  workloadFactory.Finalize();
+  workload->Execute();
 
-    CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
+  CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
 
-    workloadFactory.Finalize();
-    workload->Execute();
+  return result;
+}
 
-    CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
-
-    return result;
-};
-
-LayerTestResult<float, 3> Pad3dTest(armnn::IWorkloadFactory& workloadFactory)
+template <typename T>
+LayerTestResult<T, 3> Pad3dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
 {
     const armnn::TensorShape inputShape{ 2, 2, 2 };
     const armnn::TensorShape outputShape{ 3, 5, 6 };
 
-    const armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-    const armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
+    const armnn::TensorInfo inputTensorInfo(inputShape, armnn::GetDataType<T>());
+    const armnn::TensorInfo outputTensorInfo(outputShape, armnn::GetDataType<T>());
 
-
-    std::vector<float> inputValues
+    std::vector<T> inputValues(
+      QuantizedVector<T>(qScale,qOffset,
     {
-
         // Channel 0, Height (2) x Width (2)
-        0.0f, 4.0f,
-        2.0f, 5.0f,
+        0, 4,
+        2, 5,
 
         // Channel 1, Height (2) x Width (2)
-        6.0f, 1.0f,
-        5.0f, 2.0f
-    };
+        6, 1,
+        5, 2
+    }));
 
-    std::vector<float> expectedOutputValues
+    std::vector<T> expectedOutputValues(
+      QuantizedVector<T>(qScale,qOffset,
     {
 
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 4.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 2.0f, 5.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 4, 0, 0,
+        0, 0, 2, 5, 0, 0,
+        0, 0, 0, 0, 0, 0,
 
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 6, 1, 0, 0,
+        0, 0, 5, 2, 0, 0,
+        0, 0, 0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 6.0f, 1.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 5.0f, 2.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0
 
+    }));
 
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
+    auto inputTensor = MakeTensor<T, 3>(inputTensorInfo, std::vector<T>(inputValues));
 
-    };
-
-    auto inputTensor = MakeTensor<float, 3>(inputTensorInfo, std::vector<float>(inputValues));
-
-    LayerTestResult<float, 3> result(outputTensorInfo);
-    result.outputExpected = MakeTensor<float, 3>(outputTensorInfo, std::vector<float>(expectedOutputValues));
+    LayerTestResult<T, 3> result(outputTensorInfo);
+    result.outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(expectedOutputValues));
 
     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
@@ -3588,227 +3585,209 @@
     CopyDataFromITensorHandle(&result.output[0][0][0], outputHandle.get());
 
     return result;
-};
+}
 
-LayerTestResult<float, 4> Pad4dTest(armnn::IWorkloadFactory& workloadFactory)
+template <typename T>
+LayerTestResult<T, 4> Pad4dTestCommon(armnn::IWorkloadFactory& workloadFactory, float qScale, int32_t qOffset)
 {
     const armnn::TensorShape inputShape{ 2, 2, 3, 2 };
     const armnn::TensorShape outputShape{ 4, 5, 7, 4 };
 
-    const armnn::TensorInfo inputTensorInfo(inputShape, armnn::DataType::Float32);
-    const armnn::TensorInfo outputTensorInfo(outputShape, armnn::DataType::Float32);
+    const armnn::TensorInfo inputTensorInfo(inputShape, armnn::GetDataType<T>());
+    const armnn::TensorInfo outputTensorInfo(outputShape, armnn::GetDataType<T>());
 
-    std::vector<float> inputValues
+    std::vector<T> inputValues(
+      QuantizedVector<T>(qScale,qOffset,
     {
         // Batch 0, Channel 0, Height (3) x Width (2)
-        0.0f, 1.0f,
-        2.0f, 3.0f,
-        4.0f, 5.0f,
+        0, 1,
+        2, 3,
+        4, 5,
 
         // Batch 0, Channel 1, Height (3) x Width (2)
-        6.0f, 7.0f,
-        8.0f, 9.0f,
-        10.0f, 11.0f,
+        6, 7,
+        8, 9,
+        10, 11,
 
         // Batch 1, Channel 0, Height (3) x Width (2)
-        12.0f, 13.0f,
-        14.0f, 15.0f,
-        16.0f, 17.0f,
+        12, 13,
+        14, 15,
+        16, 17,
 
         // Batch 1, Channel 1, Height (3) x Width (2)
-        18.0f, 19.0f,
-        20.0f, 21.0f,
-        22.0f, 23.0f
+        18, 19,
+        20, 21,
+        22, 23
+    }));
 
-    };
-
-    std::vector<float> expectedOutputValues
+    std::vector<T> expectedOutputValues(
+      QuantizedVector<T>(qScale,qOffset,
     {
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 1, 0,
+        0, 2, 3, 0,
+        0, 4, 5, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 6, 7, 0,
+        0, 8, 9, 0,
+        0, 10, 11, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 12, 13, 0,
+        0, 14, 15, 0,
+        0, 16, 17, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 18, 19, 0,
+        0, 20, 21, 0,
+        0, 22, 23, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 1.0f, 0.0f,
-        0.0f, 2.0f, 3.0f, 0.0f,
-        0.0f, 4.0f, 5.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 6.0f, 7.0f, 0.0f,
-        0.0f, 8.0f, 9.0f, 0.0f,
-        0.0f, 10.0f, 11.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
 
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0,
+        0, 0, 0, 0
+    }));
 
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
+    auto inputTensor = MakeTensor<T, 4>(inputTensorInfo, std::vector<T>(inputValues));
 
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 12.0f, 13.0f, 0.0f,
-        0.0f, 14.0f, 15.0f, 0.0f,
-        0.0f, 16.0f, 17.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 18.0f, 19.0f, 0.0f,
-        0.0f, 20.0f, 21.0f, 0.0f,
-        0.0f, 22.0f, 23.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-
-
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f,
-        0.0f, 0.0f, 0.0f, 0.0f
-
-    };
-
-    auto inputTensor = MakeTensor<float, 4>(inputTensorInfo, std::vector<float>(inputValues));
-
-    LayerTestResult<float, 4> result(outputTensorInfo);
-    result.outputExpected = MakeTensor<float, 4>(outputTensorInfo, std::vector<float>(expectedOutputValues));
+    LayerTestResult<T, 4> result(outputTensorInfo);
+    result.outputExpected = MakeTensor<T, 4>(outputTensorInfo, std::vector<T>(expectedOutputValues));
 
     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
@@ -3841,7 +3820,37 @@
     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
 
     return result;
-};
+}
+
+LayerTestResult<uint8_t, 2> PadUint82dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad2dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+}
+
+LayerTestResult<uint8_t, 3> PadUint83dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad3dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+}
+
+LayerTestResult<uint8_t, 4> PadUint84dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad4dTestCommon<uint8_t>(workloadFactory, 1.0f, 0);
+}
+
+LayerTestResult<float, 2> PadFloat322dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad2dTestCommon<float>(workloadFactory, 0.0f, 0);
+}
+
+LayerTestResult<float, 3> PadFloat323dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad3dTestCommon<float>(workloadFactory, 0.0f, 0);
+}
+
+LayerTestResult<float, 4> PadFloat324dTest(armnn::IWorkloadFactory& workloadFactory)
+{
+  return Pad4dTestCommon<float>(workloadFactory, 0.0f, 0);
+}
 
 LayerTestResult<float, 4> L2Normalization1dTest(armnn::IWorkloadFactory& workloadFactory)
 {
diff --git a/src/backends/test/LayerTests.hpp b/src/backends/test/LayerTests.hpp
index 925e3e6..5790869 100644
--- a/src/backends/test/LayerTests.hpp
+++ b/src/backends/test/LayerTests.hpp
@@ -353,10 +353,13 @@
 LayerTestResult<float, 4> SimplePermuteFloat32Test(armnn::IWorkloadFactory& workloadFactory);
 LayerTestResult<uint8_t, 4> SimplePermuteUint8Test(armnn::IWorkloadFactory& workloadFactory);
 
-LayerTestResult<float, 2> Pad2dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 3> Pad3dTest(armnn::IWorkloadFactory& workloadFactory);
-LayerTestResult<float, 4> Pad4dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 2> PadUint82dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 3> PadUint83dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<uint8_t, 4> PadUint84dTest(armnn::IWorkloadFactory& workloadFactory);
 
+LayerTestResult<float, 2> PadFloat322dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 3> PadFloat323dTest(armnn::IWorkloadFactory& workloadFactory);
+LayerTestResult<float, 4> PadFloat324dTest(armnn::IWorkloadFactory& workloadFactory);
 
 LayerTestResult<float, 4> PermuteFloat32ValueSet1Test(armnn::IWorkloadFactory& workloadFactory);
 LayerTestResult<float, 4> PermuteFloat32ValueSet2Test(armnn::IWorkloadFactory& workloadFactory);