Tests for PIByteArray

2020-09-29 17:37:22 +03:00
parent e3fc248cb6
commit 430272757e
2 changed files with 1140 additions and 2 deletions
--- a/tests/core/pibytearrayTest.cpp
+++ b/tests/core/pibytearrayTest.cpp
@@ -0,0 +1,1140 @@
+#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 old((void*)"PIP is great", 12);
+    PIByteArray arr2 = arr.toBase64();
+
+    ASSERT_EQ(arr, old);
+    ASSERT_NE(arr2, old);
+
+    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_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 arr2((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);
+    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 arr2(4);
+    arr2[0] = 17;
+    arr2[1] = 110;
+    arr2[2] = 16;
+    arr2[3] = 101;
+    PIByteArray arr1 = arr.decompressedRLE(15);
+    PIByteArray res((void*)"nne", 3);
+    ASSERT_EQ(arr1, res);
+    ASSERT_EQ(arr, arr2);
+}
+
+TEST(PIByteArray_Tests, to_string){
+    PIByteArray arr((void*)"new", 3);
+    PIString str = arr.toString();
+    PIString res = "0x6E 0x65 0x77";
+    ASSERT_TRUE(res == str);
+}
+
+
+TEST(PIByteArray_Tests, to_string_10){
+    PIByteArray arr((void*)"new", 3);
+    PIString str = arr.toString(10);
+    PIString res = "110 101 119";
+    ASSERT_TRUE(res == str);
+}
+
+TEST(PIByteArray_Tests, to_string_2){
+    PIByteArray arr((void*)"new", 3);
+    PIString str = arr.toString(2);
+    PIString res = "b1101110 b1100101 b1110111";
+    ASSERT_TRUE(res == str);
+}
+
+TEST(PIByteArray_Tests, to_string_8){
+    PIByteArray arr((void*)"new", 3);
+    PIString str = arr.toString(8);
+    PIString res = "0156 0145 0167";
+    ASSERT_TRUE(res == str);
+}
+
+TEST(PIByteArray_Tests, to_hex){
+    PIByteArray arr(1);
+    arr[0] = 15;
+    PIString str = arr.toHex();
+    PIString res = "0f";
+    ASSERT_TRUE(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_TRUE(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_TRUE(vec2.element(0,0) == res.element(0,0) &&
+                vec2.element(0,1) == res.element(0,1) &&
+                vec2.element(0,2) == res.element(0,2) &&
+                vec2.element(1,0) == res.element(1,0) &&
+                vec2.element(1,1) == res.element(1,1) &&
+                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);
+}
--- a/tests/core/pistringTest.cpp
+++ b/tests/core/pistringTest.cpp
@@ -2,8 +2,6 @@
 #include "pistring.h"
 #include "pistringlist.h"

-using namespace std;
-
 TEST(PIString_Tests, operator_concatenation_pichar){
    PIString str1 = "AB C";
    const PIChar str2 = " ";