IVGCVSW-5374 Provide Android Build for Delegate

 * Fix Arm Android Compiler errors

Signed-off-by: Keith Davis <keith.davis@arm.com>
Change-Id: If5fae0fda08b6102eb46217564a096f87a3b6740

17 files changed, 65 insertions, 62 deletions

diff --git a/delegate/src/Activation.hpp b/delegate/src/Activation.hpp
index 5e8d876110..b50854aca5 100644
--- a/delegate/src/Activation.hpp
+++ b/delegate/src/Activation.hpp
@@ -22,7 +22,7 @@ TfLiteStatus ValidateActivationOperator(DelegateData& delegateData,
                                         armnn::ActivationDescriptor& activationDesc)
 {
     bool isSupported = false;
-    auto validateFunc = [&](const armnn::TensorInfo& outInfo, bool& isSupported)
+    auto validateFunc = [&](const armnn::TensorInfo& outputInfo, bool& isSupported)
     {
         FORWARD_LAYER_SUPPORT_FUNC(__func__,
                                    tfLiteContext,
diff --git a/delegate/src/Convolution.hpp b/delegate/src/Convolution.hpp
index 2d9fdba122..153f44953c 100644
--- a/delegate/src/Convolution.hpp
+++ b/delegate/src/Convolution.hpp
@@ -568,16 +568,18 @@ TfLiteStatus VisitTransposeConv2dOperator(DelegateData& delegateData,
     outputSlot.SetTensorInfo(outputTensorInfo);
 
     // Connect
-    if (delegateData.m_OutputSlotForNode[tfLiteNode->inputs->data[2]] != nullptr)
+    if (delegateData.m_OutputSlotForNode[static_cast<unsigned int>(tfLiteNode->inputs->data[2])] != nullptr)
     {
-        delegateData.m_OutputSlotForNode[tfLiteNode->inputs->data[2]]->Connect(layer->GetInputSlot(0));
+        delegateData.m_OutputSlotForNode[static_cast<unsigned int>(tfLiteNode->inputs->data[2])]->
+                                                                   Connect(layer->GetInputSlot(0));
     }
 
     // Prepare output slots
     for (unsigned int outputIndex = 0; outputIndex < layer->GetNumOutputSlots(); ++outputIndex)
     {
         armnn::IOutputSlot& outputSlot = layer->GetOutputSlot(outputIndex);
-        delegateData.m_OutputSlotForNode[tfLiteNode->outputs->data[outputIndex]] = &outputSlot;
+        delegateData.m_OutputSlotForNode[static_cast<unsigned int>(tfLiteNode->outputs->data[outputIndex])] =
+                                                                   &outputSlot;
     }
     return kTfLiteOk;
 }
diff --git a/delegate/src/DelegateUtils.hpp b/delegate/src/DelegateUtils.hpp
index 9f39a30727..990f210734 100644
--- a/delegate/src/DelegateUtils.hpp
+++ b/delegate/src/DelegateUtils.hpp
@@ -140,7 +140,8 @@ uint32_t NonNegative(int32_t value, int nodeIndex)
 {
     if (value < 0)
     {
-        throw armnn::Exception("TfLiteArmnnDelegate: Non-negative value in node " + nodeIndex);
+        throw armnn::Exception(
+            "TfLiteArmnnDelegate: Non-negative value in node " + std::to_string(static_cast<int>(nodeIndex)));
     }
     else
     {
@@ -162,7 +163,7 @@ TfLiteStatus Connect(armnn::IConnectableLayer* layer,
                      TfLiteNode* tfLiteNode,
                      armnnDelegate::DelegateData& data)
 {
-    ARMNN_ASSERT(static_cast<unsigned int >(tfLiteNode->outputs->size) == layer->GetNumOutputSlots());
+    ARMNN_ASSERT(static_cast<unsigned int>(tfLiteNode->outputs->size) == layer->GetNumOutputSlots());
 
     // Connect the input slots
     for (unsigned int inputIndex = 0; inputIndex < layer->GetNumInputSlots(); ++inputIndex)
@@ -475,7 +476,8 @@ armnn::ConstTensor CreateConstTensor(const TfLiteTensor* tfLiteTensor,
 {
     if (tfLiteTensor->allocation_type != kTfLiteMmapRo)
     {
-        throw armnn::Exception("TfLiteArmnnDelegate: Not constant allocation type: " + tfLiteTensor->allocation_type);
+        throw armnn::Exception(
+            "TfLiteArmnnDelegate:  Not constant allocation type: " + std::to_string(tfLiteTensor->allocation_type));
     }
 
     if (permutationVector.has_value() && permutationVector.value().GetSize() > 0 && permutationData != nullptr)
@@ -524,6 +526,7 @@ TfLiteStatus ConnectConstant(armnn::IConnectableLayer* layer,
                              armnnDelegate::DelegateData& data,
                              unsigned int slotIndex)
 {
+    IgnoreUnused(layer);
     bool isSupported = false;
     FORWARD_LAYER_SUPPORT_FUNC(__func__,
                                tfLiteContext,
diff --git a/delegate/src/Resize.hpp b/delegate/src/Resize.hpp
index 626112aa37..937cc00c8f 100644
--- a/delegate/src/Resize.hpp
+++ b/delegate/src/Resize.hpp
@@ -86,7 +86,6 @@ TfLiteStatus VisitResizeOperator(DelegateData& delegateData,
     }
 
     const armnn::TensorInfo& inputTensorInfo = GetTensorInfoForTfLiteTensor(tfLiteInputTensor);
-    const armnn::TensorInfo& sizeTensorInfo = GetTensorInfoForTfLiteTensor(tfLiteSizeTensor);
     const armnn::TensorInfo& outputTensorInfo = GetTensorInfoForTfLiteTensor(tfLiteOutputTensor);
 
     std::string layerName("Resize");
@@ -99,7 +98,7 @@ TfLiteStatus VisitResizeOperator(DelegateData& delegateData,
         {
             desc.m_Method = armnn::ResizeMethod::Bilinear;
 
-            layerName += "Bilinear:" + nodeIndex;
+            layerName += "Bilinear:" + std::to_string(nodeIndex);
 
             TfLiteResizeBilinearParams* biliniarOptions =
                     reinterpret_cast<TfLiteResizeBilinearParams*>(tfLiteNode->builtin_data);
@@ -111,7 +110,7 @@ TfLiteStatus VisitResizeOperator(DelegateData& delegateData,
         case kTfLiteBuiltinResizeNearestNeighbor:
         {
             desc.m_Method =  armnn::ResizeMethod::NearestNeighbor;
-            layerName += "NearestNeighbor:" + nodeIndex;
+            layerName += "NearestNeighbor:" + std::to_string(nodeIndex);
 
             TfLiteResizeNearestNeighborParams* nearestNeighborOptions =
                     reinterpret_cast<TfLiteResizeNearestNeighborParams*>(tfLiteNode->builtin_data);
diff --git a/delegate/src/Transpose.hpp b/delegate/src/Transpose.hpp
index f3c348a1c2..580e0624e3 100644
--- a/delegate/src/Transpose.hpp
+++ b/delegate/src/Transpose.hpp
@@ -58,7 +58,6 @@ TfLiteStatus VisitTransposeOperator(DelegateData& delegateData,
     }
 
     const armnn::TensorInfo& inputTensorInfo0 = GetTensorInfoForTfLiteTensor(tfLiteInputTensor0);
-    const armnn::TensorInfo& inputTensorInfo1 = GetTensorInfoForTfLiteTensor(tfLiteInputTensor1); //permutation tensor
     const armnn::TensorInfo& outputTensorInfo = GetTensorInfoForTfLiteTensor(tfLiteOutputTensor);
 
     auto* permTensorDataPtr = tflite::GetTensorData<int32_t>(&tfLiteInputTensor1);
diff --git a/delegate/src/test/ActivationTestHelper.hpp b/delegate/src/test/ActivationTestHelper.hpp
index 04da3ccc49..2368a36931 100644
--- a/delegate/src/test/ActivationTestHelper.hpp
+++ b/delegate/src/test/ActivationTestHelper.hpp
@@ -38,16 +38,16 @@ std::vector<char> CreateActivationTfLiteModel(tflite::BuiltinOperator activation
                               tensorType);
 
     // create operator
-    const std::vector<int> operatorInputs{{0}};
-    const std::vector<int> operatorOutputs{{1}};
+    const std::vector<int> operatorInputs{0};
+    const std::vector<int> operatorOutputs{1};
     flatbuffers::Offset <Operator> unaryOperator =
         CreateOperator(flatBufferBuilder,
                        0,
                        flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
                        flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()));
 
-    const std::vector<int> subgraphInputs{{0}};
-    const std::vector<int> subgraphOutputs{{1}};
+    const std::vector<int> subgraphInputs{0};
+    const std::vector<int> subgraphOutputs{1};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/ArmnnDelegateTest.cpp b/delegate/src/test/ArmnnDelegateTest.cpp
index 050fe45ca0..84bc31172d 100644
--- a/delegate/src/test/ArmnnDelegateTest.cpp
+++ b/delegate/src/test/ArmnnDelegateTest.cpp
@@ -7,10 +7,10 @@
 #include <doctest/doctest.h>
 
 #include <armnn_delegate.hpp>
-#include "ElementwiseUnaryTestHelper.hpp"
 
 #include "tensorflow/lite/kernels/builtin_op_kernels.h"
 #include <tensorflow/lite/interpreter.h>
+#include <tensorflow/lite/kernels/register.h>
 
 namespace armnnDelegate
 {
diff --git a/delegate/src/test/ComparisonTestHelper.hpp b/delegate/src/test/ComparisonTestHelper.hpp
index 21fc3a83a4..c9ccb778ac 100644
--- a/delegate/src/test/ComparisonTestHelper.hpp
+++ b/delegate/src/test/ComparisonTestHelper.hpp
@@ -107,8 +107,8 @@ std::vector<char> CreateComparisonTfLiteModel(tflite::BuiltinOperator comparison
         default:
             break;
     }
-    const std::vector<int32_t> operatorInputs{ {0, 1} };
-    const std::vector<int32_t> operatorOutputs{{2}};
+    const std::vector<int32_t> operatorInputs{0, 1};
+    const std::vector<int32_t> operatorOutputs{2};
     flatbuffers::Offset <Operator> comparisonOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -117,8 +117,8 @@ std::vector<char> CreateComparisonTfLiteModel(tflite::BuiltinOperator comparison
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0, 1} };
-    const std::vector<int> subgraphOutputs{{2}};
+    const std::vector<int> subgraphInputs{0, 1};
+    const std::vector<int> subgraphOutputs{2};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/ConvolutionTestHelper.hpp b/delegate/src/test/ConvolutionTestHelper.hpp
index b3175174d2..b2a3c889e6 100644
--- a/delegate/src/test/ConvolutionTestHelper.hpp
+++ b/delegate/src/test/ConvolutionTestHelper.hpp
@@ -137,8 +137,8 @@ std::vector<char> CreateConv2dTfLiteModel(tflite::BuiltinOperator convolutionOpe
     }
 
     // create operator
-    const std::vector<int> operatorInputs{{0, 1, 2}};
-    const std::vector<int> operatorOutputs{{3}};
+    const std::vector<int> operatorInputs{0, 1, 2};
+    const std::vector<int> operatorOutputs{3};
     flatbuffers::Offset <Operator> convolutionOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -147,8 +147,8 @@ std::vector<char> CreateConv2dTfLiteModel(tflite::BuiltinOperator convolutionOpe
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0, 1, 2} };
-    const std::vector<int> subgraphOutputs{{3}};
+    const std::vector<int> subgraphInputs{0, 1, 2};
+    const std::vector<int> subgraphOutputs{3};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
@@ -363,8 +363,8 @@ std::vector<char> CreateTransposeConvTfLiteModel(tflite::TensorType tensorType,
         CreateTransposeConvOptions(flatBufferBuilder, padding, strideX, strideY).Union();
 
     // create operator
-    const std::vector<int> operatorInputs{{0, 1, 2}};
-    const std::vector<int> operatorOutputs{{3}};
+    const std::vector<int> operatorInputs{0, 1, 2};
+    const std::vector<int> operatorOutputs{3};
     flatbuffers::Offset <Operator> convolutionOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -373,8 +373,8 @@ std::vector<char> CreateTransposeConvTfLiteModel(tflite::TensorType tensorType,
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0, 1, 2} };
-    const std::vector<int> subgraphOutputs{{3}};
+    const std::vector<int> subgraphInputs{0, 1, 2};
+    const std::vector<int> subgraphOutputs{3};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/ElementwiseBinaryTestHelper.hpp b/delegate/src/test/ElementwiseBinaryTestHelper.hpp
index 60092726a2..0c096d85c3 100644
--- a/delegate/src/test/ElementwiseBinaryTestHelper.hpp
+++ b/delegate/src/test/ElementwiseBinaryTestHelper.hpp
@@ -109,8 +109,8 @@ std::vector<char> CreateElementwiseBinaryTfLiteModel(tflite::BuiltinOperator bin
         default:
             break;
     }
-    const std::vector<int32_t> operatorInputs{ {0, 1} };
-    const std::vector<int32_t> operatorOutputs{{2}};
+    const std::vector<int32_t> operatorInputs{0, 1};
+    const std::vector<int32_t> operatorOutputs{2};
     flatbuffers::Offset <Operator> elementwiseBinaryOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -119,8 +119,8 @@ std::vector<char> CreateElementwiseBinaryTfLiteModel(tflite::BuiltinOperator bin
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0, 1} };
-    const std::vector<int> subgraphOutputs{{2}};
+    const std::vector<int> subgraphInputs{0, 1};
+    const std::vector<int> subgraphOutputs{2};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/ElementwiseUnaryTestHelper.hpp b/delegate/src/test/ElementwiseUnaryTestHelper.hpp
index 348c8abcef..2683339eb5 100644
--- a/delegate/src/test/ElementwiseUnaryTestHelper.hpp
+++ b/delegate/src/test/ElementwiseUnaryTestHelper.hpp
@@ -40,16 +40,16 @@ std::vector<char> CreateElementwiseUnaryTfLiteModel(tflite::BuiltinOperator unar
                               tensorType);
 
     // create operator
-    const std::vector<int> operatorInputs{{0}};
-    const std::vector<int> operatorOutputs{{1}};
+    const std::vector<int> operatorInputs{0};
+    const std::vector<int> operatorOutputs{1};
     flatbuffers::Offset <Operator> unaryOperator =
         CreateOperator(flatBufferBuilder,
                        0,
                        flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
                        flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()));
 
-    const std::vector<int> subgraphInputs{{0}};
-    const std::vector<int> subgraphOutputs{{1}};
+    const std::vector<int> subgraphInputs{0};
+    const std::vector<int> subgraphOutputs{1};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/FullyConnectedTestHelper.hpp b/delegate/src/test/FullyConnectedTestHelper.hpp
index 4b30424d86..1b6ca941b8 100644
--- a/delegate/src/test/FullyConnectedTestHelper.hpp
+++ b/delegate/src/test/FullyConnectedTestHelper.hpp
@@ -111,8 +111,8 @@ std::vector<char> CreateFullyConnectedTfLiteModel(tflite::TensorType tensorType,
                                     activationType,
                                     FullyConnectedOptionsWeightsFormat_DEFAULT, false).Union();
 
-    const std::vector<int> operatorInputs{ {0, 1, 2} };
-    const std::vector<int> operatorOutputs{ {3} };
+    const std::vector<int> operatorInputs{0, 1, 2};
+    const std::vector<int> operatorOutputs{3};
     flatbuffers::Offset <Operator> fullyConnectedOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -120,8 +120,8 @@ std::vector<char> CreateFullyConnectedTfLiteModel(tflite::TensorType tensorType,
                        flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
                        operatorBuiltinOptionsType, operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0, 1, 2} };
-    const std::vector<int> subgraphOutputs{ {3} };
+    const std::vector<int> subgraphInputs{0, 1, 2};
+    const std::vector<int> subgraphOutputs{3};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/Pooling2dTestHelper.hpp b/delegate/src/test/Pooling2dTestHelper.hpp
index c2c7be7955..b5d36b0231 100644
--- a/delegate/src/test/Pooling2dTestHelper.hpp
+++ b/delegate/src/test/Pooling2dTestHelper.hpp
@@ -75,8 +75,8 @@ std::vector<char> CreatePooling2dTfLiteModel(
                                                                            filterHeight,
                                                                            fusedActivation).Union();
 
-    const std::vector<int32_t> operatorInputs{{0}};
-    const std::vector<int32_t> operatorOutputs{{1}};
+    const std::vector<int32_t> operatorInputs{0};
+    const std::vector<int32_t> operatorOutputs{1};
     flatbuffers::Offset <Operator> poolingOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -85,8 +85,8 @@ std::vector<char> CreatePooling2dTfLiteModel(
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{{0}};
-    const std::vector<int> subgraphOutputs{{1}};
+    const std::vector<int> subgraphInputs{0};
+    const std::vector<int> subgraphOutputs{1};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/QuantizationTestHelper.hpp b/delegate/src/test/QuantizationTestHelper.hpp
index 2843e43233..e4155040cd 100644
--- a/delegate/src/test/QuantizationTestHelper.hpp
+++ b/delegate/src/test/QuantizationTestHelper.hpp
@@ -78,8 +78,8 @@ std::vector<char> CreateQuantizationTfLiteModel(tflite::BuiltinOperator quantiza
             break;
     }
 
-    const std::vector<int32_t> operatorInputs{ {0} };
-    const std::vector<int32_t> operatorOutputs{{1}};
+    const std::vector<int32_t> operatorInputs{0};
+    const std::vector<int32_t> operatorOutputs{1};
     flatbuffers::Offset <Operator> quantizationOperator =
             CreateOperator(flatBufferBuilder,
                            0,
@@ -88,8 +88,8 @@ std::vector<char> CreateQuantizationTfLiteModel(tflite::BuiltinOperator quantiza
                            operatorBuiltinOptionsType,
                            operatorBuiltinOptions);
 
-    const std::vector<int> subgraphInputs{ {0} };
-    const std::vector<int> subgraphOutputs{{1}};
+    const std::vector<int> subgraphInputs{0};
+    const std::vector<int> subgraphOutputs{1};
     flatbuffers::Offset <SubGraph> subgraph =
             CreateSubGraph(flatBufferBuilder,
                            flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/RedefineTestHelper.hpp b/delegate/src/test/RedefineTestHelper.hpp
index 42fc4c878c..ca8246c3a6 100644
--- a/delegate/src/test/RedefineTestHelper.hpp
+++ b/delegate/src/test/RedefineTestHelper.hpp
@@ -68,8 +68,8 @@ std::vector<char> CreateRedefineTfLiteModel(
     if (useOption)
     {
         tensors = { inputTensor, outputTensor};
-        operatorInputs = {{0}};
-        subgraphInputs = {{0}};
+        operatorInputs = {0};
+        subgraphInputs = {0};
         operatorBuiltinOptions = CreateReshapeOptions(
             flatBufferBuilder,
             flatBufferBuilder.CreateVector(targetShape.data(), targetShape.size())).Union();
@@ -87,15 +87,15 @@ std::vector<char> CreateRedefineTfLiteModel(
                                         2,
                                         flatBufferBuilder.CreateString("shape"));
         tensors = { inputTensor, outputTensor, shapeTensor };
-        operatorInputs = {{ 0, 2 }};
-        subgraphInputs = {{ 0, 2 }};
+        operatorInputs = {0, 2};
+        subgraphInputs = {0, 2};
         operatorBuiltinOptions = CreateReshapeOptions(flatBufferBuilder).Union();
     }
 
     // create operator
     tflite::BuiltinOptions operatorBuiltinOptionsType = BuiltinOptions_ReshapeOptions;
 
-    const std::vector<int32_t> operatorOutputs{{1}};
+    const std::vector<int32_t> operatorOutputs{1};
     flatbuffers::Offset <Operator> redefineOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -104,7 +104,7 @@ std::vector<char> CreateRedefineTfLiteModel(
                        operatorBuiltinOptionsType,
                        operatorBuiltinOptions);
 
-    const std::vector<int> subgraphOutputs{{1}};
+    const std::vector<int> subgraphOutputs{1};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/ResizeTestHelper.hpp b/delegate/src/test/ResizeTestHelper.hpp
index 1e9d3bcb3b..030b2a7a4a 100644
--- a/delegate/src/test/ResizeTestHelper.hpp
+++ b/delegate/src/test/ResizeTestHelper.hpp
@@ -80,8 +80,8 @@ std::vector<char> CreateResizeTfLiteModel(tflite::BuiltinOperator operatorCode,
             break;
     }
 
-    const std::vector<int> operatorInputs{{0, 1}};
-    const std::vector<int> operatorOutputs{{2}};
+    const std::vector<int> operatorInputs{0, 1};
+    const std::vector<int> operatorOutputs{2};
     flatbuffers::Offset <Operator> resizeOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -90,8 +90,8 @@ std::vector<char> CreateResizeTfLiteModel(tflite::BuiltinOperator operatorCode,
                        operatorBuiltinOptionsType,
                        operatorBuiltinOption);
 
-    const std::vector<int> subgraphInputs{{0, 1}};
-    const std::vector<int> subgraphOutputs{{2}};
+    const std::vector<int> subgraphInputs{0, 1};
+    const std::vector<int> subgraphOutputs{2};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
diff --git a/delegate/src/test/TransposeTestHelper.hpp b/delegate/src/test/TransposeTestHelper.hpp
index d63a854fbf..1d55273b9f 100644
--- a/delegate/src/test/TransposeTestHelper.hpp
+++ b/delegate/src/test/TransposeTestHelper.hpp
@@ -45,8 +45,8 @@ std::vector<char> CreateTransposeTfLiteModel(tflite::TensorType tensorType,
                               flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
                                                                       outputTensorShape.size()),
                               tensorType);
-    const std::vector<int32_t> operatorInputs{ {0, 1} };
-    const std::vector<int32_t> operatorOutputs{{2}};
+    const std::vector<int32_t> operatorInputs{0, 1};
+    const std::vector<int32_t> operatorOutputs{2};
     flatbuffers::Offset <Operator> transposeOperator =
         CreateOperator(flatBufferBuilder,
                        0,
@@ -54,8 +54,8 @@ std::vector<char> CreateTransposeTfLiteModel(tflite::TensorType tensorType,
                        flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
                        BuiltinOptions_TransposeOptions,
                        CreateTransposeOptions(flatBufferBuilder).Union());
-    const std::vector<int> subgraphInputs{ {0, 1} };
-    const std::vector<int> subgraphOutputs{{2}};
+    const std::vector<int> subgraphInputs{0, 1};
+    const std::vector<int> subgraphOutputs{2};
     flatbuffers::Offset <SubGraph> subgraph =
         CreateSubGraph(flatBufferBuilder,
                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),