AddBroadcastReshapeLayerTests.cpp File Reference

#include "../GraphUtils.hpp"
#include "../TestUtils.hpp"
#include <Optimizer.hpp>
#include <boost/test/unit_test.hpp>

Go to the source code of this file.

Functions
void	AddBroadcastReshapeLayerOptimizerTest (const TensorInfo &info0, const TensorInfo &info1, const TensorInfo &outputInfo, const std::string &reshapeLayerName, const TensorShape &expectedReshapeShape, const DataType expectedDataType)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayerSimpleTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayer1DTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayer2DTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayer3DTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayer3DMergedTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayerSubtractionTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayerDivisionTest)
	BOOST_AUTO_TEST_CASE (AddBroadcastReshapeLayerMultiplicationTest)
	BOOST_AUTO_TEST_CASE (AddNoBroadcastReshapeLayerTest)
	BOOST_AUTO_TEST_CASE (ReshapeParentConstLayerTest)
	BOOST_AUTO_TEST_CASE (ReshapeParentConstAddLayerMultipleConnectionsTest)

Function Documentation

AddBroadcastReshapeLayerOptimizerTest()

void AddBroadcastReshapeLayerOptimizerTest	(	const TensorInfo &	info0,
		const TensorInfo &	info1,
		const TensorInfo &	outputInfo,
		const std::string &	reshapeLayerName,
		const TensorShape &	expectedReshapeShape,
		const DataType	expectedDataType
	)

Definition at line 18 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), armnn::MakeOptimizations(), Optimizer::Pass(), and OutputSlot::SetTensorInfo().

Referenced by BOOST_AUTO_TEST_CASE().

{
    Graph graph;

    auto input0 = graph.AddLayer<InputLayer>(0, "input0");
    auto input1 = graph.AddLayer<InputLayer>(1, "input1");
    auto add = graph.AddLayer<AdditionLayer>("add");
    auto output = graph.AddLayer<OutputLayer>(0, "output");
    input0->GetOutputSlot().SetTensorInfo(info0);
    input1->GetOutputSlot().SetTensorInfo(info1);
    add->GetOutputSlot().SetTensorInfo(outputInfo);

    input0->GetOutputSlot().Connect(add->GetInputSlot(0));
    input1->GetOutputSlot().Connect(add->GetInputSlot(1));
    add->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has been added to the graph correctly
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<OutputLayer>));

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, reshapeLayerName);
    BOOST_TEST(reshapeLayer);
    auto addedReshapeTensorInfo = reshapeLayer->GetOutputSlot().GetTensorInfo();

    // Tensorshape and the data type are correct
    BOOST_TEST((addedReshapeTensorInfo.GetShape() == expectedReshapeShape));
    BOOST_TEST((addedReshapeTensorInfo.GetDataType() == expectedDataType));
}

BOOST_AUTO_TEST_CASE() [1/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayerSimpleTest

)

Definition at line 65 of file AddBroadcastReshapeLayerTests.cpp.

References AddBroadcastReshapeLayerOptimizerTest(), and armnn::Float32.

