#include "gtest/gtest.h"
#include "pibytearray.h"
#include "pistring.h"
#include "pideque.h"
#include "piflags.h"

using namespace std;

TEST(PIByteArray_Tests, construct_empty_BA){
    PIByteArray arr;
    ASSERT_TRUE(arr.isEmpty());
}

TEST(PIByteArray_Tests, construct_BA_size){
    PIByteArray arr(5);
    ASSERT_EQ(arr.size(), 5);
}

TEST(PIByteArray_Tests, construct_BA){
    PIString str = "new";
    const PIByteArray arr1 = str.toByteArray();
    PIByteArray res = str.toByteArray();
    PIByteArray arr(arr1);

    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, construct_BA_not_const){
    PIString str = "big";
    PIByteArray arr1 = str.toByteArray();
    PIByteArray res = str.toByteArray();
    PIByteArray arr(move(arr1));

    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, construct_BA_data_size){
    PIByteArray arr((void*)"new", 3);
    PIString str = "new";
    PIByteArray res = str.toByteArray();
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, construct_BA_size_char){
    uchar t = 'n';
    PIByteArray arr(3, t);
    PIString str = "nnn";
    PIByteArray res = str.toByteArray();
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, resized){
    PIByteArray arr(5);
    PIByteArray arr2 = arr.resized(3);
    ASSERT_EQ(arr.size(), 5);
    ASSERT_EQ(arr2.size(), 3);
}

TEST(PIByteArray_Tests, convert_to_base64){
    PIByteArray arr((void*)"PIP is great", 12);
    arr.convertToBase64();
    PIByteArray arr1(16);
    arr1[0] = 85;
    arr1[1] = 69;
    arr1[2] = 108;
    arr1[3] = 81;
    arr1[4] = 73;
    arr1[5] = 71;
    arr1[6] = 108;
    arr1[7] = 122;
    arr1[8] = 73;
    arr1[9] = 71;
    arr1[10] = 100;
    arr1[11] = 121;
    arr1[12] = 90;
    arr1[13] = 87;
    arr1[14] = 70;
    arr1[15] = 48;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, convert_to_base64_empty){
    PIByteArray arr;
    arr.convertToBase64();
    PIByteArray arr1;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, convert_from_base64){
    PIByteArray arr1(16);
    arr1[0] = 85;
    arr1[1] = 69;
    arr1[2] = 108;
    arr1[3] = 81;
    arr1[4] = 73;
    arr1[5] = 71;
    arr1[6] = 108;
    arr1[7] = 122;
    arr1[8] = 73;
    arr1[9] = 71;
    arr1[10] = 100;
    arr1[11] = 121;
    arr1[12] = 90;
    arr1[13] = 87;
    arr1[14] = 70;
    arr1[15] = 48;
    arr1.convertFromBase64();
    PIByteArray arr((void*)"PIP is great", 12);
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, convert_from_base64_empty){
    PIByteArray arr;
    arr.convertFromBase64();
    PIByteArray arr1;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, to_base64){
    PIByteArray arr((void*)"PIP is great", 12);
    PIByteArray arr2 = arr.toBase64();

    PIByteArray arr1(16);
    arr1[0] = 85;
    arr1[1] = 69;
    arr1[2] = 108;
    arr1[3] = 81;
    arr1[4] = 73;
    arr1[5] = 71;
    arr1[6] = 108;
    arr1[7] = 122;
    arr1[8] = 73;
    arr1[9] = 71;
    arr1[10] = 100;
    arr1[11] = 121;
    arr1[12] = 90;
    arr1[13] = 87;
    arr1[14] = 70;
    arr1[15] = 48;

    ASSERT_EQ(arr2, arr1);
}

TEST(PIByteArray_Tests, to_base64_immutability){
    PIByteArray arr((void*)"PIP is great", 12);
    PIByteArray old((void*)"PIP is great", 12);
    PIByteArray arr2 = arr.toBase64();
    ASSERT_EQ(arr, old);
}

