Skip to content
Snippets Groups Projects
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
Test_PadImpl.cpp 23.88 KiB
/********************************************************************************
 * Copyright (c) 2023 CEA-List
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

#include <catch2/catch_test_macros.hpp>
#include <cstdlib>
#include <memory>

#include "aidge/data/Tensor.hpp"
#include "aidge/operator/Pad.hpp"

#include "aidge/backend/cpu.hpp"

using namespace Aidge;

TEST_CASE("[cpu/operator] Pad(forward)", "[Pad][CPU]") {
    SECTION("Symmetric Pad") {
        const int pv = 0; // pad value

        std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
        auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
        std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
            {
                {
                    {{  0,   1,   2,   3,   4},
                    {  5,   6,   7,   8,   9},
                    { 10,  11,  12,  13,  14},
                    { 15,  16,  17,  18,  19},
                    { 20,  21,  22,  23,  24}},

                    {{ 25,  26,  27,  28,  29},
                    { 30,  31,  32,  33,  34},
                    { 35,  36,  37,  38,  39},
                    { 40,  41,  42,  43,  44},
                    { 45,  46,  47,  48,  49}},

                    {{ 50,  51,  52,  53,  54},
                    { 55,  56,  57,  58,  59},
                    { 60,  61,  62,  63,  64},
                    { 65,  66,  67,  68,  69},
                    { 70,  71,  72,  73,  74}}
                },
                {
                    {{ 75,  76,  77,  78,  79},
                    { 80,  81,  82,  83,  84},
                    { 85,  86,  87,  88,  89},
                    { 90,  91,  92,  93,  94},
                    { 95,  96,  97,  98,  99}},

                    {{100, 101, 102, 103, 104},
                    {105, 106, 107, 108, 109},
                    {110, 111, 112, 113, 114},
                    {115, 116, 117, 118, 119},
                    {120, 121, 122, 123, 124}},

                    {{125, 126, 127, 128, 129},
                    {130, 131, 132, 133, 134},
                    {135, 136, 137, 138, 139},
                    {140, 141, 142, 143, 144},
                    {145, 146, 147, 148, 149}}
                }
            }
        });
        std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,3,7,7> { //NCHW
            {
                {
                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    { pv,   0,   1,   2,   3,   4,  pv},
                    { pv,   5,   6,   7,   8,   9,  pv},
                    { pv,  10,  11,  12,  13,  14,  pv},
                    { pv,  15,  16,  17,  18,  19,  pv},
                    { pv,  20,  21,  22,  23,  24,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}},

                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    { pv,  25,  26,  27,  28,  29,  pv},
                    { pv,  30,  31,  32,  33,  34,  pv},
                    { pv,  35,  36,  37,  38,  39,  pv},
                    { pv,  40,  41,  42,  43,  44,  pv},
                    { pv,  45,  46,  47,  48,  49,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}},

                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    { pv,  50,  51,  52,  53,  54,  pv},
                    { pv,  55,  56,  57,  58,  59,  pv},
                    { pv,  60,  61,  62,  63,  64,  pv},
                    { pv,  65,  66,  67,  68,  69,  pv},
                    { pv,  70,  71,  72,  73,  74,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}}
                },
                {
                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    { pv,  75,  76,  77,  78,  79,  pv},
                    { pv,  80,  81,  82,  83,  84,  pv},
                    { pv,  85,  86,  87,  88,  89,  pv},
                    { pv,  90,  91,  92,  93,  94,  pv},
                    { pv,  95,  96,  97,  98,  99,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}},

                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    {pv,  100, 101, 102, 103, 104,  pv},
                    {pv,  105, 106, 107, 108, 109,  pv},
                    {pv,  110, 111, 112, 113, 114,  pv},
                    {pv,  115, 116, 117, 118, 119,  pv},
                    {pv,  120, 121, 122, 123, 124,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}},

                    {{ pv,  pv,   pv,   pv,   pv,   pv,  pv},
                    {pv,  125, 126, 127, 128, 129,  pv},
                    {pv,  130, 131, 132, 133, 134,  pv},
                    {pv,  135, 136, 137, 138, 139,  pv},
                    {pv,  140, 141, 142, 143, 144,  pv},
                    {pv,  145, 146, 147, 148, 149,  pv},
                    { pv,  pv,   pv,   pv,   pv,   pv,  pv}}
                }
            }
        });

        myPad->getOperator()->associateInput(0,myInput);
        myPad->getOperator()->setDataType(DataType::Int32);
        myPad->getOperator()->setBackend("cpu");
        op->computeOutputDims();
        myPad->forward();
        // myPad->getOperator()->getOutput(0)->print();
        REQUIRE(*(op->getOutput(0)) == *myOutput);
    }

    SECTION("Asymmetric Pad") {
        const int pv = 0; // pad value

        std::shared_ptr<Node> myPad = Pad<2>({1, 0, 0, 1}, "mypad", PadBorderType::Constant, static_cast<double>(pv));
        auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
        std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
            {
                {
                    {{  0,   1,   2,   3,   4},
                    {  5,   6,   7,   8,   9},
                    { 10,  11,  12,  13,  14},
                    { 15,  16,  17,  18,  19},
                    { 20,  21,  22,  23,  24}},

                    {{ 25,  26,  27,  28,  29},
                    { 30,  31,  32,  33,  34},
                    { 35,  36,  37,  38,  39},
                    { 40,  41,  42,  43,  44},
                    { 45,  46,  47,  48,  49}},

                    {{ 50,  51,  52,  53,  54},
                    { 55,  56,  57,  58,  59},
                    { 60,  61,  62,  63,  64},
                    { 65,  66,  67,  68,  69},
                    { 70,  71,  72,  73,  74}}
                },
                {
                    {{ 75,  76,  77,  78,  79},
                    { 80,  81,  82,  83,  84},
                    { 85,  86,  87,  88,  89},
                    { 90,  91,  92,  93,  94},
                    { 95,  96,  97,  98,  99}},

                    {{100, 101, 102, 103, 104},
                    {105, 106, 107, 108, 109},
                    {110, 111, 112, 113, 114},
                    {115, 116, 117, 118, 119},
                    {120, 121, 122, 123, 124}},

                    {{125, 126, 127, 128, 129},
                    {130, 131, 132, 133, 134},
                    {135, 136, 137, 138, 139},
                    {140, 141, 142, 143, 144},
                    {145, 146, 147, 148, 149}}
                }
            }
        });
        std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,3,6,6> { //NCHW
            {
                {
                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 0,   1,   2,   3,   4,  pv},
                    { 5,   6,   7,   8,   9,  pv},
                    { 10,  11,  12,  13,  14,  pv},
                    { 15,  16,  17,  18,  19,  pv},
                    { 20,  21,  22,  23,  24,  pv}},

                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 25,  26,  27,  28,  29,  pv},
                    { 30,  31,  32,  33,  34,  pv},
                    { 35,  36,  37,  38,  39,  pv},
                    { 40,  41,  42,  43,  44,  pv},
                    { 45,  46,  47,  48,  49,  pv}},

                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 50,  51,  52,  53,  54,  pv},
                    { 55,  56,  57,  58,  59,  pv},
                    { 60,  61,  62,  63,  64,  pv},
                    { 65,  66,  67,  68,  69,  pv},
                    { 70,  71,  72,  73,  74,  pv}}
                },
                {
                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 75,  76,  77,  78,  79,  pv},
                    { 80,  81,  82,  83,  84,  pv},
                    { 85,  86,  87,  88,  89,  pv},
                    { 90,  91,  92,  93,  94,  pv},
                    { 95,  96,  97,  98,  99,  pv}},

                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 100, 101, 102, 103, 104,  pv},
                    { 105, 106, 107, 108, 109,  pv},
                    { 110, 111, 112, 113, 114,  pv},
                    { 115, 116, 117, 118, 119,  pv},
                    { 120, 121, 122, 123, 124,  pv}},

                    {{ pv,   pv,   pv,   pv,   pv,  pv},
                    { 125, 126, 127, 128, 129,  pv},
                    { 130, 131, 132, 133, 134,  pv},
                    { 135, 136, 137, 138, 139,  pv},
                    { 140, 141, 142, 143, 144,  pv},
                    { 145, 146, 147, 148, 149,  pv}}
                }
            }
        });

        myPad->getOperator()->associateInput(0,myInput);
        myPad->getOperator()->setDataType(DataType::Int32);
        myPad->getOperator()->setBackend("cpu");
        op->computeOutputDims();
        myPad->forward();
        // myPad->getOperator()->getOutput(0)->print();
        REQUIRE(*(op->getOutput(0)) == *myOutput);
    }

    SECTION("Pad Edge") {
        std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Edge);
        auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
        std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
            {
                {
                    {{  0,   1,   2,   3,   4},
                    {  5,   6,   7,   8,   9},
                    { 10,  11,  12,  13,  14},
                    { 15,  16,  17,  18,  19},
                    { 20,  21,  22,  23,  24}},

                    {{ 25,  26,  27,  28,  29},
                    { 30,  31,  32,  33,  34},
                    { 35,  36,  37,  38,  39},
                    { 40,  41,  42,  43,  44},
                    { 45,  46,  47,  48,  49}},

                    {{ 50,  51,  52,  53,  54},
                    { 55,  56,  57,  58,  59},
                    { 60,  61,  62,  63,  64},
                    { 65,  66,  67,  68,  69},
                    { 70,  71,  72,  73,  74}}
                },
                {
                    {{ 75,  76,  77,  78,  79},
                    { 80,  81,  82,  83,  84},
                    { 85,  86,  87,  88,  89},
                    { 90,  91,  92,  93,  94},
                    { 95,  96,  97,  98,  99}},

                    {{100, 101, 102, 103, 104},
                    {105, 106, 107, 108, 109},
                    {110, 111, 112, 113, 114},
                    {115, 116, 117, 118, 119},
                    {120, 121, 122, 123, 124}},

                    {{125, 126, 127, 128, 129},
                    {130, 131, 132, 133, 134},
                    {135, 136, 137, 138, 139},
                    {140, 141, 142, 143, 144},
                    {145, 146, 147, 148, 149}}
                }
            }
        });
        std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,3,7,7> { //NCHW
            {
                {
                    {{ 0,  0,   1,   2,   3,   4,  4},
                    { 0,   0,   1,   2,   3,   4,  4},
                    { 5,   5,   6,   7,   8,   9,  9},
                    { 10,  10,  11,  12,  13,  14,  14},
                    { 15,  15,  16,  17,  18,  19,  19},
                    { 20,  20,  21,  22,  23,  24,  24},
                    { 20,  20,  21,  22,  23,  24,  24}},

                    {{ 25,  25,  26,  27,  28,  29,  29},
                    { 25,  25,  26,  27,  28,  29,  29},
                    { 30,  30,  31,  32,  33,  34,  34},
                    { 35,  35,  36,  37,  38,  39,  39},
                    { 40,  40,  41,  42,  43,  44,  44},
                    { 45,  45,  46,  47,  48,  49,  49},
                    { 45,  45,  46,  47,  48,  49, 49}},

                    {{ 50,  50,  51,  52,  53,  54,  54},
                    { 50,  50,  51,  52,  53,  54,  54},
                    { 55,  55,  56,  57,  58,  59,  59},
                    { 60,  60,  61,  62,  63,  64,  64},
                    { 65,  65,  66,  67,  68,  69,  69},
                    { 70,  70,  71,  72,  73,  74,  74},
                    { 70,  70,  71,  72,  73,  74,  74}}
                },
                {
                    {{ 75,  75,  76,  77,  78,  79,  79},
                    { 75,  75,  76,  77,  78,  79,  79},
                    { 80,  80,  81,  82,  83,  84,  84},
                    { 85,  85,  86,  87,  88,  89,  89},
                    { 90,  90,  91,  92,  93,  94,  94},
                    { 95,  95,  96,  97,  98,  99,  99},
                    { 95,  95,  96,  97,  98,  99,  99}},

                    {{100,  100, 101, 102, 103, 104,  104},
                    {100,  100, 101, 102, 103, 104,  104},
                    {105,  105, 106, 107, 108, 109, 109},
                    {110,  110, 111, 112, 113, 114,  114},
                    {115,  115, 116, 117, 118, 119,  119},
                    {120,  120, 121, 122, 123, 124,  124},
                    {120,  120, 121, 122, 123, 124,  124}},

                    {{125,  125, 126, 127, 128, 129,  129},
                    {125,  125, 126, 127, 128, 129,  129},
                    {130,  130, 131, 132, 133, 134,  134},
                    {135,  135, 136, 137, 138, 139,  139},
                    {140,  140, 141, 142, 143, 144,  144},
                    {145,  145, 146, 147, 148, 149,  149},
                    {145,  145, 146, 147, 148, 149,  149}}
                }
            }
        });

        myPad->getOperator()->associateInput(0,myInput);
        myPad->getOperator()->setDataType(DataType::Int32);
        myPad->getOperator()->setBackend("cpu");
        op->computeOutputDims();
        myPad->forward();
        // myPad->getOperator()->getOutput(0)->print();
        REQUIRE(*(op->getOutput(0)) == *myOutput);
    }

    SECTION("Pad Reflect") {
        std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Reflect);
        auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
        std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
            {
                {
                    {{  0,   1,   2,   3,   4},
                    {  5,   6,   7,   8,   9},
                    { 10,  11,  12,  13,  14},
                    { 15,  16,  17,  18,  19},
                    { 20,  21,  22,  23,  24}},

                    {{ 25,  26,  27,  28,  29},
                    { 30,  31,  32,  33,  34},
                    { 35,  36,  37,  38,  39},
                    { 40,  41,  42,  43,  44},
                    { 45,  46,  47,  48,  49}},

                    {{ 50,  51,  52,  53,  54},
                    { 55,  56,  57,  58,  59},
                    { 60,  61,  62,  63,  64},
                    { 65,  66,  67,  68,  69},
                    { 70,  71,  72,  73,  74}}
                },
                {
                    {{ 75,  76,  77,  78,  79},
                    { 80,  81,  82,  83,  84},
                    { 85,  86,  87,  88,  89},
                    { 90,  91,  92,  93,  94},
                    { 95,  96,  97,  98,  99}},

                    {{100, 101, 102, 103, 104},
                    {105, 106, 107, 108, 109},
                    {110, 111, 112, 113, 114},
                    {115, 116, 117, 118, 119},
                    {120, 121, 122, 123, 124}},

                    {{125, 126, 127, 128, 129},
                    {130, 131, 132, 133, 134},
                    {135, 136, 137, 138, 139},
                    {140, 141, 142, 143, 144},
                    {145, 146, 147, 148, 149}}
                }
            }
        });
        std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,3,7,7> { //NCHW
            {
                {
                    {
                    { 6, 5, 6, 7, 8, 9, 5},
                    { 1, 0, 1, 2, 3, 4, 0},
                    { 6, 5, 6, 7, 8, 9, 5},
                    { 11, 10, 11, 12, 13, 14, 10},
                    { 16, 15, 16, 17, 18, 19, 15},
                    { 21, 20, 21, 22, 23, 24, 20},
                    { 1, 0, 1, 2, 3, 4, 0}
                    },
                    {
                    { 31, 30, 31, 32, 33, 34, 30},
                    { 26, 25, 26, 27, 28, 29, 25},
                    { 31, 30, 31, 32, 33, 34, 30},
                    { 36, 35, 36, 37, 38, 39, 35},
                    { 41, 40, 41, 42, 43, 44, 40},
                    { 46, 45, 46, 47, 48, 49, 45},
                    { 26, 25, 26, 27, 28, 29, 25}
                    },
                    {
                    { 56, 55, 56, 57, 58, 59, 55},
                    { 51, 50, 51, 52, 53, 54, 50},
                    { 56, 55, 56, 57, 58, 59, 55},
                    { 61, 60, 61, 62, 63, 64, 60},
                    { 66, 65, 66, 67, 68, 69, 65},
                    { 71, 70, 71, 72, 73, 74, 70},
                    { 51, 50, 51, 52, 53, 54, 50}
                    }
                },
                {
                    {
                    { 81, 80, 81, 82, 83, 84, 80},
                    { 76, 75, 76, 77, 78, 79, 75},
                    { 81, 80, 81, 82, 83, 84, 80},
                    { 86, 85, 86, 87, 88, 89, 85},
                    { 91, 90, 91, 92, 93, 94, 90},
                    { 96, 95, 96, 97, 98, 99, 95},
                    { 76, 75, 76, 77, 78, 79, 75}
                    },
                    {
                    { 106, 105, 106, 107, 108, 109, 105},
                    { 101, 100, 101, 102, 103, 104, 100},
                    { 106, 105, 106, 107, 108, 109, 105},
                    { 111, 110, 111, 112, 113, 114, 110},
                    { 116, 115, 116, 117, 118, 119, 115},
                    { 121, 120, 121, 122, 123, 124, 120},
                    { 101, 100, 101, 102, 103, 104, 100}
                    },
                    {
                    { 131, 130, 131, 132, 133, 134, 130},
                    { 126, 125, 126, 127, 128, 129, 125},
                    { 131, 130, 131, 132, 133, 134, 130},
                    { 136, 135, 136, 137, 138, 139, 135},
                    { 141, 140, 141, 142, 143, 144, 140},
                    { 146, 145, 146, 147, 148, 149, 145},
                    { 126, 125, 126, 127, 128, 129, 125}
                    }
                    }
                }
        });

        myPad->getOperator()->associateInput(0,myInput);
        myPad->getOperator()->setDataType(DataType::Int32);
        myPad->getOperator()->setBackend("cpu");
        op->computeOutputDims();
        myPad->forward();
        op->getOutput(0)->print();
        REQUIRE(*(op->getOutput(0)) == *myOutput);
    }

    SECTION("Pad Wrap") {
        std::shared_ptr<Node> myPad = Pad<2>({1, 1, 1, 1}, "mypad", PadBorderType::Wrap);
        auto op = std::static_pointer_cast<OperatorTensor>(myPad -> getOperator());
        std::shared_ptr<Tensor> myInput = std::make_shared<Tensor>(Array4D<int,2,3,5,5> { //NCHW
            {
                {
                    {{  0,   1,   2,   3,   4},
                    {  5,   6,   7,   8,   9},
                    { 10,  11,  12,  13,  14},
                    { 15,  16,  17,  18,  19},
                    { 20,  21,  22,  23,  24}},

                    {{ 25,  26,  27,  28,  29},
                    { 30,  31,  32,  33,  34},
                    { 35,  36,  37,  38,  39},
                    { 40,  41,  42,  43,  44},
                    { 45,  46,  47,  48,  49}},

                    {{ 50,  51,  52,  53,  54},
                    { 55,  56,  57,  58,  59},
                    { 60,  61,  62,  63,  64},
                    { 65,  66,  67,  68,  69},
                    { 70,  71,  72,  73,  74}}
                },
                {
                    {{ 75,  76,  77,  78,  79},
                    { 80,  81,  82,  83,  84},
                    { 85,  86,  87,  88,  89},
                    { 90,  91,  92,  93,  94},
                    { 95,  96,  97,  98,  99}},

                    {{100, 101, 102, 103, 104},
                    {105, 106, 107, 108, 109},
                    {110, 111, 112, 113, 114},
                    {115, 116, 117, 118, 119},
                    {120, 121, 122, 123, 124}},

                    {{125, 126, 127, 128, 129},
                    {130, 131, 132, 133, 134},
                    {135, 136, 137, 138, 139},
                    {140, 141, 142, 143, 144},
                    {145, 146, 147, 148, 149}}
                }
            }
        });
        std::shared_ptr<Tensor> myOutput = std::make_shared<Tensor>(Array4D<int,2,3,7,7> { //NCHW
            {
                {
                    {{ 24,  20,  21,  22,  23,  24,  20},
                    { 4,   0,   1,   2,   3,   4,  0},
                    { 9,   5,   6,   7,   8,   9,  5},
                    { 14,  10,  11,  12,  13,  14,  10},
                    { 19,  15,  16,  17,  18,  19,  15},
                    { 24,  20,  21,  22,  23,  24,  20},
                    { 4,   0,   1,   2,   3,   4,  0}},

                    {{ 49,  45,  46,  47,  48,  49, 45},
                    { 29,  25,  26,  27,  28,  29,  25},
                    { 34,  30,  31,  32,  33,  34,  30},
                    { 39,  35,  36,  37,  38,  39,  35},
                    { 44,  40,  41,  42,  43,  44,  40},
                    { 49,  45,  46,  47,  48,  49,  45},
                    { 29,  25,  26,  27,  28,  29,  25}},

                    {{ 74,  70,  71,  72,  73,  74,  70},
                    { 54,  50,  51,  52,  53,  54,  50},
                    { 59,  55,  56,  57,  58,  59,  55},
                    { 64,  60,  61,  62,  63,  64,  60},
                    { 69,  65,  66,  67,  68,  69,  65},
                    { 74,  70,  71,  72,  73,  74,  70},
                    { 54,  50,  51,  52,  53,  54,  50}}
                },
                {
                    {{ 99,  95,  96,  97,  98,  99,  95},
                    { 79,  75,  76,  77,  78,  79,  75},
                    { 84,  80,  81,  82,  83,  84,  80},
                    { 89,  85,  86,  87,  88,  89,  85},
                    { 94,  90,  91,  92,  93,  94,  90},
                    { 99,  95,  96,  97,  98,  99,  95},
                    { 79,  75,  76,  77,  78,  79,  75}},

                    {{124,  120, 121, 122, 123, 124,  120},
                    {104,  100, 101, 102, 103, 104,  100},
                    {109,  105, 106, 107, 108, 109, 105},
                    {114,  110, 111, 112, 113, 114,  110},
                    {119,  115, 116, 117, 118, 119,  115},
                    {124,  120, 121, 122, 123, 124,  120},
                    {104,  100, 101, 102, 103, 104,  100}},

                    {{149,  145, 146, 147, 148, 149,  145},
                    {129,  125, 126, 127, 128, 129,  125},
                    {134,  130, 131, 132, 133, 134,  130},
                    {139,  135, 136, 137, 138, 139,  135},
                    {144,  140, 141, 142, 143, 144,  140},
                    {149,  145, 146, 147, 148, 149,  145},
                    {129,  125, 126, 127, 128, 129,  125}}
                }
            }
        });

        myPad->getOperator()->associateInput(0,myInput);
        myPad->getOperator()->setDataType(DataType::Int32);
        myPad->getOperator()->setBackend("cpu");
        op->computeOutputDims();
        myPad->forward();
        // myPad->getOperator()->getOutput(0)->print();
        REQUIRE(*(op->getOutput(0)) == *myOutput);
    }
}