{
    const TensorInfo info0({ 1, 2, 3, 5 }, DataType::Float32);
    const TensorInfo info1({ 1 }, DataType::Float32);
    AddBroadcastReshapeLayerOptimizerTest(info0, info1, info0, "Reshape_for:add-1",
                                          TensorShape({ 1, 1, 1, 1 }),
                                          DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [2/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayer1DTest

)

Definition at line 74 of file AddBroadcastReshapeLayerTests.cpp.

References AddBroadcastReshapeLayerOptimizerTest(), and armnn::Float32.

{
    const TensorInfo info0({ 1, 2, 3, 5 }, DataType::Float32);
    const TensorInfo info1({ 5 }, DataType::Float32);
    const TensorInfo outputInfo({ 1, 1, 1, 5 }, DataType::Float32);
    AddBroadcastReshapeLayerOptimizerTest(info0, info1, outputInfo, "Reshape_for:add-1",
                                          TensorShape({ 1, 1, 1, 5 }),
                                          DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [3/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayer2DTest

)

Definition at line 84 of file AddBroadcastReshapeLayerTests.cpp.

References AddBroadcastReshapeLayerOptimizerTest(), and armnn::Float32.

{
    const TensorInfo info0({ 1, 2, 3, 5 }, DataType::Float32);
    const TensorInfo info1({ 3, 5 }, DataType::Float32);
    const TensorInfo outputInfo({ 1, 2, 3, 5 }, DataType::Float32);
    AddBroadcastReshapeLayerOptimizerTest(info0, info1, outputInfo, "Reshape_for:add-1",
                                          TensorShape({ 1, 1, 3, 5 }),
                                          DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [4/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayer3DTest

)

Definition at line 94 of file AddBroadcastReshapeLayerTests.cpp.

References AddBroadcastReshapeLayerOptimizerTest(), and armnn::Float32.

{
    const TensorInfo info0({ 2, 1, 1, 1 }, DataType::Float32);
    const TensorInfo info1({ 3, 4, 5 }, DataType::Float32);
    const TensorInfo outputInfo({ 2, 3, 4, 5 }, DataType::Float32);
    AddBroadcastReshapeLayerOptimizerTest(info0, info1, outputInfo, "Reshape_for:add-1",
                                          TensorShape({ 1, 3, 4, 5 }),
                                          DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [5/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayer3DMergedTest

)

Definition at line 104 of file AddBroadcastReshapeLayerTests.cpp.

References AddBroadcastReshapeLayerOptimizerTest(), and armnn::Float32.

{
    const TensorInfo info0({ 2, 3, 1, 1 }, DataType::Float32);
    const TensorInfo info1({ 3, 4, 5 }, DataType::Float32);
    const TensorInfo outputInfo({ 2, 3, 4, 5 }, DataType::Float32);
    AddBroadcastReshapeLayerOptimizerTest(info0, info1, outputInfo, "Reshape_for:add-1",
                                          TensorShape({ 1, 3, 4, 5 }),
                                          DataType::Float32);
}

BOOST_AUTO_TEST_CASE() [6/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayerSubtractionTest

)

Definition at line 114 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), armnn::Float32, GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), armnn::MakeOptimizations(), Optimizer::Pass(), and OutputSlot::SetTensorInfo().

{
    Graph graph;
    const TensorInfo info0({ 5 }, DataType::Float32);
    const TensorInfo info1({ 1, 2, 3, 5 }, DataType::Float32);
    const TensorInfo outputInfo({ 1, 2, 3, 5 }, DataType::Float32);

    auto input0 = graph.AddLayer<InputLayer>(0, "input0");
    auto input1 = graph.AddLayer<InputLayer>(1, "input1");
    auto sub = graph.AddLayer<SubtractionLayer>("sub");
    auto output = graph.AddLayer<OutputLayer>(0, "output");
    input0->GetOutputSlot().SetTensorInfo(info0);
    input1->GetOutputSlot().SetTensorInfo(info1);
    sub->GetOutputSlot().SetTensorInfo(outputInfo);

    input0->GetOutputSlot().Connect(sub->GetInputSlot(0));
    input1->GetOutputSlot().Connect(sub->GetInputSlot(1));
    sub->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<SubtractionLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has been added to the graph correctly
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<SubtractionLayer>,
                             &IsLayerOfType<OutputLayer>));

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, "Reshape_for:sub-0");
    BOOST_TEST(reshapeLayer);
    auto addedReshapeTensorInfo = reshapeLayer->GetOutputSlot().GetTensorInfo();

    // Tensorshape and the data type are correct
    BOOST_TEST((addedReshapeTensorInfo.GetShape() == TensorShape({ 1, 1, 1, 5 })));
    BOOST_TEST((addedReshapeTensorInfo.GetDataType() == DataType::Float32));
}

BOOST_AUTO_TEST_CASE() [7/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayerDivisionTest

)

Definition at line 159 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), armnn::MakeOptimizations(), Optimizer::Pass(), armnn::QAsymmS8, and OutputSlot::SetTensorInfo().

{
    Graph graph;
    const TensorInfo info0({ 1, 4, 5 }, DataType::QAsymmS8);
    const TensorInfo info1({ 1, 2, 4, 5 }, DataType::QAsymmS8);
    const TensorInfo outputInfo({ 1, 2, 4, 5 }, DataType::QAsymmS8);

    auto input0 = graph.AddLayer<InputLayer>(0, "input0");
    auto input1 = graph.AddLayer<InputLayer>(1, "input1");
    auto div = graph.AddLayer<DivisionLayer>("div");
    auto output = graph.AddLayer<OutputLayer>(0, "output");
    input0->GetOutputSlot().SetTensorInfo(info0);
    input1->GetOutputSlot().SetTensorInfo(info1);
    div->GetOutputSlot().SetTensorInfo(outputInfo);

    input0->GetOutputSlot().Connect(div->GetInputSlot(0));
    input1->GetOutputSlot().Connect(div->GetInputSlot(1));
    div->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<DivisionLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has been added to the graph correctly
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<DivisionLayer>,
                             &IsLayerOfType<OutputLayer>));

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, "Reshape_for:div-0");
    BOOST_TEST(reshapeLayer);
    auto addedReshapeTensorInfo = reshapeLayer->GetOutputSlot().GetTensorInfo();

    // Tensorshape and the data type are correct
    BOOST_TEST((addedReshapeTensorInfo.GetShape() == TensorShape({ 1, 1, 4, 5 })));
    BOOST_TEST((addedReshapeTensorInfo.GetDataType() == DataType::QAsymmS8));
}