TEST(PIByteArray_Tests, to_base64_empty){
    PIByteArray arr;
    arr.toBase64();
    PIByteArray arr1;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, compress_rle){
    PIByteArray arr((void*)"nnnnew", 6);
    arr.compressRLE(15);
    PIByteArray res(6);
    res[0] = 19;
    res[1] = 110;
    res[2] = 16;
    res[3] = 101;
    res[4] = 16;
    res[5] = 119;
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, decompress_rle){
    PIByteArray arr(4);
    arr[0] = 17;
    arr[1] = 110;
    arr[2] = 16;
    arr[3] = 101;
    arr.decompressRLE(15);
    PIByteArray res((void*)"nne", 3);
    ASSERT_EQ(arr, res);

}

TEST(PIByteArray_Tests, compress_rle_point){
    PIByteArray arr((void*)"nnnnew", 6);
    PIByteArray arr1 = arr.compressedRLE(15);
    PIByteArray res(6);
    res[0] = 19;
    res[1] = 110;
    res[2] = 16;
    res[3] = 101;
    res[4] = 16;
    res[5] = 119;
    ASSERT_EQ(arr1, res);
}

TEST(PIByteArray_Tests, compress_rle_point_immutability){
    PIByteArray arr((void*)"nnnnew", 6);
    PIByteArray arr2((void*)"nnnnew", 6);
    PIByteArray arr1 = arr.compressedRLE(15);
    ASSERT_EQ(arr, arr2);
}

TEST(PIByteArray_Tests, decompress_rle_point){
    PIByteArray arr(4);
    arr[0] = 17;
    arr[1] = 110;
    arr[2] = 16;
    arr[3] = 101;
    PIByteArray arr1 = arr.decompressedRLE(15);
    PIByteArray res((void*)"nne", 3);
    ASSERT_EQ(arr1, res);

}

TEST(PIByteArray_Tests, decompress_rle_point_immutability){
    PIByteArray arr(4);
    arr[0] = 17;
    arr[1] = 110;
    arr[2] = 16;
    arr[3] = 101;
    PIByteArray arr2(4);
    arr2[0] = 17;
    arr2[1] = 110;
    arr2[2] = 16;
    arr2[3] = 101;
    PIByteArray arr1 = arr.decompressedRLE(15);
    ASSERT_EQ(arr, arr2);
}

TEST(PIByteArray_Tests, to_string){
    PIByteArray arr((void*)"new", 3);
    PIString str = arr.toString();
    PIString res = "0x6E 0x65 0x77";
    ASSERT_EQ(res, str);
}


TEST(PIByteArray_Tests, to_string_10){
    PIByteArray arr((void*)"new", 3);
    PIString str = arr.toString(10);
    PIString res = "110 101 119";
    ASSERT_EQ(res, str);
}

TEST(PIByteArray_Tests, to_string_2){
    PIByteArray arr((void*)"new", 3);
    PIString str = arr.toString(2);
    PIString res = "b1101110 b1100101 b1110111";
    ASSERT_EQ(res, str);
}

TEST(PIByteArray_Tests, to_string_8){
    PIByteArray arr((void*)"new", 3);
    PIString str = arr.toString(8);
    PIString res = "0156 0145 0167";
    ASSERT_EQ(res, str);
}

TEST(PIByteArray_Tests, to_hex){
    PIByteArray arr(1);
    arr[0] = 15;
    PIString str = arr.toHex();
    PIString res = "0f";
    ASSERT_EQ(res, str);
}

TEST(PIByteArray_Tests, append){
    PIByteArray arr((void*)"n", 1);
    PIByteArray arr1((void*)"new", 3);
    arr.append((void*)"ew", 2);
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, append_BA){
    PIByteArray arr((void*)"n", 1);
    const PIByteArray arr1((void*)"ew", 2);
    PIByteArray arr2((void*)"new", 3);
    arr.append(arr1);
    ASSERT_EQ(arr, arr2);
}

TEST(PIByteArray_Tests, append_uchar){
    PIByteArray arr((void*)"ne", 2);
    PIByteArray arr2((void*)"new", 3);
    arr.append('w');
    ASSERT_EQ(arr, arr2);
}

TEST(PIByteArray_Tests, checksum_plain8){
    PIByteArray arr((void*)"new", 3);
    ASSERT_EQ(180, arr.checksumPlain8());
}

TEST(PIByteArray_Tests, checksum_plain32){
    PIByteArray arr((void*)"new", 3);
    ASSERT_EQ(4294966625, arr.checksumPlain32());
}

