cavis/libnd4j/tests_cpu/layers_tests/ShapeTests2.cpp

/*******************************************************************************
 * Copyright (c) 2015-2018 Skymind, Inc.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Apache License, Version 2.0 which is available at
 * https://www.apache.org/licenses/LICENSE-2.0.
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 ******************************************************************************/

//
// Created by agibsonccc on 1/6/17.
//
#include <helpers/data_gen.h>
#include "testinclude.h"
#include <helpers/TAD.h>
#include <helpers/ShapeBuilders.h>

class OnesTest : public testing::Test {
public:
    Nd4jLong shapeBuffer[12] = {4,4,3,1,1,3,1,1,1,0,1,99};
    int dimension[3] = {0,2,3};
    Nd4jLong tadAssertionShape[10] = {3,1,1,4,1,1,3,0,3,99};
    int dimensionLength = 3;
};

class LabelTest : public testing::Test {
public:
    float labels[450] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
    Nd4jLong shapeInfo[8] = {2,150,3,1,150,16384,1,102};
    int dimension[1] = {1};
    int dimensionLength = 1;
    Nd4jLong tadShapeInfoAssert[8] = {2,1,3,1,150,16384,150,102};
};
class ThreeDTest : public testing::Test {
public:
    Nd4jLong shape[3] = {3,4,5};
    Nd4jLong *shapeBuffer;
    ThreeDTest() {
        shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
    }
    ~ThreeDTest() {
        delete[] shapeBuffer;
    }
};

class VectorTest : public testing::Test {

};

class NumTadTests : public testing::Test {
public:
    Nd4jLong shape[3] = {3,4,5};
    int dimension = 0;
};

class ShapeTest :  public testing::Test {
public:
    Nd4jLong vectorShape[2] = {1,2};
};

class MatrixTest : public testing::Test {
public:
    int rows = 3;
    int cols = 4;
    int rank = 2;
    int dims[2] = {0,1};
    Nd4jLong expectedShapes[2][2] = {
            {1,3},
            {1,4}
    };
    Nd4jLong expectedStrides[2][2] = {
            {1,4},
            {1,1}
    };
};

class TADStall : public testing::Test {
public:
    Nd4jLong shape[4] = {3,3,4,5};
    int dimensions[3]  = {1,2,3};
};

class TensorOneDimTest : public testing::Test {
public:
    int rows = 3;
    int cols = 4;
    int dim2 = 5;
    int rank = 3;
    int dims[3] = {0,1,2};
    Nd4jLong expectedShapes[3][2] = {
            {1,3},
            {1,4},
            {1,5}
    };
    Nd4jLong expectedStrides[3][2] = {
            {1,20},
            {1,5},
            {1,1}
    };
};

class TensorTwoDimTest : public testing::Test {
public:
    //From a 3d array:
    int rows = 3;
    int cols = 4;
    int dim2 = 5;
    int dimensionLength = 2;
    int dims[3][2] = {
            {0,1},{0,2},{1,2}
    };

    Nd4jLong shape[3] {rows,cols,dim2};

    //Along dimension 0,1: expect matrix with shape [rows,cols]
    //Along dimension 0,2: expect matrix with shape [rows,dim2]
    //Along dimension 1,2: expect matrix with shape [cols,dim2]
    Nd4jLong expectedShapes[3][2] = {
            {rows,cols},
            {rows,dim2},
            {cols,dim2}
    };

    Nd4jLong expectedStrides[3][2] = {
            {20,5},
            {20,1},
            {5,1}
    };

};

class TensorTwoFromFourDDimTest : public testing::Test {
public:
    //From a 3d array:
    int rows = 3;
    int cols = 4;
    int dim2 = 5;
    int dim3 = 6;
    Nd4jLong shape[4] = {rows,cols,dim2,dim3};
    int dimensionLength = 2;
    //Along dimension 0,1: expect matrix with shape [rows,cols]
    //Along dimension 0,2: expect matrix with shape [rows,dim2]
    //Along dimension 0,3: expect matrix with shape [rows,dim3]
    //Along dimension 1,2: expect matrix with shape [cols,dim2]
    //Along dimension 1,3: expect matrix with shape [cols,dim3]
    //Along dimension 2,3: expect matrix with shape [dim2,dim3]

    int dims[6][2] = {
            {0,1},
            {0,2},
            {0,3},
            {1,2},
            {1,3},
            {2,3}
    };

