diff --git a/src/backends/backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp b/src/backends/backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp
index 3f530cc..9586417 100644
--- a/src/backends/backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp
+++ b/src/backends/backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2019 Arm Ltd. All rights reserved.
+// Copyright © 2020-2021, 2023 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once
@@ -47,8 +47,7 @@
 template<armnn::DataType ArmnnInType,
          typename TInput = armnn::ResolveType<ArmnnInType>>
 void ElementwiseUnarySimpleEndToEnd(const std::vector<BackendId>& backends,
-                                    UnaryOperation operation,
-                                    const std::vector<float> expectedOutput)
+                                    UnaryOperation operation)
 {
     using namespace armnn;
 
@@ -63,8 +62,30 @@
 
     CHECK(net);
 
-    const std::vector<float> input({ 1, -1, 1, 1,  5, -5, 5, 5,
-                                       -3, 3, 3, 3,  4, 4, -4, 4 });
+    std::vector<float> input;
+    std::vector<float> expectedOutput;
+    switch(operation)
+    {
+        case UnaryOperation::Abs:
+            input = { 1, -1, 1, 1,  5, -5, 5, 5,
+                      -3, 3, 3, 3,  4, 4, -4, 4 };
+            expectedOutput = { 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
+                               3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f };
+            break;
+        case UnaryOperation::Rsqrt:
+            input = { 1, 1, 1, 1,  5, 5, 5, 5,
+                      3, 3, 3, 3,  4, 4, 4, 4 };
+            expectedOutput = { 1.f, 1.f, 1.f, 1.f, 0.447214f, 0.447214f, 0.447214f, 0.447214f,
+                               0.57735f, 0.57735f, 0.57735f, 0.57735f, 0.5f, 0.5f, 0.5f, 0.5f };
+            break;
+        default:
+            input = { 1, -1, 1, 1,  5, -5, 5, 5,
+                      -3, 3, 3, 3,  4, 4, -4, 4 };
+            expectedOutput = { 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
+                               3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f };
+            break;
+    }
+
 
     // quantize data
     std::vector<TInput> qInputData      = armnnUtils::QuantizedVector<TInput>(input, qScale, qOffset);
diff --git a/src/backends/cl/test/ClEndToEndTests.cpp b/src/backends/cl/test/ClEndToEndTests.cpp
index d5ac8b1..4ff2b79 100644
--- a/src/backends/cl/test/ClEndToEndTests.cpp
+++ b/src/backends/cl/test/ClEndToEndTests.cpp
@@ -31,18 +31,18 @@
 {
 std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc};
 
+// ElementwiseUnary
 // Abs
 TEST_CASE("ClAbsEndToEndTestFloat32")
 {
-    std::vector<float> expectedOutput =
-    {
-        1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
-        3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
-    };
-
     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
-                                                             UnaryOperation::Abs,
-                                                             expectedOutput);
+                                                             UnaryOperation::Abs);
+}
+// Rsqrt
+TEST_CASE("ClRsqrtEndToEndTestFloat32")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
+                                                             UnaryOperation::Rsqrt);
 }
 
 // Addition
diff --git a/src/backends/neon/test/NeonEndToEndTests.cpp b/src/backends/neon/test/NeonEndToEndTests.cpp
index d74c501..b930004 100644
--- a/src/backends/neon/test/NeonEndToEndTests.cpp
+++ b/src/backends/neon/test/NeonEndToEndTests.cpp
@@ -33,18 +33,18 @@
 {
 std::vector<armnn::BackendId> neonDefaultBackends = {armnn::Compute::CpuAcc};
 
+// ElementwiseUnary
 // Abs
 TEST_CASE("NeonAbsEndToEndTestFloat32")
 {
-    std::vector<float> expectedOutput =
-    {
-        1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
-        3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
-    };
-
     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(neonDefaultBackends,
-                                                             UnaryOperation::Abs,
-                                                             expectedOutput);
+                                                             UnaryOperation::Abs);
+}
+// Rsqrt
+TEST_CASE("NeonRsqrtEndToEndTestFloat32")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(neonDefaultBackends,
+                                                             UnaryOperation::Rsqrt);
 }
 
 // Constant