BOOST_AUTO_TEST_CASE() [8/11]

BOOST_AUTO_TEST_CASE

(

AddBroadcastReshapeLayerMultiplicationTest

)

Definition at line 204 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), OutputSlot::GetTensorInfo(), armnn::MakeOptimizations(), Optimizer::Pass(), armnn::QAsymmU8, and OutputSlot::SetTensorInfo().

{
    Graph graph;
    const TensorInfo info0({ 3, 5 }, DataType::QAsymmU8);
    const TensorInfo info1({ 1, 2, 3, 5 }, DataType::QAsymmU8);
    const TensorInfo outputInfo({ 1, 2, 3, 5 }, DataType::QAsymmU8);

    auto input0 = graph.AddLayer<InputLayer>(0, "input0");
    auto input1 = graph.AddLayer<InputLayer>(1, "input1");
    auto mul = graph.AddLayer<MultiplicationLayer>("mul");
    auto output = graph.AddLayer<OutputLayer>(0, "output");
    input0->GetOutputSlot().SetTensorInfo(info0);
    input1->GetOutputSlot().SetTensorInfo(info1);
    mul->GetOutputSlot().SetTensorInfo(outputInfo);

    input0->GetOutputSlot().Connect(mul->GetInputSlot(0));
    input1->GetOutputSlot().Connect(mul->GetInputSlot(1));
    mul->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has been added to the graph correctly
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, "Reshape_for:mul-0");
    BOOST_TEST(reshapeLayer);
    auto addedReshapeTensorInfo = reshapeLayer->GetOutputSlot().GetTensorInfo();

    // Tensorshape and the data type are correct
    BOOST_TEST((addedReshapeTensorInfo.GetShape() == TensorShape({ 1, 1, 3, 5 })));
    BOOST_TEST((addedReshapeTensorInfo.GetDataType() == DataType::QAsymmU8));
}

BOOST_AUTO_TEST_CASE() [9/11]

BOOST_AUTO_TEST_CASE

(

AddNoBroadcastReshapeLayerTest

)

Definition at line 249 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), armnn::MakeOptimizations(), Optimizer::Pass(), armnn::QAsymmU8, and OutputSlot::SetTensorInfo().

{
    Graph graph;
    const TensorInfo info0({ 1, 1, 1, 1 }, DataType::QAsymmU8);
    const TensorInfo info1({ 1, 2, 3, 5 }, DataType::QAsymmU8);
    const TensorInfo outputInfo({ 1, 2, 3, 5 }, DataType::QAsymmU8);

    auto input0 = graph.AddLayer<InputLayer>(0, "input0");
    auto input1 = graph.AddLayer<InputLayer>(1, "input1");
    auto mul = graph.AddLayer<MultiplicationLayer>("mul");
    auto output = graph.AddLayer<OutputLayer>(0, "output");
    input0->GetOutputSlot().SetTensorInfo(info0);
    input1->GetOutputSlot().SetTensorInfo(info1);
    mul->GetOutputSlot().SetTensorInfo(outputInfo);

    input0->GetOutputSlot().Connect(mul->GetInputSlot(0));
    input1->GetOutputSlot().Connect(mul->GetInputSlot(1));
    mul->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has not been added to the graph
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, "Reshape_for:mul-0");
    BOOST_TEST(!reshapeLayer);
}

BOOST_AUTO_TEST_CASE() [10/11]

BOOST_AUTO_TEST_CASE

(

ReshapeParentConstLayerTest

)

Definition at line 288 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), armnn::MakeOptimizations(), Optimizer::Pass(), armnn::QAsymmU8, and OutputSlot::SetTensorInfo().