    Nd4jLong expectedShapes[6][2] = {
             {rows,cols},
             {rows,dim2},
             {rows,dim3},
             {cols,dim2},
             {cols,dim3}
            ,{dim2,dim3}
    };

    Nd4jLong expectedStrides[6][2] = {
            {120,30},
            {120,6},
            {120,1},
            {30,6},
            {30,1},
            {6,1}
    };
};


class OrderTest : public testing::Test {
public:
    Nd4jLong expected[8] = {2,3,4,1,3,0,0,102};
    Nd4jLong test[8] = {2,3,4,1,3,0,0,102};

};


class LeadingOnes : public testing::Test {
public:
    Nd4jLong shapeBufferF[16] = {4,1,1,4,4,1,1,1,4,16384,1,102}; // shapes with data type DOUBLE
    Nd4jLong shapeBufferC[16] = {4,1,1,4,4,16,16,4,1,16384,1,99};
    int dimensionLength = 2;
    int dimension[2] = {2,3};
    Nd4jLong tadAssertionC[10] = {3,4,4,1,4,1,16,16384,1,99};
    Nd4jLong tadCAssertionF[10] = {3,4,4,1,1,4,1,16384,1,102};
};


TEST_F(LeadingOnes,OnesTest) {

    shape::TAD *cTad = new shape::TAD;
    cTad->init(shapeBufferC,dimension,dimensionLength);
    cTad->createTadOnlyShapeInfo();
    cTad->createOffsets();
    shape::TAD *fTad = new shape::TAD;
    fTad->init(shapeBufferF,dimension,dimensionLength);
    fTad->createTadOnlyShapeInfo();
    fTad->createOffsets();
    // shape::printShapeInfoLinear(cTad->tadOnlyShapeInfo);
    // shape::printShapeInfoLinear(fTad->tadOnlyShapeInfo);
    ASSERT_TRUE(arrsEquals(10, tadCAssertionF, fTad->tadOnlyShapeInfo));
    ASSERT_TRUE(arrsEquals(10, tadAssertionC, cTad->tadOnlyShapeInfo));

    delete cTad;
    delete fTad;
}


class NormalThreeFourFive : public testing::Test {
public:
    Nd4jLong assertionBuffer[8] = {2, 3, 4, 20, 5, 16384, 5, 99};
    Nd4jLong inputShapeBuffer[10] = {3,3,4,5,20,5,1,16384,1,99};
    int dimensionLength = 2;
    int dimension[2] = {0,1};
};


TEST_F(NormalThreeFourFive,DimensionTest) {
    shape::TAD *tad = new shape::TAD;
    tad->init(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad->createOffsets();
    ASSERT_TRUE(arrsEquals(8,assertionBuffer,tad->tadOnlyShapeInfo));

    delete tad;
}

class DimensionWarning : public testing::Test {
public:
    int dimensionLength = 2;
    int dimensions[2] = {0,1};
    Nd4jLong shape[3] = {1,5,1};
    Nd4jLong *shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);

    ~DimensionWarning() {
        delete[] shapeBuffer;
    }
};