TEST(PIByteArray_Tests, hash){
    PIByteArray arr((void*)"new", 3);
    ASSERT_EQ(422208903, arr.hash());
}

TEST(PIByteArray_Tests, assignment_operator){
    PIByteArray arr(3);
    PIDeque<uchar> deq;
    deq.append('n');
    deq.append('e');
    deq.append('w');

    arr = deq;
    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(arr, res);

}

TEST(PIByteArray_Tests, assignment_operator_ba){
    PIByteArray arr(3);
    const PIByteArray arr1((void*)"new", 3);

    arr = arr1;

    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, assignment_operator_ba_nconst){
    PIByteArray arr(3);
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr2;

    arr = move(arr1);

    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, from_user_input){
    PIByteArray arr;
    ASSERT_EQ(10, arr.fromUserInput(" \n \t10")[0]);
}

TEST(PIByteArray_Tests, from_user_input_hex){
    PIByteArray arr;
    ASSERT_EQ(16, arr.fromUserInput(" \n \t0x10")[0]);
}

TEST(PIByteArray_Tests, from_hex){
    PIByteArray arr;
    ASSERT_EQ(15, arr.fromHex("0xF")[0]);
}

TEST(PIByteArray_Tests, from_base64_ba){
    PIByteArray arr1(4);
    arr1[0] = 98;
    arr1[1] = 109;
    arr1[2] = 86;
    arr1[3] = 51;
    PIByteArray arr = PIByteArray::fromBase64(arr1);
    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(arr, res);

}

TEST(PIByteArray_Tests, from_base64_pstr){
    PIByteArray arr = PIByteArray::fromBase64("new prog");
    PIByteArray res(6);
    res[0] = 157;
    res[1] = 236;
    res[2] = 0;
    res[3] = 166;
    res[4] = 186;
    res[5] = 32;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_compar){
    PIByteArray arr((void*)"new", 3);
    PIByteArray arr1((void*)"news", 4);
    ASSERT_TRUE(arr < arr1);
}

TEST(PIByteArray_Tests, operator_compar_false){
    PIByteArray arr((void*)"new", 3);
    PIByteArray arr1((void*)"news", 3);
    ASSERT_FALSE(arr < arr1);
}

TEST(PIByteArray_Tests, operator_shift_bool){
    PIByteArray arr1;
    bool v = true;
    arr1 << v;
    PIByteArray arr(1);
    arr[0] = 1;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_char){
    PIByteArray arr1;
    char v = 'n';
    arr1 << v;
    PIByteArray arr((void*)"n", 1);
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_uchar){
    PIByteArray arr1;
    uchar v = 'n';
    arr1 << v;
    PIByteArray arr((void*)"n", 1);
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_short){
    PIByteArray arr1;
    const short v = -1;
    arr1 << v;
    PIByteArray arr(2);
    arr[0] = 255;
    arr[1] = 255;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_int){
    PIByteArray arr1;
    const int v = -1;
    arr1 << v;
    PIByteArray arr(4);
    for (short i = 0; i < 4; i ++)  arr[i] = 255;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_long){
    PIByteArray arr1;
    const long v = -1;
    arr1 << v;
    PIByteArray arr(4);
    for (short i = 0; i < 4; i ++)  arr[i] = 255;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_llong){
    PIByteArray arr1;
    const llong v = -1;
    arr1 << v;
    PIByteArray arr(8);
    for (short i = 0; i < 8; i ++)  arr[i] = 255;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_ushort){
    PIByteArray arr1;
    const ushort v = 254;
    arr1 << v;
    PIByteArray arr(2);
    arr[0] = 254;
    arr[1] = 0;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_uint){
    PIByteArray arr1;
    const uint v = 254;
    arr1 << v;
    PIByteArray arr(4);
    arr[0] = 254;
    for (short i = 1; i < 4; i ++)  arr[i] = 0;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_ulong){
    PIByteArray arr1;
    const ulong v = 254;
    arr1 << v;
    PIByteArray arr(4);
    arr[0] = 254;
    for (short i = 1; i < 4; i ++)  arr[i] = 0;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_ullong){
    PIByteArray arr1;
    const ullong v = 254;
    arr1 << v;
    PIByteArray arr(8);
    arr[0] = 254;
    for (short i = 1; i < 8; i ++)  arr[i] = 0;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, operator_shift_float){
    PIByteArray arr1;
    const float v = 31.764;
    arr1 << v;
    PIByteArray arr(4);
    arr[0] = 172;
    arr[1] = 28;
    arr[2] = 254;
    arr[3] = 65;
    ASSERT_EQ(arr1, arr);
}