{
    Graph graph;
    const TensorInfo info0({ 1, 2, 3, 5 }, DataType::QAsymmU8);
    const TensorInfo info1({ 5 }, DataType::QAsymmU8);
    const TensorInfo outputInfo({ 1, 2, 3, 5 }, DataType::QAsymmU8);

    auto input = graph.AddLayer<InputLayer>(0, "input");
    auto constant = graph.AddLayer<ConstantLayer>("constant");
    auto mul = graph.AddLayer<MultiplicationLayer>("mul");
    auto output = graph.AddLayer<OutputLayer>(0, "output");

    uint8_t tensor[] = { 1, 1, 1, 1, 1 };

    constant->m_LayerOutput = std::make_unique<ScopedTensorHandle>(ConstTensor(info1, &tensor));

    input->GetOutputSlot().SetTensorInfo(info0);
    constant->GetOutputSlot().SetTensorInfo(info1);
    mul->GetOutputSlot().SetTensorInfo(outputInfo);

    input->GetOutputSlot().Connect(mul->GetInputSlot(0));
    constant->GetOutputSlot().Connect(mul->GetInputSlot(1));
    mul->GetOutputSlot().Connect(output->GetInputSlot(0));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ConstantLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape layer has not been added to the graph
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ConstantLayer>,
                             &IsLayerOfType<MultiplicationLayer>,
                             &IsLayerOfType<OutputLayer>));

    TensorShape expectedShape = TensorShape{ 1, 1, 1, 5 };
    BOOST_TEST(constant->m_LayerOutput.get()->GetTensorInfo().GetShape() == expectedShape);

    BOOST_TEST(constant->m_LayerOutput.get()->GetTensorInfo().GetNumDimensions() == info0.GetNumDimensions());

    Layer* const reshapeLayer = GetFirstLayerWithName(graph, "Reshape_for:mul-0");
    BOOST_TEST(!reshapeLayer);
}

BOOST_AUTO_TEST_CASE() [11/11]

BOOST_AUTO_TEST_CASE

(

ReshapeParentConstAddLayerMultipleConnectionsTest

)

Definition at line 337 of file AddBroadcastReshapeLayerTests.cpp.

References Graph::AddLayer(), BOOST_AUTO_TEST_SUITE_END(), Graph::cbegin(), Graph::cend(), CheckSequence(), OutputSlot::Connect(), armnn::Float32, GetFirstLayerWithName(), Layer::GetInputSlot(), Layer::GetOutputSlot(), armnn::MakeOptimizations(), Optimizer::Pass(), and OutputSlot::SetTensorInfo().

{
    // In this test case we recreate the situation where an Addition layer has
    // a constant second term, e.g. [1,512] + [1]. The AddBroadcastReshapeLayer
    // should modify the constant tensor info to match the number of dimensions.
    // However, if this constant term is being reused elsewhere then we shouldn't
    // modify it. Instead we insert a resize layer.

    // What we'll do is have two sequential add layers both using the same const tensor.
    Graph graph;
    const TensorInfo inputInfo({ 1, 512 }, DataType::Float32);
    const TensorInfo constantTermInfo({ 1 }, DataType::Float32);
    const TensorInfo outputInfo({ 1, 512 }, DataType::Float32);

    auto input = graph.AddLayer<InputLayer>(0, "input");
    auto constant = graph.AddLayer<ConstantLayer>("constant");
    auto add1 = graph.AddLayer<AdditionLayer>("add1");
    auto add2 = graph.AddLayer<AdditionLayer>("add2");
    auto output = graph.AddLayer<OutputLayer>(0, "output");

    input->GetOutputSlot().SetTensorInfo(inputInfo);
    constant->GetOutputSlot().SetTensorInfo(constantTermInfo);
    float tensor[] = { 2.0f };
    constant->m_LayerOutput = std::make_unique<ScopedTensorHandle>(ConstTensor(constantTermInfo, &tensor));
    add1->GetOutputSlot().SetTensorInfo(outputInfo);

    input->GetOutputSlot().Connect(add1->GetInputSlot(0));
    constant->GetOutputSlot().Connect(add1->GetInputSlot(1));
    add1->GetOutputSlot().Connect(add2->GetInputSlot(0));
    add2->GetOutputSlot().Connect(output->GetInputSlot(0));
    // This second connection should prevent the modification of the const output tensor.
    constant->GetOutputSlot().Connect(add2->GetInputSlot(1));

    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ConstantLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Run optimizer
    armnn::Optimizer::Pass(graph, MakeOptimizations(AddBroadcastReshapeLayer()));

    // Broadcast reshape should have been added before each addition layer.
    BOOST_TEST(CheckSequence(graph.cbegin(), graph.cend(),
                             &IsLayerOfType<InputLayer>,
                             &IsLayerOfType<ConstantLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<ReshapeLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<AdditionLayer>,
                             &IsLayerOfType<OutputLayer>));

    // Ensure the output shape of the constant hasn't changed.
    BOOST_TEST(constant->m_LayerOutput.get()->GetTensorInfo().GetShape() == constantTermInfo.GetShape());
    // There should be two extra reshape layers with appropriate names.
    Layer* const reshapeLayer1 = GetFirstLayerWithName(graph, "Reshape_for:add1-1");
    Layer* const reshapeLayer2 = GetFirstLayerWithName(graph, "Reshape_for:add2-1");
    BOOST_TEST(reshapeLayer1);
    BOOST_TEST(reshapeLayer2);
}