29     const std::string layerName("addition");  variable
36     armnn::IConnectableLayer* const additionLayer = network->AddAdditionLayer(layerName.c_str());
52     LayerVerifierBase verifier(layerName, {tensorInfo, tensorInfo}, {tensorInfo});
58     const std::string layerName("argminmax");  in SerializeArgMinMaxTest()  local
68 …ConnectableLayer* const argMinMaxLayer = network->AddArgMinMaxLayer(descriptor, layerName.c_str());  in SerializeArgMinMaxTest()
80     LayerVerifierBaseWithDescriptor<armnn::ArgMinMaxDescriptor> verifier(layerName,  in SerializeArgMinMaxTest()
99     const std::string layerName("batchMatMul");  variable
117         network->AddBatchMatMulLayer(descriptor, layerName.c_str());
131     LayerVerifierBaseWithDescriptor<armnn::BatchMatMulDescriptor> verifier(layerName,
140     const std::string layerName("batchNormalization");  variable
172                                             layerName.c_str());
185         layerName, {inputInfo}, {outputInfo}, descriptor, constants);
191     const std::string layerName("spaceToBatchNd");  variable
202 …ectableLayer* const batchToSpaceNdLayer = network->AddBatchToSpaceNdLayer(desc, layerName.c_str());
214     LayerVerifierBaseWithDescriptor<armnn::BatchToSpaceNdDescriptor> verifier(layerName,
223         const std::string layerName("cast");  variable
232         armnn::IConnectableLayer* castLayer       = network->AddCastLayer(layerName.c_str());
244         LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
250     const std::string layerName("channelShuffle");  variable
259             network->AddChannelShuffleLayer(descriptor, layerName.c_str());
272             layerName, {inputInfo}, {outputInfo}, descriptor);
278     const std::string layerName("comparison");  variable
290 …nnectableLayer* const comparisonLayer = network->AddComparisonLayer(descriptor, layerName.c_str());
304     LayerVerifierBaseWithDescriptor<armnn::ComparisonDescriptor> verifier(layerName,
316         ConstantLayerVerifier(const std::string& layerName,  in ConstantLayerVerifier()  argument
320             : LayerVerifierBase(layerName, inputInfos, outputInfos)  in ConstantLayerVerifier()
353     const std::string layerName("constant");  variable
361     armnn::IConnectableLayer* constant = network->AddConstantLayer(constTensor, layerName.c_str());
378     ConstantLayerVerifier verifier(layerName, {}, {info}, {constTensor});
386     Convolution2dLayerVerifier(const std::string& layerName,  in Convolution2dLayerVerifier()  argument
390 …: LayerVerifierBaseWithDescriptor<Convolution2dDescriptor>(layerName, inputInfos, outputInfos, des…  in Convolution2dLayerVerifier()
417     const std::string layerName("convolution2d");  variable
446 …IConnectableLayer* const convLayer = network->AddConvolution2dLayer(descriptor, layerName.c_str());
462 …Convolution2dLayerVerifier verifier(layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo},…
470     const std::string layerName("convolution2dWithPerAxis");  variable
501 …IConnectableLayer* const convLayer = network->AddConvolution2dLayer(descriptor, layerName.c_str());
517 …Convolution2dLayerVerifier verifier(layerName, {inputInfo, kernelInfo, biasInfo}, {outputInfo}, de…
524     const std::string layerName("convolution2d");  variable
554                                            layerName.c_str());
572             layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}, descriptor, constants);
579     const std::string layerName("convolution3d");  variable
612 …onnectableLayer* const convLayer   = network->AddConvolution3dLayer(descriptor, layerName.c_str());
629             layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}, descriptor);
635     const std::string layerName("depthToSpace");  variable
646 …ConnectableLayer* const depthToSpaceLayer = network->AddDepthToSpaceLayer(desc, layerName.c_str());
658 …LayerVerifierBaseWithDescriptor<armnn::DepthToSpaceDescriptor> verifier(layerName, {inputInfo}, {o…
664     const std::string layerName("depwiseConvolution2d");  variable
692 …                                                                                layerName.c_str());
714         layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}, descriptor, constants);
722     const std::string layerName("depwiseConvolution2dWithPerAxis");  variable
754 …                                                                                layerName.c_str());
776             layerName, {inputInfo, kernelInfo, biasInfo}, {outputInfo}, descriptor, constants);
782     const std::string layerName("depthwiseConvolution2d");  variable
812 …                                                                                layerName.c_str());
830         layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}, descriptor, constants);
837     const std::string layerName("dequantize");  variable
843 …  armnn::IConnectableLayer* const dequantizeLayer = network->AddDequantizeLayer(layerName.c_str());
855     LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
861     const std::string layerName("detectionPostProcess");  variable
901         network->AddDetectionPostProcessLayer(descriptor, anchors, layerName.c_str());
922             layerName, inputInfos, outputInfos, descriptor, constants);
928     const std::string layerName("division");  variable
935     armnn::IConnectableLayer* const divisionLayer = network->AddDivisionLayer(layerName.c_str());
950     LayerVerifierBase verifier(layerName, {info, info}, {info});
956     const std::string layerName("EqualLayer");  variable
965 …nnectableLayer* const equalLayer = network->AddComparisonLayer(equalDescriptor, layerName.c_str());
978     LayerVerifierBase verifier(layerName, {inputTensorInfo1, inputTensorInfo2}, {outputTensorInfo});
984     auto layerName = GetBinaryOperationAsCString(binaryOperation);  in SerializeElementwiseBinaryTest()  local
992 …                                                                                        layerName);  in SerializeElementwiseBinaryTest()
1008             verifier(layerName, { tensorInfo, tensorInfo }, { tensorInfo }, descriptor);  in SerializeElementwiseBinaryTest()
1025     auto layerName = GetUnaryOperationAsCString(unaryOperation);  in SerializeElementwiseUnaryTest()  local
1037                                 network->AddElementwiseUnaryLayer(descriptor, layerName);  in SerializeElementwiseUnaryTest()
1051         verifier(layerName, { inputInfo }, { outputInfo }, descriptor);  in SerializeElementwiseUnaryTest()
1070     const std::string layerName("fill");  variable
1078 …  armnn::IConnectableLayer* const fillLayer = network->AddFillLayer(descriptor, layerName.c_str());
1090 …LayerVerifierBaseWithDescriptor<armnn::FillDescriptor> verifier(layerName, {inputInfo}, {outputInf…
1097     const std::string layerName("floor");  variable
1102     armnn::IConnectableLayer* const floorLayer = network->AddFloorLayer(layerName.c_str());
1114     LayerVerifierBase verifier(layerName, {info}, {info});
1122     FullyConnectedLayerVerifier(const std::string& layerName,  in FullyConnectedLayerVerifier()  argument
1126 …: LayerVerifierBaseWithDescriptor<FullyConnectedDescriptor>(layerName, inputInfos, outputInfos, de…  in FullyConnectedLayerVerifier()
1155     const std::string layerName("fullyConnected");  variable
1177                                             layerName.c_str());
1193 …FullyConnectedLayerVerifier verifier(layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}…
1199     const std::string layerName("fullyConnected_weights_as_inputs");  variable
1220                                         layerName.c_str());
1238         layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}, descriptor, constants);
1244     const std::string layerName("fullyConnected_weights_as_inputs");  variable
1265 …leLayer* const fullyConnectedLayer = network->AddFullyConnectedLayer(descriptor,layerName.c_str());
1281 …FullyConnectedLayerVerifier verifier(layerName, {inputInfo, weightsInfo, biasesInfo}, {outputInfo}…
1291         GatherLayerVerifier(const std::string& layerName,  in GatherLayerVerifier()  argument
1295 …: LayerVerifierBaseWithDescriptor<GatherDescriptor>(layerName, inputInfos, outputInfos, descriptor…  in GatherLayerVerifier()
1319     const std::string layerName("gather");  variable
1337 …armnn::IConnectableLayer *const gatherLayer = network->AddGatherLayer(descriptor, layerName.c_str(…
1351     GatherLayerVerifier verifier(layerName, {paramsInfo, indicesInfo}, {outputInfo}, descriptor);
1360         GatherNdLayerVerifier(const std::string& layerName,  in GatherNdLayerVerifier()  argument
1363                 : LayerVerifierBase(layerName, inputInfos, outputInfos) {}  in GatherNdLayerVerifier()
1386     const std::string layerName("gatherNd");  variable
1402     armnn::IConnectableLayer *const gatherNdLayer = network->AddGatherNdLayer(layerName.c_str());
1416     GatherNdLayerVerifier verifier(layerName, {paramsInfo, indicesInfo}, {outputInfo});
1422     const std::string layerName("greater");  variable
1433 …ectableLayer* const equalLayer = network->AddComparisonLayer(greaterDescriptor, layerName.c_str());
1447     LayerVerifierBase verifier(layerName, { inputInfo, inputInfo }, { outputInfo });
1454     const std::string layerName("instanceNormalization");  variable
1466         network->AddInstanceNormalizationLayer(descriptor, layerName.c_str());
1479             layerName, {info}, {info}, descriptor);
1555     const std::string layerName("l2Normalization");  variable
1564             layerName, {inputInfo}, {inputInfo}, desc);
1570     const std::string layerName("logicalBinaryAnd");  variable
1582 …bleLayer* const logicalBinaryLayer = network->AddLogicalBinaryLayer(descriptor, layerName.c_str());
1597             layerName, { inputInfo, inputInfo }, { outputInfo }, descriptor);
1603     const std::string layerName("log_softmax");  variable
1612 …nnectableLayer* const logSoftmaxLayer = network->AddLogSoftmaxLayer(descriptor, layerName.c_str());
1624 …LayerVerifierBaseWithDescriptor<armnn::LogSoftmaxDescriptor> verifier(layerName, {info}, {info}, d…
1630     const std::string layerName("maximum");  variable
1637     armnn::IConnectableLayer* const maximumLayer = network->AddMaximumLayer(layerName.c_str());
1652     LayerVerifierBase verifier(layerName, {info, info}, {info});
1658     const std::string layerName("mean");  variable
1668 …  armnn::IConnectableLayer* const meanLayer = network->AddMeanLayer(descriptor, layerName.c_str());
1680 …LayerVerifierBaseWithDescriptor<armnn::MeanDescriptor> verifier(layerName, {inputInfo}, {outputInf…
1686     const std::string layerName("merge");  variable
1692     armnn::IConnectableLayer* const mergeLayer = network->AddMergeLayer(layerName.c_str());
1706     LayerVerifierBase verifier(layerName, {info, info}, {info});
1713     MergerLayerVerifier(const std::string& layerName,  in MergerLayerVerifier()  argument
1717 …: LayerVerifierBaseWithDescriptor<armnn::OriginsDescriptor>(layerName, inputInfos, outputInfos, de…  in MergerLayerVerifier()
1822     const std::string layerName("concat");  variable
1834 …armnn::IConnectableLayer* const concatLayer = network->AddConcatLayer(descriptor, layerName.c_str(…
1851     MergerLayerVerifier verifier(layerName, {inputInfo, inputInfo}, {outputInfo}, descriptor);
1857     const std::string layerName("minimum");  variable
1864     armnn::IConnectableLayer* const minimumLayer = network->AddMinimumLayer(layerName.c_str());
1879     LayerVerifierBase verifier(layerName, {info, info}, {info});
1885     const std::string layerName("multiplication");  variable
1892 …armnn::IConnectableLayer* const multiplicationLayer = network->AddMultiplicationLayer(layerName.c_…
1907     LayerVerifierBase verifier(layerName, {info, info}, {info});
1913     const std::string layerName("prelu");  variable
1922     armnn::IConnectableLayer* const preluLayer = network->AddPreluLayer(layerName.c_str());
1936     LayerVerifierBase verifier(layerName, {inputTensorInfo, alphaTensorInfo}, {outputTensorInfo});
1942     const std::string layerName("normalization");  variable
1954 …nnectableLayer* const normalizationLayer = network->AddNormalizationLayer(desc, layerName.c_str());
1966 …LayerVerifierBaseWithDescriptor<armnn::NormalizationDescriptor> verifier(layerName, {info}, {info}…
1972     const std::string layerName("pad");  variable
1980     armnn::IConnectableLayer* const padLayer = network->AddPadLayer(desc, layerName.c_str());
1992     LayerVerifierBaseWithDescriptor<armnn::PadDescriptor> verifier(layerName,
2001     const std::string layerName("padReflect");  variable
2010     armnn::IConnectableLayer* const padLayer = network->AddPadLayer(desc, layerName.c_str());
2022     LayerVerifierBaseWithDescriptor<armnn::PadDescriptor> verifier(layerName,
2085     const std::string layerName("permute");  variable
2093 …armnn::IConnectableLayer* const permuteLayer = network->AddPermuteLayer(descriptor, layerName.c_st…
2106             layerName, {inputTensorInfo}, {outputTensorInfo}, descriptor);
2112     const std::string layerName("pooling2d");  variable
2132 …armnn::IConnectableLayer* const pooling2dLayer = network->AddPooling2dLayer(desc, layerName.c_str(…
2145             layerName, {inputInfo}, {outputInfo}, desc);
2151     const std::string layerName("pooling3d");  variable
2175 …armnn::IConnectableLayer* const pooling3dLayer = network->AddPooling3dLayer(desc, layerName.c_str(…
2188             layerName, {inputInfo}, {outputInfo}, desc);
2194     const std::string layerName("quantize");  variable
2199     armnn::IConnectableLayer* const quantizeLayer = network->AddQuantizeLayer(layerName.c_str());
2211     LayerVerifierBase verifier(layerName, {info}, {info});
2217     const std::string layerName("rank");  variable
2223     armnn::IConnectableLayer* const rankLayer = network->AddRankLayer(layerName.c_str());
2235     LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
2241     const std::string layerName("Reduce_Sum");  variable
2251 …armnn::IConnectableLayer* const reduceSumLayer = network->AddReduceLayer(descriptor, layerName.c_s…
2263 …LayerVerifierBaseWithDescriptor<armnn::ReduceDescriptor> verifier(layerName, {inputInfo}, {outputI…
2269     const std::string layerName("reshape");  variable
2277 …armnn::IConnectableLayer* const reshapeLayer = network->AddReshapeLayer(descriptor, layerName.c_st…
2290             layerName, {inputInfo}, {outputInfo}, descriptor);
2296     const std::string layerName("resize");  variable
2309     armnn::IConnectableLayer* const resizeLayer = network->AddResizeLayer(desc, layerName.c_str());
2321 …LayerVerifierBaseWithDescriptor<armnn::ResizeDescriptor> verifier(layerName, {inputInfo}, {outputI…
2328     ResizeBilinearLayerVerifier(const std::string& layerName,  in ResizeBilinearLayerVerifier()  argument
2333             layerName, inputInfos, outputInfos, descriptor) {}  in ResizeBilinearLayerVerifier()
2370     const std::string layerName("resizeBilinear");  variable
2383     armnn::IConnectableLayer* const resizeLayer = network->AddResizeLayer(desc, layerName.c_str());
2395     ResizeBilinearLayerVerifier verifier(layerName, {inputInfo}, {outputInfo}, desc);
2457     const std::string layerName("shape");  variable
2463     armnn::IConnectableLayer* const shapeLayer = network->AddShapeLayer(layerName.c_str());
2475     LayerVerifierBase verifier(layerName, {inputInfo}, {outputInfo});
2482     const std::string layerName{"slice"};  variable
2492 …armnn::IConnectableLayer* const sliceLayer  = network->AddSliceLayer(descriptor, layerName.c_str()…
2504 …LayerVerifierBaseWithDescriptor<armnn::SliceDescriptor> verifier(layerName, {inputInfo}, {outputIn…
2510     const std::string layerName("softmax");  variable
2518 …armnn::IConnectableLayer* const softmaxLayer = network->AddSoftmaxLayer(descriptor, layerName.c_st…
2530 …LayerVerifierBaseWithDescriptor<armnn::SoftmaxDescriptor> verifier(layerName, {info}, {info}, desc…
2536     const std::string layerName("spaceToBatchNd");  variable
2547 …ectableLayer* const spaceToBatchNdLayer = network->AddSpaceToBatchNdLayer(desc, layerName.c_str());
2560             layerName, {inputInfo}, {outputInfo}, desc);
2566     const std::string layerName("spaceToDepth");  variable
2577 …ConnectableLayer* const spaceToDepthLayer = network->AddSpaceToDepthLayer(desc, layerName.c_str());
2590             layerName, {inputInfo}, {outputInfo}, desc);
2619     const std::string layerName("splitter");  variable
2625 …armnn::IConnectableLayer* const splitterLayer = network->AddSplitterLayer(desc, layerName.c_str());
2644             layerName, {inputInfo}, {outputInfo, outputInfo, outputInfo}, desc);
2650     const std::string layerName("stack");  variable
2660 …armnn::IConnectableLayer* const stackLayer = network->AddStackLayer(descriptor, layerName.c_str());
2675             layerName, {inputTensorInfo, inputTensorInfo}, {outputTensorInfo}, descriptor);
2681     const std::string layerName("standIn");  variable
2689 …armnn::IConnectableLayer* const standInLayer = network->AddStandInLayer(descriptor, layerName.c_st…
2709             layerName, { tensorInfo, tensorInfo }, { tensorInfo, tensorInfo }, descriptor);
2715     const std::string layerName("stridedSlice");  variable
2726 …ConnectableLayer* const stridedSliceLayer = network->AddStridedSliceLayer(desc, layerName.c_str());
2739             layerName, {inputInfo}, {outputInfo}, desc);
2745     const std::string layerName("subtraction");  variable
2752 …armnn::IConnectableLayer* const subtractionLayer = network->AddSubtractionLayer(layerName.c_str());
2767     LayerVerifierBase verifier(layerName, {info, info}, {info});
2776         SwitchLayerVerifier(const std::string& layerName,  in SwitchLayerVerifier()  argument
2779                 : LayerVerifierBase(layerName, inputInfos, outputInfos) {}  in SwitchLayerVerifier()
2806     const std::string layerName("switch");  variable
2815     armnn::IConnectableLayer* const switchLayer = network->AddSwitchLayer(layerName.c_str());
2832     SwitchLayerVerifier verifier(layerName, {info, info}, {info, info});
2838     const std::string layerName("transpose");  variable
2846 …ConnectableLayer* const transposeLayer = network->AddTransposeLayer(descriptor, layerName.c_str());
2859             layerName, {inputTensorInfo}, {outputTensorInfo}, descriptor);
2865     const std::string layerName("transposeConvolution2d");  variable
2894                                                     layerName.c_str());
2908             layerName, {inputInfo}, {outputInfo}, descriptor, constants);
2917         ConstantLayerVerifier(const std::string& layerName,  in ConstantLayerVerifier()  argument
2921             : LayerVerifierBase(layerName, inputInfos, outputInfos)  in ConstantLayerVerifier()
2954     const std::string layerName("constant");  variable
2965     armnn::IConnectableLayer* constant = network->AddConstantLayer(constTensor, layerName.c_str());
2979     ConstantLayerVerifier verifier(layerName, {}, {info}, constTensor);