TEST(PIByteArray_Tests, operator_shift_double){
    PIByteArray arr1;
    const double v = 3341.76422;
    arr1 << v;
    PIByteArray arr(8);
    arr[0] = 230;
    arr[1] = 5;
    arr[2] = 216;
    arr[3] = 71;
    arr[4] = 135;
    arr[5] = 27;
    arr[6] = 170;
    arr[7] = 64;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, operator_shift_ldouble){
    PIByteArray arr1;
    const ldouble v = 334451.761422;
    arr1 << v;
    PIByteArray arr(16);
    arr[0] = 0;
    arr[1] = 144;
    arr[2] = 171;
    arr[3] = 145;
    arr[4] = 93;
    arr[5] = 120;
    arr[6] = 78;
    arr[7] = 163;
    arr[8] = 17;
    arr[9] = 64;
    arr[10] = 0;
    arr[11] = 0;
    arr[12] = 0;
    arr[13] = 0;
    arr[14] = 0;
    arr[15] = 0;
    ASSERT_EQ(arr, arr1);
}

TEST(PIByteArray_Tests, operator_shift_PIFlags){
    PIByteArray arr;
    PIFlags<short> testFlags = 65;
    arr << testFlags;
    PIByteArray res(4);
    res[0] = 65;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_shift_PIBA){
    PIByteArray arr;
    PIByteArray arr1((void*)"new", 3);
    arr << arr1;
    PIByteArray res(7);
    res[0] = 3;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 110;
    res[5] = 101;
    res[6] = 119;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_shift_RawData){
    PIByteArray arr((void*)"n", 1);
    PIByteArray::RawData dat((void*)"ew", 2);
    arr << dat;
    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, operator_shift_right_bool){
    PIByteArray arr(1);
    arr[0] = 1;
    bool v;
    arr >> v;
    ASSERT_EQ(v, true);
}

TEST(PIByteArray_Tests, operator_shift_right_char){
    PIByteArray arr((void*)"n", 1);
    char v;
    arr >> v;

    ASSERT_EQ(v, 'n');
}

TEST(PIByteArray_Tests, operator_shift_right_uchar){
    PIByteArray arr((void*)"n", 1);
    uchar v;
    arr >> v;
    ASSERT_EQ(v, 'n');
}

TEST(PIByteArray_Tests, operator_shift_right_short){
    PIByteArray arr(2);
    arr[0] = 255;
    arr[1] = 255;
    short v;
    arr >> v;
    ASSERT_EQ(v, -1);
}

TEST(PIByteArray_Tests, operator_shift_right_int){
    PIByteArray arr(4);
    for (short i = 0; i < 4; i ++)  arr[i] = 255;
    int v;
    arr >> v;
    ASSERT_EQ(v, -1);
}

TEST(PIByteArray_Tests, operator_shift_right_long){
    PIByteArray arr(4);
    for (short i = 0; i < 4; i ++)  arr[i] = 255;
    long v = -1;
    arr >> v;
    ASSERT_EQ(v, -1);
}

TEST(PIByteArray_Tests, operator_shift_right_llong){
    PIByteArray arr(8);
    for (short i = 0; i < 8; i ++)  arr[i] = 255;
    llong v = -1;
    arr >> v;
    ASSERT_EQ(v, -1);
}

TEST(PIByteArray_Tests, operator_shift_right_ushort){
    PIByteArray arr(2);
    arr[0] = 254;
    arr[1] = 0;
    ushort v = 254;
    arr >> v;
    ASSERT_EQ(v, 254);
}

TEST(PIByteArray_Tests, operator_shift_right_uint){
    PIByteArray arr(4);
    arr[0] = 254;
    for (short i = 1; i < 4; i ++)  arr[i] = 0;
    uint v;
    arr >> v;
    ASSERT_EQ(v, 254);
}