diff --git a/src/backends/reference/test/RefEndToEndTests.cpp b/src/backends/reference/test/RefEndToEndTests.cpp
index 8fcb3d1..6ff5771 100644
--- a/src/backends/reference/test/RefEndToEndTests.cpp
+++ b/src/backends/reference/test/RefEndToEndTests.cpp
@@ -43,46 +43,43 @@
 {
 std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::CpuRef};
 
+// ElementwiseUnary
 // Abs
 TEST_CASE("RefAbsEndToEndTestFloat32")
 {
-    std::vector<float> expectedOutput =
-    {
-        1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
-        3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
-    };
-
     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
-                                                             UnaryOperation::Abs,
-                                                             expectedOutput);
+                                                             UnaryOperation::Abs);
 }
 
 TEST_CASE("RefAbsEndToEndTestUint8")
 {
-    // Note the expected output will be implicitly quantized by the below test function
-    std::vector<float> expectedOutput =
-    {
-        1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
-        3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
-    };
-
     ElementwiseUnarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
-                                                                     UnaryOperation::Abs,
-                                                                     expectedOutput);
+                                                              UnaryOperation::Abs);
 }
 
 TEST_CASE("RefAbsEndToEndTestInt16")
 {
-    // Note the expected output will be implicitly quantized by the below test function
-    std::vector<float> expectedOutput =
-    {
-        1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
-        3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
-    };
-
     ElementwiseUnarySimpleEndToEnd<armnn::DataType::QSymmS16>(defaultBackends,
-                                                                     UnaryOperation::Abs,
-                                                                     expectedOutput);
+                                                              UnaryOperation::Abs);
+}
+
+// Rsqrt
+TEST_CASE("RefRsqrtEndToEndTestFloat32")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
+                                                             UnaryOperation::Rsqrt);
+}
+
+TEST_CASE("RefRsqrtEndToEndTestUint8")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
+                                                              UnaryOperation::Rsqrt);
+}
+
+TEST_CASE("RefRsqrtEndToEndTestInt16")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::QSymmS16>(defaultBackends,
+                                                              UnaryOperation::Rsqrt);
 }
 
 // Addition
diff --git a/src/backends/tosaCommon/TosaMappings.cpp b/src/backends/tosaCommon/TosaMappings.cpp
index 0b5fa1a..3932b62 100644
--- a/src/backends/tosaCommon/TosaMappings.cpp
+++ b/src/backends/tosaCommon/TosaMappings.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -29,6 +29,11 @@
         {
             return ConvertElementwiseBinaryToTosaOperator(layer, type, inputs, outputs);
         }