TEST_F(DimensionWarning,ShapeWarning) {
    shape::TAD *tad = new shape::TAD;
    tad->init(shapeBuffer,dimensions,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad->createOffsets();
    delete tad;
}


class TadRank : public testing::Test {
    Nd4jLong shapeBuffer[12] = {4,2,1,3,3,9,9,3,1,0,1,99};
    int dimensionLength = 2;
    int dimension[2] = {2,3};

};

class TestRemoveIndex : public testing::Test {};

class TestReverseCopy : public testing::Test {};

class TestConcat : public testing::Test {};

class SliceVectorTest : public testing::Test {};

class SliceMatrixTest : public testing::Test {};

class SliceTensorTest : public testing::Test {};

class ElementWiseStrideTest : public testing::Test {
public:
    Nd4jLong shape[3] = {3,4,5};
    Nd4jLong stride[2] = {20,5};
    int elementWiseStrideAssertion = -1;
};

class PermuteTest : public testing::Test{};

class LengthPerSliceTest : public testing::Test{};

class ExpectedValuesTest : public testing::Test {
public:
    Nd4jLong mainShape[4] = {9,7,5,3};
    int testDimensions[3] = {0,2,3};

};

class BeginOneTadTest : public testing::Test {
public:
    Nd4jLong assertionShapeBuffer[8] = {2,3,5,1,3,16384,1,102};
    Nd4jLong inputShapeBuffer[10] = {3,1,3,5,1,1,3,16384,0,102};
    int dimensionLength = 2;
    int dimension[2] = {1,2};
    //error: [2,1,1,1,1,0,1,97]
};

class FourDTest : public testing::Test {
    /**
     * INDArray array3d = Nd4j.ones(1, 10, 10);
array3d.sum(1);

INDArray array4d = Nd4j.ones(1, 10, 10, 10);
INDArray sum40 = array4d.sum(0);
     */
public:
    Nd4jLong threeDShape[3] = {1,10,10};
    Nd4jLong fourDShape[4] = {1,10,10,10};
    Nd4jLong *threeDShapeBuffer = nullptr,*fourDShapeBuffer = nullptr;
    int dimensionThree = 1;
    int dimensionThreeTwo = 0;
    int dimensionFour = 0;
    int dimensionLength = 1;
    FourDTest() {
        threeDShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'f', 3, threeDShape);
        fourDShapeBuffer  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'f', 4, fourDShape);
    }
    ~FourDTest() {
        if(threeDShapeBuffer != nullptr)
            delete[] threeDShapeBuffer;
        if(fourDShapeBuffer != nullptr)
            delete[] fourDShapeBuffer;
    }



};



TEST_F(FourDTest,ThreeDFourDTest) {
    shape::TAD *threeTadTwo = new shape::TAD;
    threeTadTwo->init(threeDShapeBuffer,&dimensionThreeTwo,dimensionLength);
    threeTadTwo->createTadOnlyShapeInfo();
    threeTadTwo->createOffsets();

    shape::TAD *threeTad = new shape::TAD;
    threeTad->init(threeDShapeBuffer,&dimensionThree,dimensionLength);
    threeTad->createTadOnlyShapeInfo();
    threeTad->createOffsets();

    shape::TAD *fourTad = new shape::TAD;
    fourTad->init(fourDShapeBuffer,&dimensionFour,dimensionLength);
    fourTad->createTadOnlyShapeInfo();
    fourTad->createOffsets();

    delete threeTadTwo;
    delete threeTad;
    delete fourTad;
}