TEST(PIByteArray_Tests, operator_shift_right_ulong){
    PIByteArray arr(4);
    arr[0] = 254;
    for (short i = 1; i < 4; i ++)  arr[i] = 0;
    ulong v;
    arr >> v;
    ASSERT_EQ(v, 254);
}

TEST(PIByteArray_Tests, operator_shift_right_ullong){
    PIByteArray arr(8);
    arr[0] = 254;
    for (short i = 1; i < 8; i ++)  arr[i] = 0;
    ullong v;
    arr >> v;
    ASSERT_EQ(v, 254);
}

TEST(PIByteArray_Tests, operator_shift_right_float){
    PIByteArray arr(4);
    arr[0] = 172;
    arr[1] = 28;
    arr[2] = 254;
    arr[3] = 65;
    float v;
    float res = 31.764;
    arr >> v;
    ASSERT_EQ(v, res);
}

TEST(PIByteArray_Tests, operator_shift_right_double){
    PIByteArray arr(7);
    const double res = 3341.76422;
    double v;
    arr[0] = 230;
    arr[1] = 5;
    arr[2] = 216;
    arr[3] = 71;
    arr[4] = 135;
    arr[5] = 27;
    arr[6] = 170;
    arr[7] = 64;
    arr >> v;
    ASSERT_EQ(v, res);
}

TEST(PIByteArray_Tests, operator_shift_right_ldouble){
    PIByteArray arr(16);
    const ldouble res = 334451.761422;
    ldouble v;
    arr[0] = 0;
    arr[1] = 144;
    arr[2] = 171;
    arr[3] = 145;
    arr[4] = 93;
    arr[5] = 120;
    arr[6] = 78;
    arr[7] = 163;
    arr[8] = 17;
    arr[9] = 64;
    arr[10] = 0;
    arr[11] = 0;
    arr[12] = 0;
    arr[13] = 0;
    arr[14] = 0;
    arr[15] = 0;
    arr >> v;
    ASSERT_EQ(v, res);
}

TEST(PIByteArray_Tests, operator_shift_right_PIFlags){
    PIFlags<short> testFlags;
    PIByteArray arr(4);
    arr[0] = 65;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr >> testFlags;
    PIFlags<short> res = 65;
    ASSERT_EQ(res, testFlags);
}

TEST(PIByteArray_Tests, operator_shift_right_PIBA){
    PIByteArray arr1;
    PIByteArray arr(7);
    arr[0] = 3;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 110;
    arr[5] = 101;
    arr[6] = 119;
    arr >> arr1;
    PIByteArray res((void*)"new", 3);
    ASSERT_EQ(res, arr1);
}

TEST(PIByteArray_Tests, operator_shift_right_RawData){
    PIByteArray arr((void*)"new", 3);
    PIByteArray::RawData dat;
    arr >> dat;
    PIByteArray::RawData res((void*)"new", 3);
    PIByteArray res_arr;
    res_arr << res;
    ASSERT_EQ(res_arr, arr);
}

TEST(PIByteArray_Tests, operator_shift_PIPair){
    PIByteArray arr;
    PIPair<int, bool> par;
    par.first = 43;
    par.second = true;
    arr << par;
    PIByteArray res(5);
    res[0] = 43;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 1;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_shift_PIVector){
    PIByteArray arr;
    PIVector<char> vect;
    vect.append('n');
    vect.append('e');
    vect.append('w');
    arr << vect;
    PIByteArray res(7);
    res[0] = 3;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 110;
    res[5] = 101;
    res[6] = 119;
    ASSERT_EQ(res, arr);

}

TEST(PIByteArray_Tests, operator_shift_PIDeque){
    PIByteArray arr;
    PIDeque<char> deq;
    deq.append('n');
    deq.append('e');
    deq.append('w');
    arr << deq;
    PIByteArray res(7);
    res[0] = 3;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 110;
    res[5] = 101;
    res[6] = 119;
    ASSERT_EQ(arr, res);

}