+        case LayerType::ElementwiseUnary:
+        {
+            auto unaryDesc = PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor);
+            return ConvertElementwiseUnaryOperator(layer, inputs, outputs, unaryDesc);
+        }
         case LayerType::Concat:
         {
             auto concatDesc = PolymorphicDowncast<const OriginsDescriptor*>(&descriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
index 2ec052c..26f51b6 100644
--- a/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
+++ b/src/backends/tosaCommon/operatorMappings/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+# Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 # SPDX-License-Identifier: MIT
 #
 
@@ -14,6 +14,8 @@
         Conv2dOperator.cpp
         ElementwiseBinaryOperator.hpp
         ElementwiseBinaryOperator.cpp
+        ElementwiseUnaryOperator.cpp
+        ElementwiseUnaryOperator.hpp
         Pooling2DOperator.hpp
         Pooling2DOperator.cpp
         ReshapeOperator.hpp
diff --git a/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.cpp b/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.cpp
new file mode 100644
index 0000000..15fb9d7
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.cpp
@@ -0,0 +1,72 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ElementwiseUnaryOperator.hpp"
+
+TosaSerializationBasicBlock* ConvertElementwiseUnaryOperator(const Layer* layer,
+                                                             const std::vector<const TensorInfo*>& inputs,
+                                                             const std::vector<const TensorInfo*>& outputs,
+                                                             const ElementwiseUnaryDescriptor* unaryDescriptor)
+{
+    std::string input0Name = std::string("input0_");
+    std::string outputName = std::string("output0_");
+    std::string blockName  = std::string("Op_ELEMENTWISEUNARY_block_") + GetUniqueTosaMappingID();
+
+
+    // If a layer is present then the block will be used for execution, so input and output names need to be determined
+    // using the previous and following layers so the graph is connected correctly. For validation this doesn't matter.
+    if(layer != nullptr)
+    {
+        // Get the layer connected to the input slot and determine unique the tensor name.
+        Layer& connectedLayer0 = layer->GetInputSlot(0).GetConnectedOutputSlot()->GetOwningLayer();
+        input0Name = GenerateUniqueName(connectedLayer0, 0);
+
+        // Determine unique output tensor name.
+        outputName = GenerateUniqueOutputName(*layer, 0);
+    }
+
+    TosaSerializationOperator* op = nullptr;
+    switch(unaryDescriptor->m_Operation)
+    {
+        case UnaryOperation::Rsqrt:
+        {
+            op = new TosaSerializationOperator(tosa::Op_RSQRT,
+                                               Attribute_NONE,
+                                               nullptr,
+                                               {input0Name},
+                                               {outputName});
+            blockName = std::string("Op_RSQRT_block_") + GetUniqueTosaMappingID();
+            break;
+        }
+        default:
+            throw armnn::Exception("ConvertElementwiseUnaryToTosaOperator: Unsupported layer type.");
+    }
+
+    ARMNN_ASSERT(op != nullptr);
+
+    std::vector<TosaSerializationTensor*> tensors;
+    // Only add input tensor if connected layer is an input layer.
+    // As intermediate or constant tensors will be created separately.
+    // There also can't be duplicate tensor.
+    if(input0Name.find("input0_") != std::string::npos)
+    {
+        std::vector<int32_t> inputShape0 = GetTosaTensorShape(inputs[0]->GetShape());
+        DType inputDType0 = ArmNNToDType(inputs[0]->GetDataType());
+        tensors.push_back(new TosaSerializationTensor(input0Name, inputShape0, inputDType0, {}));
+    }
+
+    std::vector<int32_t> outputShape0 = GetTosaTensorShape(outputs[0]->GetShape());
+    DType outputDType0 = ArmNNToDType(outputs[0]->GetDataType());
+
+    tensors.push_back(new TosaSerializationTensor(outputName, outputShape0, outputDType0, {}));
+
+    // operatorInputNames/operatorOutputNames ends up being the same as
+    // blockInputNames/blockOutputNames for one-to-one ArmNN to Tosa mappings
+    return new TosaSerializationBasicBlock(blockName, // name
+                                           {op}, // operators
+                                           tensors, // tensors
+                                           {input0Name}, // inputs
+                                           {outputName}); // outputs
+}
\ No newline at end of file
diff --git a/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.hpp b/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.hpp
new file mode 100644
index 0000000..d13428c
--- /dev/null
+++ b/src/backends/tosaCommon/operatorMappings/ElementwiseUnaryOperator.hpp
@@ -0,0 +1,19 @@
+//
+// Copyright © 2023 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "TosaOperatorUtils.hpp"
+#include <Layer.hpp>
+
+#include <tosa_serialization_handler.h>
+
+using namespace armnn;
+using namespace tosa;
+
+TosaSerializationBasicBlock* ConvertElementwiseUnaryOperator(const Layer* layer,
+                                                             const std::vector<const TensorInfo*>& inputs,
+                                                             const std::vector<const TensorInfo*>& outputs,
+                                                             const ElementwiseUnaryDescriptor* unaryDescriptor);
diff --git a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
index 3f27371..66dc1b3 100644
--- a/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
+++ b/src/backends/tosaCommon/operatorMappings/TosaCommonOperators.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -10,6 +10,7 @@
 #include "ConstantOperator.hpp"
 #include "Conv2dOperator.hpp"
 #include "ElementwiseBinaryOperator.hpp"
+#include "ElementwiseUnaryOperator.hpp"
 #include "Pooling2DOperator.hpp"
 #include "ReshapeOperator.hpp"
 #include "SliceOperator.hpp"
diff --git a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
index 4cc3791..6e532ab 100644
--- a/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
+++ b/src/backends/tosaCommon/test/OneToOneMappingTests.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -252,6 +252,56 @@
     AssertTosaOneToOneMappingBasicBlock(
         basicBlock, inputShape, outputShape, Op_CONV2D, Attribute_ConvAttribute, descriptor, LayerType::Convolution2d);
 }
+TEST_CASE("GetTosaMapping_ElementwiseUnaryLayerRsqrt")
+{
+    TensorInfo inputInfo  = TensorInfo({ 2, 2 }, DataType::Float32, 0.0f, 0, true);
+    TensorInfo outputInfo = TensorInfo({ 2, 2 }, DataType::Float32, 0.0f, 0, true);
+    std::vector<std::vector<int32_t>> inputShape  = {{ 2, 2 }};
+    std::vector<std::vector<int32_t>> outputShape = {{ 2, 2 }};
+
+    ElementwiseUnaryDescriptor unaryDescriptor = ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt);
+    TosaSerializationBasicBlock* basicBlock =
+            GetTosaMapping(nullptr, LayerType::ElementwiseUnary, {&inputInfo,}, {&outputInfo}, unaryDescriptor);
+
+    AssertTosaOneToOneMappingBasicBlock(basicBlock,
+                                        inputShape,
+                                        outputShape,
+                                        tosa::Op_RSQRT,
+                                        tosa::Attribute_NONE,
+                                        unaryDescriptor,
+                                        LayerType::ElementwiseUnary);
+}
+TEST_CASE("GetTosaMappingFromLayer_ElementwiseUnaryLayerRsqrt")
+{
+    IRuntime::CreationOptions options;
+    IRuntimePtr runtime(IRuntime::Create(options));
+
+    // Builds up the structure of the network.
+    INetworkPtr net(INetwork::Create());
+    ElementwiseUnaryDescriptor unaryDescriptor = ElementwiseUnaryDescriptor(UnaryOperation::Rsqrt);
+    IConnectableLayer* input     = net->AddInputLayer(0, "input0");
+    IConnectableLayer* unaryRsqrt = net->AddElementwiseUnaryLayer(unaryDescriptor, "rsqrt");
+    IConnectableLayer* output    = net->AddOutputLayer(0, "output");
+
+    input->GetOutputSlot(0).Connect(unaryRsqrt->GetInputSlot(0));
+    unaryRsqrt->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+    TensorInfo inputInfo  = TensorInfo({ 2, 2 }, DataType::Float32, 0.0f, 0, true);
+    TensorInfo outputInfo = TensorInfo({ 2, 2 }, DataType::Float32, 0.0f, 0, true);
+    input->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    unaryRsqrt->GetOutputSlot(0).SetTensorInfo(outputInfo);
+    std::vector<std::vector<int32_t>> inputShape  = {{ 2, 2 }};
+    std::vector<std::vector<int32_t>> outputShape = {{ 2, 2 }};
+
+    TosaSerializationBasicBlock* basicBlock =
+            GetTosaMappingFromLayer(PolymorphicDowncast<Layer*>(unaryRsqrt));
+    AssertTosaOneToOneMappingBasicBlock(basicBlock,
+                                        inputShape,
+                                        outputShape,
+                                        tosa::Op_RSQRT,
+                                        tosa::Attribute_NONE,
+                                        unaryDescriptor,
+                                        LayerType::ElementwiseUnary);
+}
 
 TEST_CASE("GetTosaMapping_MultiplicationLayer")
 {
diff --git a/src/backends/tosaReference/TosaRefLayerSupport.cpp b/src/backends/tosaReference/TosaRefLayerSupport.cpp
index 6113b58..238801c 100644
--- a/src/backends/tosaReference/TosaRefLayerSupport.cpp
+++ b/src/backends/tosaReference/TosaRefLayerSupport.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -68,6 +68,7 @@
             }
             break;
         }