class RowVectorOnesTest : public testing::Test {
public:
    Nd4jLong shapeBuffer[12] = {4,4,3,1,1,3,1,1,1,8192,1,99}; // float32 type of shape
    float data[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
    Nd4jLong assertionBuffer[10] = {3,4,1,1,3,1,1,8192,0,99};
    int dimensionLength = 3;
    int dimension[3] = {0,2,3};
};

// TEST_F(RowVectorOnesTest,TadShape) {
//     shape::TAD *tad = new shape::TAD(shapeBuffer,dimension,dimensionLength);
//     tad->createTadOnlyShapeInfo();
//     tad ->createOffsets();
//     ASSERT_TRUE(arrsEquals(10,assertionBuffer,tad->tadOnlyShapeInfo));
//     delete tad;
// }



class SixDTest : public testing::Test {
public:
    Nd4jLong inputShapeBuffer[16] = {6,1,1,4,4,4,4,1,1,1,4,16,64,16384,1,102}; // shape with double data type
    int dimensionLength = 2;
    int dimension[2] = {2,3};
    Nd4jLong assertionShapeBuffer[8] = {2,4,4,1,4,16384,1,102}; // also double typed shape
};

TEST_F(SixDTest, SixDWithOnes) {
    shape::TAD *tad = new shape::TAD;
    tad->init(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad->createOffsets();
    // shape::printShapeInfoLinear(inputShapeBuffer);
    // shape::printShapeInfoLinear(tad->tadOnlyShapeInfo);
    //[2,1,1,1,1,0,1,97]
    ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
    delete tad;
}

class TrailingTest : public testing::Test {
public:
    Nd4jLong inputShapeBuffer[12] = {4,5,5,5,1,1,5,25,125,16384,1,102};
    int dimensionLength = 1;
    int dimension[1] = {0};
    Nd4jLong assertionShapeBuffer[8] = {2,1,5,125,1,16384,1,102};
};

TEST_F(TrailingTest,TrailingTest2) {
    shape::TAD *tad = new shape::TAD;
    tad->init(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad->createOffsets();
    //[2,1,1,1,1,0,1,97]
    ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
    delete tad;
}


class ScalarTest : public testing::Test {
public:
    Nd4jLong inputShapeBuffer[12] = {3,2,3,4,12,4,1,16384,1,99};
    int dimensionLength = 1;
    int dimension[1] = {1};
    Nd4jLong assertionShapeBuffer[8] = {2,1,1,1,1,16384,1,99};
};
/*
TEST_F(ScalarTest,ScalarTest2) {
    shape::TAD *tad = new shape::TAD(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad ->createOffsets();
    //[2,1,1,1,1,0,1,97]
    shape::printShapeInfoLinear(tad->tadOnlyShapeInfo);
    ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
}
*/



class ThreeTest : public testing::Test {
public:
    Nd4jLong inputShapeBuffer[10] = {3,4,3,2,6,2,1,16384,1,99};
    int dimensionLength = 1;
    int dimension[1] = {0};
    Nd4jLong assertionShapeBuffer[8] = {2,1,4,1,6,16384,6,99};
};

TEST_F(ThreeTest,ThreeTest ) {
    shape::TAD *tad = new shape::TAD;
    tad->init(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    tad->createOffsets();
    //[2,1,1,1,1,0,1,97]
    ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tad->tadOnlyShapeInfo));
    delete tad;
}


TEST_F(BeginOneTadTest, TadTest) {
    shape::TAD *tad = new shape::TAD;
    tad->init(inputShapeBuffer,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    auto tadShapeBuffer = tad->tadOnlyShapeInfo;
    // shape::printShapeInfoLinear(tadShapeBuffer);
    //[2,1,1,1,1,0,1,97]
    ASSERT_TRUE(arrsEquals(8,assertionShapeBuffer,tadShapeBuffer));

    delete tad;
}

/*
TEST_F(OnesTest,OnesTadTest) {
    shape::TAD *tad = new shape::TAD(shapeBuffer,dimension,dimensionLength);
    int *tadShapeBuffer = tad->shapeInfoOnlyShapeAndStride();
    ASSERT_TRUE(arrsEquals(10,tadAssertionShape,tadShapeBuffer));
    delete[] tadShapeBuffer;
}
*/

TEST_F(LabelTest,LabelTad) {
    shape::TAD *tad = new shape::TAD;
    tad->init(shapeInfo,dimension,dimensionLength);
    tad->createTadOnlyShapeInfo();
    auto tadShapeInfo = tad->tadOnlyShapeInfo;
    ASSERT_TRUE(arrsEquals(8,tadShapeInfoAssert,tadShapeInfo));

    delete tad;
}

TEST_F(ExpectedValuesTest,TadTest) {
    auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, mainShape);
    shape::TAD *tad = new shape::TAD;
    tad->init(shapeBuffer,testDimensions,3);
    tad->createTadOnlyShapeInfo();
    auto shapeInfo = tad->tadOnlyShapeInfo;

    delete tad;
    delete[] shapeBuffer;
}

TEST_F(OrderTest,testOrder) {
    int rank = shape::rank(expected);
    auto expectedShape = shape::shapeOf(expected);
    auto expectedStride = shape::stride(expected);
    int realOrder = shape::getOrder(rank,expectedShape,expectedStride,1);
    int expectedOrder = 102;
    ASSERT_EQ(expectedOrder,realOrder);
}


TEST_F(ThreeDTest,TensorAlongDimensionTest) {
    int dimension[2] = {0,2};
    Nd4jLong tadShapeAssertion[2] = {3,5};
    Nd4jLong strideAssertion[2] = {20,1};
    shape::TAD *tad = new shape::TAD;
    tad->init(0,this->shapeBuffer,dimension,2);
    tad->createTadOnlyShapeInfo();
    auto shapeBufferTest = tad->tadOnlyShapeInfo;
    auto shapeTest = shape::shapeOf(shapeBufferTest);
    auto strideTest = shape::stride(shapeBufferTest);
    ASSERT_TRUE(arrsEquals(2,tadShapeAssertion,shapeTest));
    ASSERT_TRUE(arrsEquals(2,strideAssertion,strideTest));
    delete tad;
}


TEST_F(NumTadTests,TadTest) {
    auto shape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, this->shape);
    shape::TAD *tad = new shape::TAD;
    tad->init(shape,&dimension,1);
    int numTads = shape::tensorsAlongDimension(shape,&dimension,1);
    ASSERT_EQ(20,numTads);
    delete[] shape;
    delete tad;
}

TEST_F(TADStall,TestStall) {
    auto shapeInfo = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shape);
    shape::TAD *tad = new shape::TAD;
    tad->init(0,shapeInfo,this->dimensions,3);
    tad->createTadOnlyShapeInfo();
    Nd4jLong *test = tad->tadOnlyShapeInfo;