TEST(PIByteArray_Tests, operator_shift_PIMap){
    PIByteArray arr;
    PIMap<char, char> mp;
    mp['2'] = 'e';
    mp['1'] = 'n';
    mp['3'] = 'w';
    arr << mp;
    PIByteArray res(26);
    res[0] = 3; //size
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 1; //key index
    res[5] = 0;
    res[6] = 0;
    res[7] = 0;
    res[8] = 49; //key content
    res[9] = 0; //key index
    res[10] = 0;
    res[11] = 0;
    res[12] = 0;
    res[13] = 50; // key content
    res[14] = 2; //key index
    res[15] = 0;
    res[16] = 0;
    res[17] = 0;
    res[18] = 51; //key 3
    res[19] = 3; //number content
    res[20] = 0;
    res[21] = 0;
    res[22] = 0;
    res[23] = 101; //data 'e'
    res[24] = 110; //data 'n'
    res[25] = 119; //data 'w'
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, operator_shift_PIChar){
    PIByteArray arr;
    PIChar ch = "n";
    arr << ch;
    PIByteArray res(2);
    res[0] = 110;
    res[1] = 0;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_shift_right_PIPair){
    PIByteArray arr(5);
    arr[0] = 43;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 1;
    PIPair<int, bool> par;
    PIPair<int, bool> res;
    res.first = 43;
    res.second = true;
    arr >> par;
    ASSERT_EQ(res, par);
}

TEST(PIByteArray_Tests, operator_shift_right_PIVector){
    PIByteArray arr(7);
    arr[0] = 3;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 110;
    arr[5] = 101;
    arr[6] = 119;
    PIVector<char> vec;
    PIVector<char> vect;
    vect.append('n');
    vect.append('e');
    vect.append('w');
    arr >> vec;
    ASSERT_EQ(vec, vect);
}

TEST(PIByteArray_Tests, operator_shift_right_PIDeque){
    PIDeque<char> deq;
    PIByteArray arr1(7);
    arr1[0] = 3;
    arr1[1] = 0;
    arr1[2] = 0;
    arr1[3] = 0;
    arr1[4] = 110;
    arr1[5] = 101;
    arr1[6] = 119;
    arr1 >> deq;
    PIDeque<char> res;
    res.append('n');
    res.append('e');
    res.append('w');
    ASSERT_EQ(deq, res);
}

TEST(PIByteArray_Tests, operator_shift_right_PIMap){
    PIByteArray arr(26);
    arr[0] = 3; //size
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 1; //key index
    arr[5] = 0;
    arr[6] = 0;
    arr[7] = 0;
    arr[8] = 49; //key content
    arr[9] = 0; //key index
    arr[10] = 0;
    arr[11] = 0;
    arr[12] = 0;
    arr[13] = 50; // key content
    arr[14] = 2; //key index
    arr[15] = 0;
    arr[16] = 0;
    arr[17] = 0;
    arr[18] = 51; //key 3
    arr[19] = 3; //number content
    arr[20] = 0;
    arr[21] = 0;
    arr[22] = 0;
    arr[23] = 101; //data 'e'
    arr[24] = 110; //data 'n'
    arr[25] = 119; //data 'w'
    PIMap<char, char> mp;
    arr >> mp;
    PIMap<char, char> res;
    res['2'] = 'e';
    res['1'] = 'n';
    res['3'] = 'w';
    ASSERT_EQ(mp, res);
}

TEST(PIByteArray_Tests, operator_shift_right_PIChar){
    PIChar ch;
    PIByteArray arr(2);
    arr[0] = 110;
    arr[1] = 0;
    arr >> ch;
    PIChar res = "n";
    ASSERT_EQ(res, ch);
}

TEST(PIByteArray_Tests, operator_shift_PIBitArr){
    PIBitArray bit(2);
    bit.setBit(0);
    bit.setBit(1);
    PIByteArray arr;
    arr << bit;
    PIByteArray res(9);
    res[0] = 2;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 1;
    res[5] = 0;
    res[6] = 0;
    res[7] = 0;
    res[8] = 3;
    ASSERT_EQ(res, arr);
}