+        case LayerType::ElementwiseUnary:
         case LayerType::Pooling2d:
         case LayerType::Reshape:
         case LayerType::Slice:
@@ -89,7 +90,8 @@
             break;
         }
         default:
-            break;
+            // Default to false for all unsupported layers.
+            return false;
     }
 
     auto mappings = GetTosaMapping(nullptr, type, inputInfos, outputInfos, descriptor);
diff --git a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
index e19462e..26cadd2 100644
--- a/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefEndToEndTests.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -11,6 +11,7 @@
 #include "backendsCommon/test/MultiplicationEndToEndTestImpl.hpp"
 #include "backendsCommon/test/Pooling2dEndToEndTestImpl.hpp"
 #include "backendsCommon/test/ReshapeEndToEndTestImpl.hpp"
+#include "backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp"
 #include "backendsCommon/test/SliceEndToEndTestImpl.hpp"
 #include "backendsCommon/test/SubtractionEndToEndTestImpl.hpp"
 #include "backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp"
@@ -138,6 +139,12 @@
     ReshapeEndToEndFloat16<DataType::Float16>(tosaDefaultBackends);
 }
 
+TEST_CASE("TosaRefRsqrtEndtoEndTestFloat32")
+{
+    ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(tosaDefaultBackends,
+                                                             UnaryOperation::Rsqrt);
+}
+
 // Slice
 TEST_CASE("TosaRefSliceEndtoEndTestFloat32")
 {
diff --git a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
index 66dfbe8..e32894f 100644
--- a/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
+++ b/src/backends/tosaReference/test/TosaRefLayerSupportTests.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -374,6 +374,46 @@
     CHECK(!supported);
 }
 