    delete[] shapeInfo;
    delete tad;
}


TEST_F(LengthPerSliceTest,TestLengthPerSlice) {
    Nd4jLong firstShape[2] = {5,3};
    int lengthPerSliceAssertionFirst = 3;
    int firstDimension = 0;
    int lengthPerSliceTest = shape::lengthPerSlice(2,firstShape,&firstDimension,1);
    ASSERT_EQ(lengthPerSliceAssertionFirst,lengthPerSliceTest);
}

TEST_F(PermuteTest,PermuteShapeBufferTest) {
    int permuteOrder[4] = {3,2,1,0};
    int normalOrder[4] = {0,1,2,3};
    Nd4jLong shapeToPermute[4] = {5,3,2,6};
    Nd4jLong permutedOrder[4] = {6,2,3,5};
    auto shapeBufferOriginal  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shapeToPermute);
    auto assertionShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shapeToPermute);
    shape::permuteShapeBufferInPlace(shapeBufferOriginal,normalOrder,shapeBufferOriginal);
    EXPECT_TRUE(arrsEquals(4,assertionShapeBuffer,shapeBufferOriginal));

    auto backwardsAssertion  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, permutedOrder);
    auto permuted = shape::permuteShapeBuffer(assertionShapeBuffer, permuteOrder);
    EXPECT_TRUE(arrsEquals(4, backwardsAssertion, permuted));


    delete[] permuted;
    delete[] backwardsAssertion;
    delete[] shapeBufferOriginal;
    delete[] assertionShapeBuffer;
}

TEST_F(ElementWiseStrideTest,ElementWiseStrideTest) {

}

TEST_F(SliceVectorTest,RowColumnVectorTest) {
    Nd4jLong rowVectorShape[2] = {1,5};
    auto rowVectorShapeInfo  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorShape);
    Nd4jLong colVectorShape[2] = {5,1};
    auto colVectorShapeInfo  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, colVectorShape);
    Nd4jLong *sliceRow = shape::sliceOfShapeBuffer(0,rowVectorShapeInfo);
    EXPECT_TRUE(arrsEquals(2,rowVectorShapeInfo,sliceRow));
    Nd4jLong *scalarSliceInfo = shape::createScalarShapeInfo();
    Nd4jLong *scalarColumnAssertion = shape::createScalarShapeInfo();
    scalarColumnAssertion[shape::shapeInfoLength(2) - 3] = 1;
    Nd4jLong *scalarColumnTest = shape::sliceOfShapeBuffer(1L,colVectorShapeInfo);
    EXPECT_TRUE(arrsEquals(2,scalarColumnAssertion,scalarColumnTest));

    delete[] scalarColumnTest;
    delete[] scalarColumnAssertion;
    delete[] scalarSliceInfo;
    delete[] sliceRow;
    delete[] rowVectorShapeInfo;
    delete[] colVectorShapeInfo;
}

TEST_F(SliceTensorTest,TestSlice) {
    Nd4jLong shape[3] = {3,3,2};
    auto shapeBuffer  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);
    Nd4jLong sliceShape[2] = {3,2};
    auto sliceShapeBuffer  = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, sliceShape);
    Nd4jLong *testSlice = shape::sliceOfShapeBuffer(0,shapeBuffer);
    EXPECT_TRUE(arrsEquals(2,sliceShapeBuffer,testSlice));
    delete[] testSlice;
    delete[] shapeBuffer;
    delete[] sliceShapeBuffer;

}

TEST_F(SliceMatrixTest,TestSlice) {
    Nd4jLong shape[2] = {3,2};
    auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, shape);
    Nd4jLong sliceShape[2] = {1,2};
    auto sliceShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, sliceShape);
    Nd4jLong *testSlice = shape::sliceOfShapeBuffer(0,shapeBuffer);
    EXPECT_TRUE(arrsEquals(2,sliceShapeBuffer,testSlice));
    delete[] testSlice;
    delete[] shapeBuffer;
    delete[] sliceShapeBuffer;

}