TEST(PIByteArray_Tests, operator_shift_PIVector2D){
    PIByteArray arr;
    PIVector2D<char> vec2(2,3);
    vec2.element(0, 0) = 'n';
    vec2.element(0, 1) = 'e';
    vec2.element(0, 2) = 'w';
    vec2.element(1, 0) = 'o';
    vec2.element(1, 1) = 'l';
    vec2.element(1, 2) = 'd';
    arr << vec2;
    PIByteArray res(14);
    res[0] = 2;
    res[1] = 0;
    res[2] = 0;
    res[3] = 0;
    res[4] = 3;
    res[5] = 0;
    res[6] = 0;
    res[7] = 0;
    res[8] = 110;
    res[9] = 101;
    res[10] = 119;
    res[11] = 111;
    res[12] = 108;
    res[13] = 100;
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, operator_shift_right_PIBitArr){
    PIBitArray bit;
    PIByteArray arr(9);
    arr[0] = 2;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 1;
    arr[5] = 0;
    arr[6] = 0;
    arr[7] = 0;
    arr[8] = 3;
    arr >> bit;
    PIBitArray res(2);
    res.setBit(0);
    res.setBit(1);
    ASSERT_EQ(res, bit);
}

TEST(PIByteArray_Tests, operator_shift_right_PIVector2D){
    PIVector2D<char> vec2(2,3);
    PIByteArray arr(14);
    arr[0] = 2;
    arr[1] = 0;
    arr[2] = 0;
    arr[3] = 0;
    arr[4] = 3;
    arr[5] = 0;
    arr[6] = 0;
    arr[7] = 0;
    arr[8] = 110;
    arr[9] = 101;
    arr[10] = 119;
    arr[11] = 111;
    arr[12] = 108;
    arr[13] = 100;
    arr >> vec2;
    PIVector2D<char> res(2,3);
    res.element(0, 0) = 'n';
    res.element(0, 1) = 'e';
    res.element(0, 2) = 'w';
    res.element(1, 0) = 'o';
    res.element(1, 1) = 'l';
    res.element(1, 2) = 'd';
    ASSERT_EQ(vec2.element(0,0), res.element(0,0));
    ASSERT_EQ(vec2.element(0,1), res.element(0,1));
    ASSERT_EQ(vec2.element(0,2), res.element(0,2));
    ASSERT_EQ(vec2.element(1,0), res.element(1,0));
    ASSERT_EQ(vec2.element(1,1), res.element(1,1));
    ASSERT_EQ(vec2.element(1,2), res.element(1,2));
}

TEST(PIByteArray_Tests, operator_shift_template){
    PIByteArray arr;
    char ch = 'n';
    arr << ch;
    PIByteArray res(1);
    res[0] = 110;
    ASSERT_EQ(arr, res);
}

TEST(PIByteArray_Tests, operator_shift_right_template){
    PIByteArray arr(1);
    arr[0] = 110;
    char ch;
    arr >> ch;
    char res = 'n';
    ASSERT_EQ(ch, res);
}

TEST(PIByteArray_Tests, operator_equality){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 119;
    ASSERT_TRUE(arr1 == arr);
}

TEST(PIByteArray_Tests, operator_not_equality){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 11;
    ASSERT_TRUE(arr1 != arr);
}

TEST(PIByteArray_Tests, operator_equality_size){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(2);
    arr[0] = 110;
    arr[1] = 101;
    ASSERT_FALSE(arr1 == arr);
}

TEST(PIByteArray_Tests, operator_not_equality_size){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(2);
    arr[0] = 110;
    arr[1] = 101;
    ASSERT_TRUE(arr1 != arr);
}

TEST(PIByteArray_Tests, operator_equality_false){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 11;
    ASSERT_FALSE(arr1 == arr);

}

TEST(PIByteArray_Tests, operator_not_equality_false){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 119;
    ASSERT_FALSE(arr1 != arr);

}

TEST(PIByteArray_Tests, pi_hash){
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 119;
    ASSERT_EQ(piHash(arr), 422208903);

}

TEST(PIByteArray_Tests, pi_swap){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr2((void*)"old", 3);
    piSwap(arr1, arr2);
    PIByteArray arr(3);
    arr[0] = 110;
    arr[1] = 101;
    arr[2] = 119;
    ASSERT_EQ(arr, arr2);
}

TEST(PIByteArray_Tests, pi_swap_sec){
    PIByteArray arr1((void*)"new", 3);
    PIByteArray arr2((void*)"old", 3);
    piSwap(arr1, arr2);
    PIByteArray arr(3);
    arr[0] = 111;
    arr[1] = 108;
    arr[2] = 100;
    ASSERT_EQ(arr, arr1);
}