+TEST_CASE("IsLayerSupportedTosaReferenceRsqrt")
+{
+    TensorShape shape0 = {2,2};
+    TensorShape outShape = {2,2};
+    TensorInfo in0(shape0, DataType::Float32);
+    TensorInfo out(outShape, DataType::Float32);
+
+    ElementwiseUnaryDescriptor desc(UnaryOperation::Rsqrt);
+    TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(LayerType::ElementwiseUnary,
+                                                     {in0, out},
+                                                     desc,
+                                                     EmptyOptional(),
+                                                     EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(supported);
+}
+
+TEST_CASE("IsLayerSupportedTosaReferenceRsqrtUnsupported")
+{
+    TensorShape shape0 = {1,1,3,4};
+    TensorShape outShape = {1,3,1,4};
+    TensorInfo in0(shape0, DataType::Signed64);
+    TensorInfo out(outShape, DataType::Signed64);
+
+    ElementwiseUnaryDescriptor desc(UnaryOperation::Rsqrt);
+    TosaRefLayerSupport supportChecker;
+    std::string reasonIfNotSupported;
+    auto supported = supportChecker.IsLayerSupported(LayerType::ElementwiseUnary,
+                                                     {in0, out},
+                                                     desc,
+                                                     EmptyOptional(),
+                                                     EmptyOptional(),
+                                                     reasonIfNotSupported);
+
+    CHECK(!supported);
+}
+
 TEST_CASE("IsLayerSupportedTosaReferenceSlice")
 {
     TensorShape inShape = {3,2,3};