TEST_F(TestConcat,ConcatTest) {
    Nd4jLong firstArr[2] = {1,2};
    Nd4jLong secondConcat[2] = {3,4};
    Nd4jLong concatAssertion[4] = {1,2,3,4};
    Nd4jLong *concatTest = shape::concat(firstArr,2,secondConcat,2);
    EXPECT_TRUE(arrsEquals(4,concatAssertion,concatTest));
    delete[] concatTest;
}

TEST_F(TestReverseCopy,ReverseCopyTest) {
    Nd4jLong toCopy[5] = {0,1,2,3,4};
    Nd4jLong reverseAssertion[5] = {4,3,2,1,0};
    Nd4jLong *reverseCopyTest = shape::reverseCopy(toCopy,5);
    EXPECT_TRUE(arrsEquals(5,reverseAssertion,reverseCopyTest));
    delete[] reverseCopyTest;
}

TEST_F(TestRemoveIndex,Remove) {
    Nd4jLong input[5] = {0,1,2,3,4};
    Nd4jLong indexesToRemove[3] = {0,1,2};
    Nd4jLong indexesToRemoveAssertion[2] = {3,4};
    Nd4jLong *indexesToRemoveTest = shape::removeIndex<Nd4jLong>(input,indexesToRemove, (Nd4jLong) 5, (Nd4jLong) 3);
    EXPECT_TRUE(arrsEquals(2,indexesToRemoveAssertion,indexesToRemoveTest));
    delete[] indexesToRemoveTest;
}

TEST_F(TensorTwoFromFourDDimTest,TadTwoFromFourDimTest) {
    //Along dimension 0,1: expect matrix with shape [rows,cols]
    //Along dimension 0,2: expect matrix with shape [rows,dim2]
    //Along dimension 0,3: expect matrix with shape [rows,dim3]
    //Along dimension 1,2: expect matrix with shape [cols,dim2]
    //Along dimension 1,3: expect matrix with shape [cols,dim3]
    //Along dimension 2,3: expect matrix with shape [dim2,dim3]
    auto baseShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 4, shape);
    for(int i = 0; i <  3; i++) {
        int *dimArr = dims[i];
        Nd4jLong *expectedShape = expectedShapes[i];
        shape::TAD *tad = new shape::TAD;
        tad->init(baseShapeBuffer,dimArr,dimensionLength);
        auto expectedShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', dimensionLength, expectedShape);
        tad->createTadOnlyShapeInfo();
        Nd4jLong *testShapeBuffer = tad->tadOnlyShapeInfo;
        EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedShape,shape::shapeOf(testShapeBuffer)));
        EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedStrides[i],shape::stride(testShapeBuffer)));

        delete[] expectedShapeBuffer;
        delete tad;
    }

    delete[] baseShapeBuffer;
}

TEST_F(TensorTwoDimTest,TadTwoDimTest) {
    //Along dimension 0,1: expect matrix with shape [rows,cols]
    //Along dimension 0,2: expect matrix with shape [rows,dim2]
    //Along dimension 1,2: expect matrix with shape [cols,dim2]
    auto baseShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 3, shape);

    for(int i = 0; i <  3; i++) {
        int *dimArr = dims[i];
        Nd4jLong *expectedShape = expectedShapes[i];
        shape::TAD *tad = new shape::TAD;
        tad->init(baseShapeBuffer,dimArr,dimensionLength);
        auto expectedShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', dimensionLength, expectedShape);
        tad->createTadOnlyShapeInfo();
        Nd4jLong *testShapeBuffer = tad->tadOnlyShapeInfo;
        Nd4jLong *expectedStride = expectedStrides[i];
        Nd4jLong *testShape = shape::shapeOf(testShapeBuffer);
        Nd4jLong *testStride = shape::stride(testShapeBuffer);
        EXPECT_TRUE(arrsEquals(shape::rank(expectedShapeBuffer),expectedShape,testShape));
        EXPECT_TRUE(arrsEquals(shape::rank(testShapeBuffer),expectedStride,testStride));

        delete[] expectedShapeBuffer;
        delete tad;

    }

    delete[] baseShapeBuffer;


}

TEST_F(TensorOneDimTest,TadDimensionsForTensor) {
    Nd4jLong shape[3] = {rows,cols,dim2};
    auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', rank, shape);

    for(int i = 0; i < rank; i++) {
        //Along dimension 0: expect row vector with length 'dims[i]'
        shape::TAD *zero = new shape::TAD;
        zero->init(shapeBuffer,&dims[i],1);
        zero->createTadOnlyShapeInfo();
        Nd4jLong *testDimZeroShapeBuffer = zero->tadOnlyShapeInfo;
        Nd4jLong *testShape = shape::shapeOf(testDimZeroShapeBuffer);
        Nd4jLong *testStride = shape::stride(testDimZeroShapeBuffer);
        EXPECT_TRUE(arrsEquals(2,expectedShapes[i],testShape));
        EXPECT_TRUE(arrsEquals(2,expectedStrides[i],testStride));

        delete zero;
    }

    delete[] shapeBuffer;
}


TEST_F(MatrixTest,TadDimensionsForMatrix) {
    Nd4jLong shape[2] = {rows,cols};
    auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', rank, shape);

    shape::TAD *dimZero = new shape::TAD;
    dimZero->init(shapeBuffer,&dims[0],1);
    shape::TAD *dimOne = new shape::TAD;
    dimOne->init(shapeBuffer,&dims[1],1);
    //Along dimension 0: expect row vector with length 'rows'
    Nd4jLong rowVectorShape[2] = {1,rows};
    auto expectedDimZeroShape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorShape);
    dimZero->createTadOnlyShapeInfo();
    Nd4jLong *testDimZero = dimZero->tadOnlyShapeInfo;
    EXPECT_TRUE(arrsEquals(2,expectedShapes[0],shape::shapeOf(testDimZero)));
    EXPECT_TRUE(arrsEquals(2,expectedStrides[0],shape::stride(testDimZero)));

    delete[] expectedDimZeroShape;
    //Along dimension 1: expect row vector with length 'cols'
    Nd4jLong rowVectorColShape[2] {1,cols};
    auto expectedDimOneShape = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVectorColShape);
    dimOne->createTadOnlyShapeInfo();
    Nd4jLong *testDimOneShape = dimOne->tadOnlyShapeInfo;
    EXPECT_TRUE(arrsEquals(2,expectedShapes[1],shape::shapeOf(testDimOneShape)));
    EXPECT_TRUE(arrsEquals(2,expectedStrides[1],shape::stride(testDimOneShape)));

    delete[] expectedDimOneShape;
    delete dimOne;
    delete dimZero;
    delete[] shapeBuffer;
}

TEST_F(VectorTest,VectorTadShape) {
    Nd4jLong rowVector[2] = {2,2};
    auto rowBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, rowVector);
    int rowDimension = 1;

    Nd4jLong columnVector[2] = {2,2};
    auto colShapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, columnVector);
    int colDimension = 0;


    shape::TAD *rowTad = new shape::TAD;
    rowTad->init(rowBuffer,&rowDimension,1);
    rowTad->createTadOnlyShapeInfo();
    Nd4jLong *rowTadShapeBuffer = rowTad->tadOnlyShapeInfo;
    Nd4jLong *rowTadShape = shape::shapeOf(rowTadShapeBuffer);
    shape::TAD *colTad = new shape::TAD;
    colTad->init(colShapeBuffer,&colDimension,1);
    colTad->createTadOnlyShapeInfo();
    Nd4jLong *colTadShapeBuffer = colTad->tadOnlyShapeInfo;
    Nd4jLong *colTadShape = shape::shapeOf(colTadShapeBuffer);
    Nd4jLong assertionShape[2] = {1,2};
    Nd4jLong assertionStride[2] = {1,1};
    EXPECT_TRUE(arrsEquals(2,assertionShape,rowTadShape));
    EXPECT_TRUE(arrsEquals(2,assertionStride,shape::stride(rowTadShapeBuffer)));
    EXPECT_TRUE(arrsEquals(2,assertionShape,colTadShape));

    delete[] rowBuffer;
    delete[] colShapeBuffer;
    delete rowTad;
    delete colTad;
}




TEST_F(ShapeTest,IsVector) {
    ASSERT_TRUE(shape::isVector(vectorShape,2));
}

TEST_F(VectorTest,LinspaceCombinationTest) {
    int rows = 3;
    int cols = 4;
    int len = rows * cols;
    double *linspaced = linspace<double>(1,rows * cols,len);
    Nd4jLong shape[2] = {rows,cols};
    auto shapeBuffer = sd::ShapeBuilders::createShapeInfo(sd::DataType::FLOAT32, 'c', 2, shape);

    delete[] shapeBuffer;
    delete[] linspaced;
}