From c3abd747f2bad7a2419b646447728e122727dcbf Mon Sep 17 00:00:00 2001
From: maakshishov <shishov1101@gmail.com>
Date: Thu, 17 Sep 2020 17:07:29 +0300
Subject: [PATCH] PIMathVector Tests and bug fixes in PIMathMatrixT

---
 tests/CMakeLists.txt             |    2 +-
 tests/core/pistringTest.cpp      | 2978 ------------------------------
 tests/math/testpimathmatrix.cpp  |  145 +-
 tests/math/testpimathmatrixt.cpp |   12 +-
 tests/math/testpimathvector.cpp  |  364 ++++
 tests/math/testpimathvectort.cpp |  427 +++++
 6 files changed, 870 insertions(+), 3058 deletions(-)
 delete mode 100644 tests/core/pistringTest.cpp
 create mode 100644 tests/math/testpimathvector.cpp
 create mode 100644 tests/math/testpimathvectort.cpp

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 68c51388..07693426 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -17,4 +17,4 @@ endmacro()
 # Concurrent tests
 pip_test(concurrent "")
 pip_test(math "")
-pip_test(core "")
+#pip_test(core "")
diff --git a/tests/core/pistringTest.cpp b/tests/core/pistringTest.cpp
deleted file mode 100644
index 900b2cfd..00000000
--- a/tests/core/pistringTest.cpp
+++ /dev/null
@@ -1,2978 +0,0 @@
-#include "gtest/gtest.h"
-#include "pistring.h"
-#include "pistringlist.h"
-
-using namespace std;
-
-TEST(PIString_Tests, operator_concatenation_pichar){
-    PIString str1 = "AB C";
-    const PIChar str2 = " ";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB C ");
-}
-
-TEST(PIString_Tests, operator_concatenation_pichar_zero1){
-    PIString str1 = "";
-    const PIChar str2 = "D";
-    str1 += str2;
-    ASSERT_STREQ(str1, "D");
-}
-
-TEST(PIString_Tests, operator_concatenation_pichar_zero2){
-    PIString str1 = "AB C";
-    const PIChar str2 = "";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB C");
-}
-
-TEST(PIString_Tests, operator_concatenation_pichar_zero_zero){
-    PIString str1;
-    const PIChar str2;
-    str1 += str2;
-    ASSERT_STREQ(str1, "");
-}
-
-TEST(PIString_Tests, operator_concatenation_char){
-    PIString str1 = "AB C";
-    const char *str2 = "D D ";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB CD D ");
-}
-
-TEST(PIString_Tests, operator_concatenation_char_zero1){
-    PIString str1 = "";
-    const char *str2 = "D D ";
-    str1 += str2;
-    ASSERT_STREQ(str1, "D D ");
-}
-
-TEST(PIString_Tests, operator_concatenation_wchar){
-    PIString str1= "AB C";
-    wchar_t str2[] = L"C";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB CC");
-}
-
-TEST(PIString_Tests, operator_concatenation_wchar_zero1){
-    PIString str1 = "";
-    wchar_t str2[] = L"C";
-    str1 += str2;
-    ASSERT_STREQ(str1, "C");
-}
-
-TEST(PIString_Tests, operator_concatenation_pistring){
-    PIString str1 = "AB C";
-    PIString str2 = " CD  ";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB C CD  ");
-}
-
-TEST(PIString_Tests, operator_concatenation_pistring_zero1){
-    PIString str1 = "";
-    PIString str2 = "D DD";
-    str1 += str2;
-    ASSERT_STREQ(str1, "D DD");
-}
-
-TEST(PIString_Tests, operator_concatenation_pistring_zero2){
-    PIString str1 = "AB C";
-    PIString str2 = "";
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB C");
-}
-
-TEST(PIString_Tests, operator_concatenation_pistring_zero_zero){
-    PIString str1;
-    PIString str2;
-    str1 += str2;
-    ASSERT_STREQ(str1, "");
-}
-
-TEST(PIString_Tests, operator_concatenation_piByteArray){
-    PIString str1 = "AB C";
-    PIByteArray str2;
-    str2.append('g');
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB Cg");
-}
-
-TEST(PIString_Tests, operator_concatenation_piByteArray_zero1){
-    PIString str1 = "";
-    PIByteArray str2;
-    str2.append('0');
-    str1 += str2;
-    ASSERT_STREQ(str1, "0");
-}
-
-TEST(PIString_Tests, operator_concatenation_piByteArray_zero2){
-    PIString str1 = "AB C";
-    PIByteArray str2;
-    str1 += str2;
-    ASSERT_STREQ(str1, "AB C");
-}
-
-TEST(PIString_Tests, operator_concatenation_piByteArray_zero_zero){
-    PIString str1;
-    PIByteArray str2;
-    str1 += str2;
-    ASSERT_STREQ(str1, "");
-}
-
-TEST(PIString_Tests, construct_pistring){
-    PIString str1 = "New";
-    ASSERT_STREQ(str1, PIString("New"));
-}
-
-TEST(PIString_Tests, construct_pichar){
-    PIChar str1 = 'n';
-    ASSERT_STREQ("n", PIString(str1));
-}
-
-TEST(PIString_Tests, construct_char){
-    char str1 = 'n';
-    ASSERT_STREQ("n", PIString(str1));
-}
-
-TEST(PIString_Tests, construct_chars){
-    char str1[] = "mew";
-    ASSERT_STREQ("mew", PIString(str1));
-}
-
-TEST(PIString_Tests, construct_wchar_t){
-    wchar_t str1[] = L"gav";
-    ASSERT_STREQ("gav", PIString(str1));
-}
-
-TEST(PIString_Tests, construct_pibyte_array){
-    PIByteArray str1;
-    str1.append('m');
-    ASSERT_STREQ("m", PIString(str1));
-}
-
-TEST(PIString_Tests, construct_pichar_size){
-    PIChar *str1 = new PIChar[3];
-    str1[0] = 'n';
-    str1[1] = 'e';
-    str1[2] = 'w';
-    ASSERT_STREQ("new", PIString(str1, 3));
-}
-
-TEST(PIString_Tests, construct_char_size){
-    char str1[] = "good";
-    ASSERT_STREQ("good", PIString(str1, 4));
-}
-
-TEST(PIString_Tests, construct_char_len){
-    char str1 = 'n';
-    ASSERT_STREQ("nnn", PIString(3, str1));
-}
-
-TEST(PIString_Tests, construct_pichar_len){
-    PIChar str1 = 'n';
-    ASSERT_STREQ("nnnnn", PIString(5, str1));
-}
-
-TEST(PIString_Tests, operator_pointer){
-    PIString str1 = "testing";
-    const char *point = str1.operator const char *();
-    ASSERT_STREQ("testing", point);
-}
-
-TEST(PIString_Tests, operator_symbol){
-    PIString str1 = "testing";
-    PIChar symbo = "i";
-    ASSERT_EQ(symbo, str1[4]);
-}
-
-TEST(PIString_Tests, operator_compare_pistring_true){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_compare_pistring_false){
-    PIString str1 = "tes";
-    PIString str2 = "testing";
-    ASSERT_FALSE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_compare_pichar_true){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_TRUE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_compare_pichar_false){
-    PIString str1 = "t";
-    PIChar str2 = "p";
-    ASSERT_FALSE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_compare_char_true){
-    PIString str1 = "test";
-    char str2[] = "test";
-    ASSERT_TRUE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_compare_char_false){
-    PIString str1 = "t";
-    char str2[] = "test";
-    ASSERT_FALSE(str1 == str2);
-}
-
-TEST(PIString_Tests, operator_encompare_pistring_false){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_FALSE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_encompare_pistring_true){
-    PIString str1 = "tes";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_encompare_pichar_false){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_FALSE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_encompare_pichar_true){
-    PIString str1 = "t";
-    PIChar str2 = "p";
-    ASSERT_TRUE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_encompare_char_false){
-    PIString str1 = "test";
-    char str2[] = "test";
-    ASSERT_FALSE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_encompare_char_true){
-    PIString str1 = "t";
-    char str2[] = "test";
-    ASSERT_TRUE(str1 != str2);
-}
-
-TEST(PIString_Tests, operator_less_pistring_true){
-    PIString str1 = "testin";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_pistring_false){
-    PIString str1 = "testing";
-    PIString str2 = "testin";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_pistring_false_equal){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_pichar_true){
-    PIString str1 = "a";
-    PIChar str2 = "t";
-    ASSERT_TRUE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_pichar_false){
-    PIString str1 = "t";
-    PIChar str2 = "a";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_pichar_false_equal){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_char_true){
-    PIString str1 = "a";
-    char str2[] = "t";
-    ASSERT_TRUE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_char_false){
-    PIString str1 = "t";
-    char str2[] = "a";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_less_char_false_equal){
-    PIString str1 = "t";
-    char str2[] = "t";
-    ASSERT_FALSE(str1 < str2);
-}
-
-TEST(PIString_Tests, operator_more_pistring_true){
-    PIString str1 = "testin";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str2 > str1);
-}
-
-TEST(PIString_Tests, operator_more_pistring_false){
-    PIString str1 = "testing";
-    PIString str2 = "testin";
-    ASSERT_FALSE(str2 > str1);
-}
-
-TEST(PIString_Tests, operator_more_pistring_false_equal){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_FALSE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_pichar_true){
-    PIString str1 = "t";
-    PIChar str2 = "a";
-    ASSERT_TRUE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_pichar_false){
-    PIString str1 = "a";
-    PIChar str2 = "t";
-    ASSERT_FALSE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_pichar_false_equal){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_FALSE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_char_true){
-    PIString str1 = "t";
-    char str2[] = "a";
-    ASSERT_TRUE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_char_false){
-    PIString str1 = "a";
-    char str2[] = "t";
-    ASSERT_FALSE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_more_char_false_equal){
-    PIString str1 = "t";
-    char str2[] = "t";
-    ASSERT_FALSE(str1 > str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_pistring_true){
-    PIString str1 = "testin";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_pistring_false){
-    PIString str1 = "testing";
-    PIString str2 = "testin";
-    ASSERT_FALSE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_pistring_true_equal){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_pichar_true){
-    PIString str1 = "a";
-    PIChar str2 = "t";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_pichar_false){
-    PIString str1 = "t";
-    PIChar str2 = "a";
-    ASSERT_FALSE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_pichar_true_equal){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_char_true){
-    PIString str1 = "a";
-    char str2[] = "t";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_char_false){
-    PIString str1 = "t";
-    char str2[] = "a";
-    ASSERT_FALSE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_less_eq_char_true_equal){
-    PIString str1 = "t";
-    char str2[] = "t";
-    ASSERT_TRUE(str1 <= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_pistring_true){
-    PIString str1 = "testin";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str2 >= str1);
-}
-
-TEST(PIString_Tests, operator_more_eq_pistring_false){
-    PIString str1 = "testing";
-    PIString str2 = "testin";
-    ASSERT_FALSE(str2 >= str1);
-}
-
-TEST(PIString_Tests, operator_more_eq_pistring_true_equal){
-    PIString str1 = "testing";
-    PIString str2 = "testing";
-    ASSERT_TRUE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_pichar_true){
-    PIString str1 = "t";
-    PIChar str2 = "a";
-    ASSERT_TRUE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_pichar_false){
-    PIString str1 = "a";
-    PIChar str2 = "t";
-    ASSERT_FALSE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_pichar_true_equal){
-    PIString str1 = "t";
-    PIChar str2 = "t";
-    ASSERT_TRUE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_char_true){
-    PIString str1 = "t";
-    char str2[] = "a";
-    ASSERT_TRUE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_char_false){
-    PIString str1 = "a";
-    char str2[] = "t";
-    ASSERT_FALSE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_more_eq_char_true_equal){
-    PIString str1 = "t";
-    char str2[] = "t";
-    ASSERT_TRUE(str1 >= str2);
-}
-
-TEST(PIString_Tests, operator_shift_pistring){
-    PIString str1 = "shift";
-    PIString str2 = " good";
-    str1 << str2;
-    ASSERT_STREQ("shift good", str1);
-}
-
-TEST(PIString_Tests, operator_shift_pichar){
-    PIString str1 = "shif";
-    PIChar str2 = 't';
-    str1 << str2;
-    ASSERT_STREQ("shift", str1);
-}
-
-TEST(PIString_Tests, operator_shift_char){
-    PIString str1 = "shif";
-    char str2[] = "t chat";
-    str1 << str2;
-    ASSERT_STREQ("shift chat", str1);
-}
-
-TEST(PIString_Tests, operator_shift_wchar_t){
-    PIString str1 = "shif";
-    wchar_t str2[] = L"t cc";
-    str1 << str2;
-    ASSERT_STREQ("shift cc", str1);
-}
-
-TEST(PIString_Tests, operator_shift_int){
-    PIString str1 = "shift ";
-    int numb = -2147483648;
-    str1 << numb;
-    ASSERT_STREQ("shift -2147483648", str1);
-}
-
-TEST(PIString_Tests, operator_shift_uint){
-    PIString str1 = "shift ";
-    uint numb = 4294967295;
-    str1 << numb;
-    ASSERT_STREQ("shift 4294967295", str1);
-}
-
-TEST(PIString_Tests, operator_shift_short){
-    PIString str1 = "shift ";
-    short numb = -32768;
-    str1 << numb;
-    ASSERT_STREQ("shift -32768", str1);
-}
-
-TEST(PIString_Tests, operator_shift_ushort){
-    PIString str1 = "shift ";
-    ushort numb = 65535;
-    str1 << numb;
-    ASSERT_STREQ("shift 65535", str1);
-}
-
-TEST(PIString_Tests, operator_shift_long){
-    PIString str1 = "shift ";
-    long numb = -2147483648;
-    str1 << numb;
-    ASSERT_STREQ("shift -2147483648", str1);
-}
-
-TEST(PIString_Tests, operator_shift_ulong){
-    PIString str1 = "shift ";
-    ulong numb = 4294967295;
-    str1 << numb;
-    ASSERT_STREQ("shift 4294967295", str1);
-}
-
-TEST(PIString_Tests, operator_shift_llong){
-    PIString str1 = "shift ";
-    llong numb = -9223372036854775807;
-    str1 << numb;
-    ASSERT_STREQ("shift -9223372036854775807", str1);
-}
-
-TEST(PIString_Tests, operator_shift_ullong){
-    PIString str1 = "shift ";
-    ullong numb = 1844674407370955161;
-    str1 << numb;
-    ASSERT_STREQ("shift 1844674407370955161", str1);
-}
-
-TEST(PIString_Tests, operator_shift_float){
-    PIString str1 = "shift ";
-    float numb = -67.88999939;
-    str1 << numb;
-    ASSERT_STREQ("shift -67.88999939", str1);
-}
-
-TEST(PIString_Tests, operator_shift_double){
-    PIString str1 = "shift ";
-    double numb = 13.34300000;
-    str1 << numb;
-
-    ASSERT_STREQ("shift 13.34300000", str1);
-}
-
-TEST(PIString_Tests, prepend){
-    PIString str1 = "idea";
-    PIString str2 = "Good ";
-    str1.prepend(str2);
-    ASSERT_STREQ("Good idea", str1);
-}
-
-TEST(PIString_Tests, append){
-    PIString str1 = "Good";
-    PIString str2 = " idea";
-    str1.append(str2);
-    ASSERT_STREQ("Good idea", str1);
-}
-
-TEST(PIString_Tests, mid){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("fo", str1.mid(10, 2));
-}
-
-TEST(PIString_Tests, mid_len_0){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("", str1.mid(10, 0));
-}
-
-
-TEST(PIString_Tests, mid_start_more){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("", str1.mid(1000, 0));
-}
-
-TEST(PIString_Tests, mid_len_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("for new project 144", str1.mid(10, -2));
-}
-
-TEST(PIString_Tests, mid_len_more){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("for new project 144", str1.mid(10, 100));
-}
-
-TEST(PIString_Tests, subString){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("for new project 144", str1.mid(10, 46));
-}
-
-TEST(PIString_Tests, mid_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.mid(-10, 47));
-}
-
-TEST(PIString_Tests, subString_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Go", str1.mid(-10, 12));
-}
-
-TEST(PIString_Tests, left){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Go", str1.left(2));
-}
-
-TEST(PIString_Tests, left_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("", str1.left(-2));
-}
-
-TEST(PIString_Tests, right){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("44", str1.right(2));
-}
-
-TEST(PIString_Tests, right_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("", str1.right(-2));
-}
-
-TEST(PIString_Tests, cutMid){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good for new project 144", str1.cutMid(5,5));
-}
-
-TEST(PIString_Tests, cutMid_len_zero){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.cutMid(5,0));
-}
-
-TEST(PIString_Tests, cutMid_len_min){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good ", str1.cutMid(5,-2));
-}
-
-TEST(PIString_Tests, cutMid_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("ood idea for new project 144", str1.cutMid(-5, 6));
-}
-
-TEST(PIString_Tests, cutMid_zero){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.cutMid(-5, 5));
-}
-
-TEST(PIString_Tests, cutleft){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("od idea for new project 144", str1.cutLeft(2));
-}
-
-TEST(PIString_Tests, cutleft_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.cutLeft(-2));
-}
-
-TEST(PIString_Tests, cutright){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 1", str1.cutRight(2));
-}
-
-TEST(PIString_Tests, cutright_minus){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.cutRight(-2));
-}
-
-TEST(PIString_Tests, trim){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("Good idea for new project 144", str1.trim());
-}
-
-TEST(PIString_Tests, trim_without){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.trim());
-}
-
-TEST(PIString_Tests, trim_link){
-    PIString str1 = " Good idea for new project 144 ";
-    PIString &str2 = str1.trim();
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, trimmed){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("Good idea for new project 144", str1.trimmed());
-}
-
-TEST(PIString_Tests, trimmed_without){
-    PIString str1 = "Good idea for new project 144";
-    ASSERT_STREQ("Good idea for new project 144", str1.trimmed());
-}
-
-TEST(PIString_Tests, replace){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ(" Good thin for new project 144 ", str1.replace(6,4, "thin"));
-}
-
-TEST(PIString_Tests, replace_more){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ(" Good thin", str1.replace(6,100, "thin"));
-}
-
-TEST(PIString_Tests, replace_link){
-    PIString str1 = " Good idea for new project 144 ";
-    PIString &str2 = str1.replace(6,4, "thin");
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, replace_minus){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("BAD idea for new project 144 ", str1.replace(0, 5, "BAD"));
-}
-
-TEST(PIString_Tests, replace_zero){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("thin Good idea for new project 144 ", str1.replace(0, 0, "thin"));
-}
-
-TEST(PIString_Tests, replace_all){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("BAD", str1.replaced(0, 100, "BAD"));
-}
-
-TEST(PIString_Tests, replaced){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ(" Good thin for new project 144 ", str1.replaced(6,4, "thin"));
-}
-
-TEST(PIString_Tests, replaced_minus){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("BAD idea for new project 144 ", str1.replaced(0, 5, "BAD"));
-}
-
-TEST(PIString_Tests, replaced_zero){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("thin Good idea for new project 144 ", str1.replaced(0, 0, "thin"));
-}
-
-
-TEST(PIString_Tests, replaced_all){
-    PIString str1 = " Good idea for new project 144 ";
-    ASSERT_STREQ("thin", str1.replaced(0, 100, "thin"));
-}
-
-TEST(PIString_Tests, replace_str){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replace("Good", "bad", &ok);
-    ASSERT_STREQ(" bad idea for new Good project 144 ", str1);
-}
-
-TEST(PIString_Tests, replace_str_link){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    PIString &str2 =  str1.replace("Good", "bad", &ok);
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, replace_str_zero){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replace("", "bad", &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, replace_str_true){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replace("Good", "bad", &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, replace_str_delete){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replace("Good", "", &ok);
-    ASSERT_STREQ("  idea for new Good project 144 ", str1);
-}
-
-TEST(PIString_Tests, replaced_str){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    PIString str2 = str1.replaced("Good", "bad", &ok);
-    ASSERT_STREQ(" bad idea for new Good project 144 ", str2);
-}
-
-TEST(PIString_Tests, replaced_str_zero){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replaced("", "bad", &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, replaced_str_true){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    str1.replaced("Good", "bad", &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, replaced_delete){
-    PIString str1 = " Good idea for new Good project 144 ";
-    bool ok = 1;
-    PIString str2 = str1.replaced("Good", "", &ok);
-    ASSERT_STREQ("  idea for new Good project 144 ", str2);
-}
-
-TEST(PIString_Tests, replaceall){
-    PIString str1 = " Good idea for new Good project 144 ";
-    str1.replaceAll("Good", "bad");
-    ASSERT_STREQ(" bad idea for new bad project 144 ", str1);
-}
-
-TEST(PIString_Tests, replaceall_no_find){
-    PIString str1 = " Good idea for new Good project 144 ";
-    str1.replaceAll("God", "bad");
-    ASSERT_STREQ(" Good idea for new Good project 144 ", str1);
-}
-
-TEST(PIString_Tests, replaceall_str){
-    PIString str1 = " Good idea for new Good project 144 ";
-    PIString str2 = str1.replaceAll("Good", "bad");
-    ASSERT_STREQ(" bad idea for new bad project 144 ", str2);
-}
-
-TEST(PIString_Tests, replaceall_str_no_find){
-    PIString str1 = " Good idea for new Good project 144 ";
-    PIString str2 = str1.replaceAll("God", "bad");
-    ASSERT_STREQ(" Good idea for new Good project 144 ", str2);
-}
-
-TEST(PIString_Tests, replaceall_link){
-    PIString str1 = " Good idea for new Good project 144 ";
-    PIString &str2 = str1.replaceAll("Good", "bad");
-    ASSERT_STREQ(" bad idea for new bad project 144 ", str2);
-}
-
-TEST(PIString_Tests, replaceall_link_change){
-    PIString str1 = " Good idea for new Good project 144 ";
-    PIString &str2 = str1.replaceAll("Good", "bad");
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, repeat){
-    PIString str1 = "string ";
-    PIString str2 = str1.repeat(6);
-    ASSERT_STREQ("string string string string string string ", str2);
-}
-
-TEST(PIString_Tests, repeat_zero){
-    PIString str1 = "string ";
-    PIString str2 = str1.repeat(0);
-    ASSERT_STREQ("string ", str2);
-}
-
-TEST(PIString_Tests, repeat_link){
-    PIString str1 = "string ";
-    PIString &str2 = str1.repeat(6);
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, repeated){
-    PIString str1 = "string ";
-    str1.repeat(6);
-    ASSERT_STREQ("string string string string string string ", str1);
-}
-
-TEST(PIString_Tests, repeated_zero){
-    PIString str1 = "string ";
-    str1.repeat(0);
-    ASSERT_STREQ("string ", str1);
-}
-
-TEST(PIString_Tests, insert_char){
-    PIString str1 = "strng ";
-    char sym = 'i';
-    str1.insert(3, sym);
-    ASSERT_STREQ("string ", str1);
-}
-
-TEST(PIString_Tests, insert_pichar){
-    PIString str1 = "strng ";
-    PIChar sym = 'i';
-    str1.insert(3, sym);
-    ASSERT_STREQ("string ", str1);
-}
-
-TEST(PIString_Tests, insert_pistring){
-    PIString str1 = "string out";
-    PIString str2 = " go";
-    str1.insert(6, str2);
-    ASSERT_STREQ("string go out", str1);
-}
-
-TEST(PIString_Tests, insert_chars){
-    PIString str1 = "see boy";
-    char str2[] = " big";
-    str1.insert(3, str2);
-    ASSERT_STREQ("see big boy", str1);
-}
-
-TEST(PIString_Tests, expandRightTo){
-    PIString str1 = "see boy ";
-    PIChar symbol = "x";
-    str1.expandRightTo(11, symbol);
-    ASSERT_STREQ("see boy xxx", str1);
-}
-
-TEST(PIString_Tests, expandRightTo_null){
-    PIString str1 = "see boy ";
-    PIChar symbol = "x";
-    str1.expandRightTo(0, symbol);
-    ASSERT_STREQ("see boy ", str1);
-}
-
-TEST(PIString_Tests, expandLeftTo){
-    PIString str1 = " see boy";
-    PIChar symbol = "x";
-    str1.expandLeftTo(11, symbol);
-    ASSERT_STREQ("xxx see boy", str1);
-}
-
-TEST(PIString_Tests, expandLeftTo_null){
-    PIString str1 = "see boy ";
-    PIChar symbol = "x";
-    str1.expandLeftTo(0, symbol);
-    ASSERT_STREQ("see boy ", str1);
-}
-
-TEST(PIString_Tests, quote){
-    PIString str1 = "see boy";
-    PIChar symbol = " ";
-    str1.quote(symbol);
-    ASSERT_STREQ(" see boy ", str1);
-}
-
-TEST(PIString_Tests, quote_link){
-    PIString str1 = "see boy";
-    PIChar symbol = " ";
-    PIString &str2 = str1.quote(symbol);
-    str1 = "link";
-    ASSERT_STREQ("link", str2);
-}
-
-TEST(PIString_Tests, quoted){
-    PIString str1 = "see boy";
-    PIChar symbol = " ";
-    PIString str2 = str1.quoted(symbol);
-    ASSERT_STREQ(" see boy ", str2);
-}
-
-TEST(PIString_Tests, reverse){
-    PIString str1 = "see boy";
-    PIString &str2 = str1.reverse();
-    ASSERT_STREQ("yob ees", str2);
-}
-
-TEST(PIString_Tests, reverse_link){
-    PIString str1 = "see boy";
-    PIString &str2 = str1.reverse();
-    str1 = "yes";
-    ASSERT_STREQ("yes", str2);
-}
-
-TEST(PIString_Tests, reversed){
-    PIString str1 = "see boy";
-    PIString str2 = str1.reversed();
-    ASSERT_STREQ("yob ees", str2);
-}
-
-TEST(PIString_Tests, elide){
-    PIString str1 = "BMSTU is best university in space";
-    PIString &str2 = str1.elide(8, 1);
-    ASSERT_STREQ("BMSTU ..", str2);
-}
-
-TEST(PIString_Tests, elide_small){
-    PIString str1 = "BMSTU is best university in space";
-    PIString &str2 = str1.elide(2, 1);
-    ASSERT_STREQ("..", str2);
-}
-
-TEST(PIString_Tests, elide_all){
-    PIString str1 = "BMSTU is best university in space";
-    PIString &str2 = str1.elide(100, 1);
-    ASSERT_STREQ("BMSTU is best university in space", str2);
-}
-
-TEST(PIString_Tests, elide_link){
-    PIString str1 = "BMSTU is best university in space";
-    PIString &str2 = str1.elide(8, 1);
-    str1 = "space";
-    ASSERT_STREQ("space", str2);
-}
-
-TEST(PIString_Tests, elided){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.elided(8, 1);
-    ASSERT_STREQ("BMSTU ..", str2);
-}
-
-TEST(PIString_Tests, takemid){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeMid(9, 4);
-    ASSERT_STREQ("best", str2);
-}
-
-TEST(PIString_Tests, takeleft){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeLeft(5);
-    ASSERT_STREQ("BMSTU", str2);
-}
-
-TEST(PIString_Tests, takeright){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeRight(5);
-    ASSERT_STREQ("space", str2);
-}
-
-TEST(PIString_Tests, takesymbol){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeSymbol();
-    ASSERT_STREQ("B", str2);
-}
-
-TEST(PIString_Tests, takesymbol_with_rubbish){
-    PIString str1 = " \t \n \r BMSTU is best university in space";
-    PIString str2 = str1.takeSymbol();
-    ASSERT_STREQ("B", str2);
-}
-
-TEST(PIString_Tests, takesymbol_without){
-    PIString str1 = " \t \n \r ";
-    PIString str2 = str1.takeSymbol();
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, takeword){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeWord();
-    ASSERT_STREQ("BMSTU", str2);
-}
-
-TEST(PIString_Tests, takeword_space){
-    PIString str1 = "   \r\n\tBMSTU is best university in space";
-    PIString str2 = str1.takeWord();
-    ASSERT_STREQ("BMSTU", str2);
-}
-
-TEST(PIString_Tests, takeword_without_word){
-    PIString str1 = "   \r\n\t";
-    PIString str2 = str1.takeWord();
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, takecword){
-    PIString str1 = "_6 BMSTU is best university in space";
-    PIString str2 = str1.takeCWord();
-    ASSERT_STREQ("_6", str2);
-}
-
-TEST(PIString_Tests, takecword_space){
-    PIString str1 = "  \t\r\n_6 BMSTU is best university in space";
-    PIString str2 = str1.takeCWord();
-    ASSERT_STREQ("_6", str2);
-}
-
-TEST(PIString_Tests, takecword_space_w){
-    PIString str1 = "  \t\r\n BMSTU is best university in space";
-    PIString str2 = str1.takeCWord();
-    ASSERT_STREQ("BMSTU", str2);
-}
-
-TEST(PIString_Tests, takecword_not_cword){
-    PIString str1 = "  \t\r\n ";
-    PIString str2 = str1.takeCWord();
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, takeline){
-    PIString str1 = "BMSTU is best\n university in space";
-    PIString str2 = str1.takeLine();
-    ASSERT_STREQ("BMSTU is best", str2);
-}
-
-TEST(PIString_Tests, takeline_without){
-    PIString str1 = "BMSTU is best";
-    PIString str2 = str1.takeLine();
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, takeline_first){
-    PIString str1 = "\nBMSTU is best";
-    PIString str2 = str1.takeLine();
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, takenumber){
-    PIString str1 = "6.6";
-    PIString str2 = str1.takeNumber();
-    ASSERT_STREQ("6.6", str2);
-}
-
-TEST(PIString_Tests, takenumber_sign){
-    PIString str1 = "-66";
-    PIString str2 = str1.takeNumber();
-    ASSERT_STREQ("-66", str2);
-}
-
-TEST(PIString_Tests, takenumber_suffix){
-    PIString str1 = "66L";
-    PIString str2 = str1.takeNumber();
-    ASSERT_STREQ("66L", str2);
-}
-
-TEST(PIString_Tests, takerange){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeRange('B', 'i', ' ');
-    ASSERT_STREQ("MSTU is best un", str2);
-}
-
-TEST(PIString_Tests, takerange_without_shield){
-    PIString str1 = "BMSTU is best university in space";
-    PIString str2 = str1.takeRange('B', 'i');
-    ASSERT_STREQ("MSTU ", str2);
-}
-
-TEST(PIString_Tests, takerange_space){
-    PIString str1 = " \t\r\nBMSTU is best university in space";
-    PIString str2 = str1.takeRange('B', 'i', ' ');
-    ASSERT_STREQ("MSTU is best un", str2);
-}
-
-TEST(PIString_Tests, takerange_without_shield_space){
-    PIString str1 = " \t\r\nBMSTU is best university in space";
-    PIString str2 = str1.takeRange('B', 'i');
-    ASSERT_STREQ("MSTU ", str2);
-}
-
-TEST(PIString_Tests, inBrackets){
-    PIString str1 = "BMSTU is (best) university in space";
-    PIString str2 = str1.inBrackets('(', ')');
-    ASSERT_STREQ("best", str2);
-}
-
-TEST(PIString_Tests, inBrackets_end_start){
-    PIString str1 = "BMSTU )is (best) university in space";
-    PIString str2 = str1.inBrackets('(', ')');
-    ASSERT_STREQ("best", str2);
-}
-
-TEST(PIString_Tests, inBrackets_without){
-    PIString str1 = "BMSTU )is (best) university in space";
-    PIString str2 = str1.inBrackets('0', '1');
-    ASSERT_STREQ("", str2);
-}
-
-TEST(PIString_Tests, lenghtascii){
-    PIString str1 = "BMSTU is (best) university in space";
-    int size = str1.lengthAscii();
-    ASSERT_EQ(35, size);
-}
-
-TEST(PIString_Tests, data){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    const char *data = str1.data();
-    ASSERT_STREQ("BMSTU is (best) university in space\n", data);
-}
-
-TEST(PIString_Tests, dataconsole){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    const char *data = str1.dataConsole();
-    ASSERT_STREQ("BMSTU is (best) university in space\n", data);
-}
-
-TEST(PIString_Tests, dataUTF8){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    const char *data = str1.dataUTF8();
-    ASSERT_STREQ("BMSTU is (best) university in space\n", data);
-}
-
-TEST(PIString_Tests, dataAScii){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    const char *data = str1.dataAscii();
-    ASSERT_STREQ("BMSTU is (best) university in space\n", data);
-}
-
-TEST(PIString_Tests, hash){
-    const PIString str1 = "B";
-    uint h = str1.hash();
-    ASSERT_EQ(3912571919, h);
-}
-
-TEST(PIString_Tests, toByteArray){
-    const PIString str1 = "C";
-    PIByteArray h = str1.toByteArray();
-    ASSERT_EQ(67, h.at(0));
-}
-
-TEST(PIString_Tests, toUTF8){
-    const PIString str1 = "C";
-    PIByteArray h = str1.toUTF8();
-    ASSERT_EQ(67, h.at(0));
-}
-
-TEST(PIString_Tests, tocharset){
-    const PIString str1 = "B";
-    PIByteArray h = str1.toCharset("c");
-    ASSERT_EQ(66, h.at(0));
-}
-
-TEST(PIString_Tests, toUTF8_empty){
-    PIString str1;
-    str1.toUTF8();
-    ASSERT_EQ(0, str1.size());
-}
-
-TEST(PIString_Tests, tocharset_empty){
-    PIString str1 = "";
-    str1.toCharset("c");
-    ASSERT_EQ(0, str1.size());
-}
-
-TEST(PIString_Tests, split){
-    PIString str1 = " mirrow best mirrow ";
-    PIStringList list = str1.split("best");
-    ASSERT_STREQ(list[1], list[0]);
-}
-
-TEST(PIString_Tests, split_sec){
-    PIString str1 = " mirrow best detail ";
-    PIStringList list = str1.split("best");
-    ASSERT_STREQ(" mirrow ", list[0]);
-    ASSERT_STREQ(list[1], " detail ");
-}
-
-TEST(PIString_Tests, split_empty){
-    PIString str1 = "";
-    PIStringList list = str1.split("best");
-    ASSERT_EQ(0, list.size());
-}
-
-TEST(PIString_Tests, split_empty_delim){
-    PIString str1 = " mirrow best mirrow ";
-    PIStringList list = str1.split("");
-    ASSERT_EQ(0, list.size());
-}
-
-TEST(PIString_Tests, split_not_delim){
-    PIString str1 = " mirrow best mirrow ";
-    PIStringList list = str1.split("tr");
-    ASSERT_STREQ(list[0], " mirrow best mirrow ");
-}
-
-TEST(PIString_Tests, toUpperCase){
-    PIString str1 = " miRrow ";
-    PIString str2 = str1.toUpperCase();
-    ASSERT_STREQ(" MIRROW ", str2);
-}
-
-TEST(PIString_Tests, toLowerCase){
-    PIString str1 = " MIrROW ";
-    PIString str2 = str1.toLowerCase();
-    ASSERT_STREQ(" mirrow ", str2);
-}
-
-TEST(PIString_Tests, toNativeDecimalPoints){
-    PIString str1 = "4546,878";
-    PIString str2 = str1.toNativeDecimalPoints();
-    ASSERT_STREQ("4546.878", str2);
-}
-
-TEST(PIString_Tests, contains_char){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = '\n';
-    ASSERT_TRUE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_char_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = '0';
-    ASSERT_FALSE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_picahr){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIChar s = 'i';
-    ASSERT_TRUE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_pichar_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIChar s = '0';
-    ASSERT_FALSE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_cahrs){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s[] = "BMSTU";
-    ASSERT_TRUE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_chars_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s[] = "out";
-    ASSERT_FALSE(str1.contains(s));
-}
-
-
-TEST(PIString_Tests, contains_pistring){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString s = "univer";
-    ASSERT_TRUE(str1.contains(s));
-}
-
-TEST(PIString_Tests, contains_pistring_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString s = "new";
-    ASSERT_FALSE(str1.contains(s));
-}
-
-TEST(PIString_Tests, find_char){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'i';
-    ASSERT_EQ(6, str1.find(s));
-}
-
-TEST(PIString_Tests, find_char_start){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'i';
-    ASSERT_EQ(18, str1.find(s, 7));
-}
-
-TEST(PIString_Tests, find_char_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'o';
-    ASSERT_EQ(-1, str1.find(s));
-}
-
-TEST(PIString_Tests, find_chars){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char str2[] = "is";
-    ASSERT_EQ(6, str1.find(str2));
-}
-
-TEST(PIString_Tests, find_chars_start){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char str2[] = "iv";
-    ASSERT_EQ(18, str1.find(str2, 7));
-}
-
-TEST(PIString_Tests, find_chars_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s[] = "ouc";
-    ASSERT_EQ(-1, str1.find(s));
-}
-
-TEST(PIString_Tests, find_pistring){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "is";
-    ASSERT_EQ(6, str1.find(str2));
-}
-
-TEST(PIString_Tests, find_pistring_start){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "iv";
-    ASSERT_EQ(18, str1.find(str2, 7));
-}
-
-TEST(PIString_Tests, find_pistring_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "ouc";
-    ASSERT_EQ(-1, str1.find(str2));
-}
-
-TEST(PIString_Tests, find_last_char){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'i';
-    ASSERT_EQ(27, str1.findLast(s));
-}
-
-TEST(PIString_Tests, find_last_char_start){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'i';
-    ASSERT_EQ(27, str1.findLast(s, 20));
-}
-
-TEST(PIString_Tests, find_last_char_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char s = 'o';
-    ASSERT_EQ(-1, str1.findLast(s));
-}
-
-TEST(PIString_Tests, find_last_chars){
-    PIString str1 = "BMSTU is (best) university in is space\n";
-    char str2[] = "is";
-    ASSERT_EQ(30, str1.findLast(str2));
-}
-
-TEST(PIString_Tests, find_last_chars_start){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    char str2[] = "iv";
-    ASSERT_EQ(30, str1.findLast(str2, 25));
-}
-
-TEST(PIString_Tests, find_last_chars_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    char str2[] = "ouc";
-    ASSERT_EQ(-1, str1.findLast(str2));
-}
-
-TEST(PIString_Tests, find_last_pistring){
-    PIString str1 = "BMSTU is (best) university in is space\n";
-    PIString str2 = "is";
-    ASSERT_EQ(30, str1.findLast(str2));
-}
-
-TEST(PIString_Tests, find_last_pistring_start){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "iv";
-    ASSERT_EQ(30, str1.findLast(str2, 10));
-}
-
-TEST(PIString_Tests, find_last_pistring_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "ouc";
-    ASSERT_EQ(-1, str1.findLast(str2));
-}
-
-TEST(PIString_Tests, find_word){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(16, str1.findWord(str2));
-}
-
-TEST(PIString_Tests, find_word_start){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(16, str1.findWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_word_space_before){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = " university";
-    ASSERT_EQ(-1, str1.findWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_word_space_after){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university ";
-    ASSERT_EQ(-1, str1.findWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_word_digit_before){
-    PIString str1 = "BMSTU is (best) _university_ in iv space\n";
-    PIString str2 = "_university";
-    ASSERT_EQ(-1, str1.findWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_word_digit_after){
-    PIString str1 = "BMSTU is (best) _university_ in iv space\n";
-    PIString str2 = "university_";
-    ASSERT_EQ(-1, str1.findWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_word_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(-1, str1.findWord(str2, 37));
-}
-
-TEST(PIString_Tests, find_cword){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(16, str1.findCWord(str2));
-}
-
-TEST(PIString_Tests, find_cword_start){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(16, str1.findCWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_cword_space_before){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = " university";
-    ASSERT_EQ(15, str1.findCWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_cword_space_after){
-    PIString str1 = "BMSTU is (best) university in iv space\n";
-    PIString str2 = "university ";
-    ASSERT_EQ(-1, str1.findCWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_cword_digit_before){
-    PIString str1 = "BMSTU is (best) _university_ in iv space\n";
-    PIString str2 = "_university";
-    ASSERT_EQ(-1, str1.findCWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_cword_digit_after){
-    PIString str1 = "BMSTU is (best) _university_ in iv space\n";
-    PIString str2 = "university_";
-    ASSERT_EQ(-1, str1.findCWord(str2, 10));
-}
-
-TEST(PIString_Tests, find_cword_false){
-    PIString str1 = "BMSTU is (best) university in space\n";
-    PIString str2 = "university";
-    ASSERT_EQ(-1, str1.findCWord(str2, 37));
-}
-
-TEST(PIString_Tests, find_range){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIChar start = "v";
-    PIChar end = "g";
-    ASSERT_EQ(3, str1.findRange(start, end, "n", 1));
-}
-
-TEST(PIString_Tests, find_range_len){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIChar start = "v";
-    PIChar end = "g";
-    int len;
-    str1.findRange(start, end, "n", 1, &len);
-    ASSERT_EQ(14, len);
-}
-
-TEST(PIString_Tests, find_range_len_without_shield){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIChar start = "v";
-    PIChar end = "g";
-    int len;
-    str1.findRange(start, end, "/", 1, &len);
-    ASSERT_EQ(9, len);
-}
-
-TEST(PIString_Tests, find_range_start){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIChar start = "g";
-    PIChar end = "o";
-    int len;
-    str1.findRange(start, end, " ", 17, &len);
-    ASSERT_EQ(9, len);
-}
-
-TEST(PIString_Tests, find_range_eq){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIChar start = "v";
-    PIChar end = "v";
-    int len;
-    str1.findRange(start, end, "n", 1, &len);
-    ASSERT_EQ(0, len);
-}
-
-TEST(PIString_Tests, find_range_trim){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIChar start = "A";
-    PIChar end = "v";
-    int len;
-    ASSERT_EQ(2, str1.findRange(start, end, "n", 0, &len));
-}
-
-TEST(PIString_Tests, find_any){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "doip";
-    ASSERT_EQ(11, str1.findAny(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_not){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "q";
-    ASSERT_EQ(-1, str1.findAny(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_start){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "doip";
-    ASSERT_EQ(15, str1.findAny(str2, 12));
-}
-
-TEST(PIString_Tests, find_any_chars){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "doip";
-    ASSERT_EQ(11, str1.findAny(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_chars_not){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "q";
-    ASSERT_EQ(-1, str1.findAny(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_chars_start){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "doip";
-    ASSERT_EQ(15, str1.findAny(str2, 12));
-}
-
-TEST(PIString_Tests, find_any_last){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "doip";
-    ASSERT_EQ(39, str1.findAnyLast(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_last_not){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "q";
-    ASSERT_EQ(-1, str1.findAnyLast(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_last_start){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "doip";
-    ASSERT_EQ(39, str1.findAnyLast(str2, 12));
-}
-
-TEST(PIString_Tests, find_any_last_chars){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "doip";
-    ASSERT_EQ(39, str1.findAnyLast(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_last_chars_not){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "q";
-    ASSERT_EQ(-1, str1.findAnyLast(str2, 0));
-}
-
-TEST(PIString_Tests, find_any_last_chars_start){
-    PIString str1 = " A very strong programmer wrote this code";
-    char str2[] = "doip";
-    ASSERT_EQ(39, str1.findAnyLast(str2, 12));
-}
-
-TEST(PIString_Tests, entries){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIChar c = "A";
-    ASSERT_EQ(1, str1.entries(c));
-}
-
-TEST(PIString_Tests, entries_char){
-    PIString str1 = " A very strong programmer wrote this code";
-    char c = 'A';
-    ASSERT_EQ(1, str1.entries(c));
-}
-
-TEST(PIString_Tests, starts_with){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = " A very";
-    ASSERT_TRUE(str1.startsWith(str2));
-}
-
-TEST(PIString_Tests, starts_with_false){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = " A veru";
-    ASSERT_FALSE(str1.startsWith(str2));
-}
-
-TEST(PIString_Tests, ends_with){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = " code";
-    ASSERT_TRUE(str1.endsWith(str2));
-}
-
-TEST(PIString_Tests, ends_with_false){
-    PIString str1 = " A very strong programmer wrote this code";
-    PIString str2 = "c code";
-    ASSERT_FALSE(str1.endsWith(str2));
-}
-
-TEST(PIString_Tests, length){
-    PIString str1 = " A very strong programmer wrote this code";
-    ASSERT_EQ(41, str1.length());
-}
-
-TEST(PIString_Tests, is_empty_false){
-    PIString str1 = " A very strong programmer wrote this code";
-    ASSERT_FALSE(str1.isEmpty());
-}
-
-TEST(PIString_Tests, is_empty_true){
-    PIString str1 = "";
-    ASSERT_TRUE(str1.isEmpty());
-}
-
-TEST(PIString_Tests, to_bool){
-    PIString str1 = "1";
-    ASSERT_TRUE(str1.toBool());
-}
-
-TEST(PIString_Tests, to_bool_yes){
-    PIString str1 = "yes";
-    ASSERT_TRUE(str1.toBool());
-}
-
-TEST(PIString_Tests, to_bool_false){
-    PIString str1 = "no";
-    ASSERT_FALSE(str1.toBool());
-}
-
-TEST(PIString_Tests, to_bool_false_zero){
-    PIString str1 = "0";
-    ASSERT_FALSE(str1.toBool());
-}
-
-TEST(PIString_Tests, to_char){
-    PIString str1 = "A very strong programmer wrote this code";
-    ASSERT_EQ(65, str1.toChar());
-}
-
-TEST(PIString_Tests, to_short){
-    PIString str1 = "133";
-    ASSERT_EQ(133, str1.toShort(-1));
-}
-
-TEST(PIString_Tests, to_short_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toShort(-1));
-}
-
-TEST(PIString_Tests, to_short_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toShort(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_short_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toShort(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_short_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(-7, str1.toShort(10, &ok));
-}
-
-TEST(PIString_Tests, to_ushort){
-    PIString str1 = "133.1";
-    ASSERT_EQ(133, str1.toUShort(-1));
-}
-
-TEST(PIString_Tests, to_ushort_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toUShort(-1));
-}
-
-TEST(PIString_Tests, to_ushort_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toUShort(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_ushort_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toUShort(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_ushort_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(65529, str1.toUShort(10, &ok));
-}
-
-TEST(PIString_Tests, to_int){
-    PIString str1 = "133";
-    ASSERT_EQ(133, str1.toInt(-1));
-}
-
-TEST(PIString_Tests, to_int_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toInt(-1));
-}
-
-TEST(PIString_Tests, to_int_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toInt(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_int_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toInt(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_int_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(-7, str1.toShort(10, &ok));
-}
-
-TEST(PIString_Tests, to_uint){
-    PIString str1 = "133.1";
-    ASSERT_EQ(133, str1.toUInt(-1));
-}
-
-TEST(PIString_Tests, to_uint_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toUInt(-1));
-}
-
-TEST(PIString_Tests, to_uint_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toUInt(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_uint_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toUInt(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_uint_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(4294967289, str1.toUInt(10, &ok));
-}
-
-TEST(PIString_Tests, to_long){
-    PIString str1 = "133";
-    ASSERT_EQ(133, str1.toLong(-1));
-}
-
-TEST(PIString_Tests, to_long_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toLong(-1));
-}
-
-TEST(PIString_Tests, to_long_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toLong(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_long_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toLong(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_long_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(-7, str1.toLong(10, &ok));
-}
-
-TEST(PIString_Tests, to_ulong){
-    PIString str1 = "133.1";
-    ASSERT_EQ(133, str1.toULong(-1));
-}
-
-TEST(PIString_Tests, to_ulong_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toULong(-1));
-}
-
-TEST(PIString_Tests, to_ulong_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toULong(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_ulong_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toULong(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_ulong_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(4294967289, str1.toULong(10, &ok));
-}
-
-TEST(PIString_Tests, to_llong){
-    PIString str1 = "133";
-    ASSERT_EQ(133, str1.toLLong(-1));
-}
-
-TEST(PIString_Tests, to_llong_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toLLong(-1));
-}
-
-TEST(PIString_Tests, to_llong_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toLLong(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_llong_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toLLong(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_llong_neg){
-    PIString str1 = "-7";
-    bool ok;
-    ASSERT_EQ(-7, str1.toLLong(10, &ok));
-}
-
-TEST(PIString_Tests, to_ullong){
-    PIString str1 = "133.1";
-    ASSERT_EQ(133, str1.toULLong(-1));
-}
-
-TEST(PIString_Tests, to_ullong_0x){
-    PIString str1 = "0x133";
-    ASSERT_EQ(307, str1.toULLong(-1));
-}
-
-TEST(PIString_Tests, to_ullong_false){
-    PIString str1 = "0x133";
-    bool ok;
-    str1.toULLong(1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_ullong_false_base){
-    PIString str1 = "7";
-    bool ok;
-    str1.toULLong(6, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, to_float){
-    PIString str1 = "-7765,54";
-    float f = -7765.54;
-    ASSERT_EQ(f, str1.toFloat());
-}
-
-TEST(PIString_Tests, to_double){
-    PIString str1 = "-7765,54656";
-    double f = -7765.54656;
-    ASSERT_EQ(f, str1.toDouble());
-}
-
-TEST(PIString_Tests, to_ldouble){
-    PIString str1 = "-7765,54656";
-    ldouble f = -7765.54656;
-    ASSERT_EQ(f, str1.toLDouble());
-}
-
-TEST(PIString_Tests, setNumber){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_zero){
-    PIString str1 = " String";
-    const short val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_false_base){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_true){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_false_base_str){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_base_minus){
-    PIString str1 = " String";
-    const short val = -10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("-A", str1);
-}
-
-TEST(PIString_Tests, setNumber_ushort){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_ushort_true){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ushort_zero){
-    PIString str1 = " String";
-    const ushort val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_ushort_false_base){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ushort_false_base_str){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_ushort_base_minus){
-    PIString str1 = " String";
-    const ushort val = 10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("A", str1);
-}
-
-TEST(PIString_Tests, setNumber_int){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_int_zero){
-    PIString str1 = " String";
-    const int val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_int_false_base){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_int_true){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_int_false_base_str){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_int_base_minus){
-    PIString str1 = " String";
-    const int val = -10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("-A", str1);
-}
-
-TEST(PIString_Tests, setNumber_uint){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_uint_true){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_uintt_zero){
-    PIString str1 = " String";
-    const uint val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_uint_false_base){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_uint_false_base_str){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_uint_base_minus){
-    PIString str1 = " String";
-    const uint val = 10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("A", str1);
-}
-
-TEST(PIString_Tests, setNumber_long){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_long_zero){
-    PIString str1 = " String";
-    const long val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_long_false_base){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_long_true){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_long_false_base_str){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_long_base_minus){
-    PIString str1 = " String";
-    const long val = -10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("-A", str1);
-}
-
-TEST(PIString_Tests, setNumber_ulong){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_ulong_true){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ulong_zero){
-    PIString str1 = " String";
-    const ulong val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_ulong_false_base){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ulong_false_base_str){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_ulong_base_minus){
-    PIString str1 = " String";
-    const ulong val = 10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("A", str1);
-}
-
-TEST(PIString_Tests, setNumber_llong){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_llong_zero){
-    PIString str1 = " String";
-    const llong val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_llong_false_base){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_llong_true){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_llong_false_base_str){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_llong_base_minus){
-    PIString str1 = " String";
-    const llong val = -10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("-A", str1);
-}
-
-TEST(PIString_Tests, setNumber_ullong){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("131", str1);
-}
-
-TEST(PIString_Tests, setNumber_ullong_true){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ullong_zero){
-    PIString str1 = " String";
-    const ullong val = 0;
-    bool ok;
-    str1.setNumber(val, 10, &ok);
-    ASSERT_STREQ("0", str1);
-}
-
-TEST(PIString_Tests, setNumber_ullong_false_base){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, setNumber_ullong_false_base_str){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.setNumber(val, 1, &ok);
-    ASSERT_STREQ("", str1);
-}
-
-TEST(PIString_Tests, setNumber_ullong_base_minus){
-    PIString str1 = " String";
-    const ullong val = 10;
-    bool ok;
-    str1.setNumber(val, 16, &ok);
-    ASSERT_STREQ("A", str1);
-}
-
-TEST(PIString_Tests, setNumber_float){
-    PIString str1 = " String";
-    const float val = 131.132;
-    str1.setNumber(val, 'f', 3);
-    ASSERT_STREQ("131.132", str1);
-}
-
-TEST(PIString_Tests, setNumber_double){
-    PIString str1 = " String";
-    const double val = 131.1324334;
-    str1.setNumber(val, 'f', 7);
-    ASSERT_STREQ("131.1324334", str1);
-}
-
-TEST(PIString_Tests, setNumber_ldouble){
-    PIString str1 = " String";
-    const ldouble val = 131.1324334;
-    str1.setNumber(val, 'f', 7);
-    ASSERT_STREQ("131.1324334", str1);
-}
-
-TEST(PIString_Tests, setReadableSize){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1023 B", str1.setReadableSize(1023));
-}
-
-TEST(PIString_Tests, setReadableSize_kb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 kB", str1.setReadableSize(1024));
-}
-
-TEST(PIString_Tests, setReadableSize_mb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 MB", str1.setReadableSize(1024*1024));
-}
-
-TEST(PIString_Tests, setReadableSize_gb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 GB", str1.setReadableSize(1024*1024*1024));
-}
-
-TEST(PIString_Tests, setReadableSize_tb){
-    PIString str1 = " ITELMA";
-    llong val = 99999999999999;
-    ASSERT_STREQ("90.9 TB", str1.setReadableSize(val));
-}
-
-TEST(PIString_Tests, setReadableSize_pb){
-    PIString str1 = " ITELMA";
-    llong val = 999999999999999999;
-    ASSERT_STREQ("888.1 PB", str1.setReadableSize(val));
-}
-
-TEST(PIString_Tests, fromNumber){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumberr_zero){
-    PIString str1 = " String";
-    const short val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_false_base){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_true){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_false_base_str){
-    PIString str1 = " String";
-    const short val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_base_minus){
-    PIString str1 = " String";
-    const short val = -10;
-    bool ok;
-    ASSERT_STREQ("-A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ushort){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ushort_true){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ushort_zero){
-    PIString str1 = " String";
-    const ushort val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ushort_false_base){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ushort_false_base_str){
-    PIString str1 = " String";
-    const ushort val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ushort_base_minus){
-    PIString str1 = " String";
-    const ushort val = 10;
-    bool ok;
-    ASSERT_STREQ("A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_int){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_int_zero){
-    PIString str1 = " String";
-    const int val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_int_false_base){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_int_true){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_int_false_base_str){
-    PIString str1 = " String";
-    const int val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_int_base_minus){
-    PIString str1 = " String";
-    const int val = -10;
-    bool ok;
-    ASSERT_STREQ("-A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_uint){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_uint_true){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_uintt_zero){
-    PIString str1 = " String";
-    const uint val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_uint_false_base){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_uint_false_base_str){
-    PIString str1 = " String";
-    const uint val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_uint_base_minus){
-    PIString str1 = " String";
-    const uint val = 10;
-    bool ok;
-    ASSERT_STREQ("A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_long){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_long_zero){
-    PIString str1 = " String";
-    const long val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_long_false_base){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_long_true){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_long_false_base_str){
-    PIString str1 = " String";
-    const long val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_long_base_minus){
-    PIString str1 = " String";
-    const long val = -10;
-    bool ok;
-    ASSERT_STREQ("-A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ulong){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ulong_true){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ulong_zero){
-    PIString str1 = " String";
-    const ulong val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ulong_false_base){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ulong_false_base_str){
-    PIString str1 = " String";
-    const ulong val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ulong_base_minus){
-    PIString str1 = " String";
-    const ulong val = 10;
-    bool ok;
-    ASSERT_STREQ("A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_llong){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_llong_zero){
-    PIString str1 = " String";
-    const llong val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_llong_false_base){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_llong_true){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_llong_false_base_str){
-    PIString str1 = " String";
-    const llong val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_llong_base_minus){
-    PIString str1 = " String";
-    const llong val = -10;
-    bool ok;
-    ASSERT_STREQ("-A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ullong){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    ASSERT_STREQ("131", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ullong_true){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.fromNumber(val, 10, &ok);
-    ASSERT_TRUE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ullong_zero){
-    PIString str1 = " String";
-    const ullong val = 0;
-    bool ok;
-    ASSERT_STREQ("0", str1.fromNumber(val, 10, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ullong_false_base){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    str1.fromNumber(val, 1, &ok);
-    ASSERT_FALSE(ok);
-}
-
-TEST(PIString_Tests, fromNumber_ullong_false_base_str){
-    PIString str1 = " String";
-    const ullong val = 131;
-    bool ok;
-    ASSERT_STREQ("", str1.fromNumber(val, 1, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_ullong_base_minus){
-    PIString str1 = " String";
-    const ullong val = 10;
-    bool ok;
-    ASSERT_STREQ("A", str1.fromNumber(val, 16, &ok));
-}
-
-TEST(PIString_Tests, fromNumber_float){
-    PIString str1 = " String";
-    const float val = 131.132;
-    ASSERT_STREQ("131.132", str1.fromNumber(val, 'f', 3));
-}
-
-TEST(PIString_Tests, fromNumber_double){
-    PIString str1 = " String";
-    const double val = 131.1324334;
-    ASSERT_STREQ("131.1324334", str1.fromNumber(val, 'f', 7));
-}
-
-TEST(PIString_Tests, fromNumber_ldouble){
-    PIString str1 = " String";
-    const ldouble val = 131.1324334;
-    ASSERT_STREQ("131.1324334", str1.fromNumber(val, 'f', 7));
-}
-
-TEST(PIString_Tests, fromBool_true){
-    PIString str1;
-    bool val = true;
-    ASSERT_STREQ("true", str1.fromBool(val));
-}
-
-TEST(PIString_Tests, fromBool_false){
-    PIString str1;
-    bool val = false;
-    ASSERT_STREQ("false", str1.fromBool(val));
-}
-
-TEST(PIString_Tests, from_Console){
-    PIString str1;
-    char s[] = "true boy";
-    ASSERT_STREQ("true boy", str1.fromConsole(s));
-}
-
-TEST(PIString_Tests, from_System){
-    PIString str1;
-    char s[] = "true boy";
-    ASSERT_STREQ("true boy", str1.fromSystem(s));
-}
-
-TEST(PIString_Tests, from_UTF8){
-    PIString str1;
-    char s[] = "true boy";
-    ASSERT_STREQ("true boy", str1.fromUTF8(s));
-}
-
-TEST(PIString_Tests, from_UTF8_ba){
-    PIString str1;
-    PIByteArray s;
-    s.append('t');
-    s.append('r');
-    s.append('u');
-    s.append('e');
-    ASSERT_STREQ("true", str1.fromUTF8(s));
-}
-
-TEST(PIString_Tests, from_Ascii){
-    PIString str1;
-    char s[] = "true boy";
-    ASSERT_STREQ("true boy", str1.fromAscii(s));
-}
-
-TEST(PIString_Tests, from_Codepage){
-    PIString str1 = "Nul";
-    char s[] = "true";
-    char c[] = "utf8";
-    PIString str2 = str1.fromCodepage(s, c);
-    ASSERT_STREQ("true", str2);
-}
-
-TEST(PIString_Tests, ReadableSize){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1023 B", str1.readableSize(1023));
-}
-
-TEST(PIString_Tests, readableSize_kb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 kB", str1.readableSize(1024));
-}
-
-TEST(PIString_Tests, readableSize_mb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 MB", str1.readableSize(1024*1024));
-}
-
-TEST(PIString_Tests, readableSize_gb){
-    PIString str1 = " ITELMA";
-    ASSERT_STREQ("1.0 GB", str1.readableSize(1024*1024*1024));
-}
-
-TEST(PIString_Tests, readableSize_tb){
-    PIString str1 = " ITELMA";
-    llong val = 99999999999999;
-    ASSERT_STREQ("90.9 TB", str1.readableSize(val));
-}
-
-TEST(PIString_Tests, readableSize_pb){
-    PIString str1 = " ITELMA";
-    llong val = 999999999999999999;
-    ASSERT_STREQ("888.1 PB", str1.readableSize(val));
-}
-
-TEST(PIString_Tests, removeAll_char){
-    PIString str1 = "A very strong programmer wrote this code";
-    char v = ' ';
-    ASSERT_STREQ("Averystrongprogrammerwrotethiscode", str1.removeAll(v));
-}
-
-TEST(PIString_Tests, removeAll_pistring){
-    PIString str1 = "A very strong programmer wrote this code";
-    PIString v = "very strong ";
-    ASSERT_STREQ("A programmer wrote this code", str1.removeAll(v));
-}
-
-TEST(PIString_Tests, operator_ba_pstr){
-    PIString str1 = '1';
-    PIByteArray s;
-    s << str1;
-    ASSERT_STREQ("010000003100", s.toHex());
-}
-
-TEST(PIString_Tests, operator_pstr_ba){
-    PIString str1 = "1";
-    PIByteArray s;
-    s.append('t');
-    s.append('r');
-    s.append('u');
-    s.append('e');
-    str1 << s;
-    ASSERT_STREQ("1true", str1);
-}
-
-TEST(PIString_Tests, operator_plus_pstr_pstr){
-    PIString str1 = "first ";
-    PIString str2 = "second";
-    ASSERT_STREQ("first second", str1 + str2);
-}
-
-TEST(PIString_Tests, operator_plus_pstr_chars){
-    PIString str1 = "first ";
-    char str2[] = "second";
-    ASSERT_STREQ("first second", str1 + str2);
-}
-
-TEST(PIString_Tests, operator_plus_chars_pstr){
-    PIString str1 = "first";
-    char str2[] = "second ";
-    ASSERT_STREQ("second first", str2 + str1);
-}
-
-TEST(PIString_Tests, versionCompare2){                                                                      //дописать
-    PIString str1 = "first";
-    PIString str2 = "first 1";
-    versionCompare(str1, str2, 0);
-    ASSERT_EQ(898448032, piHash(str1));
-}
-
-TEST(PIString_Tests, versionNormalize2){
-    PIString str1 = "first second";
-    ASSERT_STREQ("0.0_first second", versionNormalize(str1));
-}
-
-TEST(PIString_Tests, piHash){
-    PIString str1 = "first";
-    ASSERT_EQ(898448032, piHash(str1));
-}
-
-TEST(PIString_Tests, piSwap){
-    PIString str1 = "first";
-    PIString str2 = "second";
-    piSwap(str1, str2);
-    ASSERT_STREQ("first", str2);
-}
-
-TEST(PIString_Tests, piSwap_sec){
-    PIString str1 = "first";
-    PIString str2 = "second";
-    piSwap(str1, str2);
-    ASSERT_STREQ("second", str1);
-}
-
-
-
-
-
-
-
-
-
-
-
diff --git a/tests/math/testpimathmatrix.cpp b/tests/math/testpimathmatrix.cpp
index fb7109fb..f2c8cc10 100644
--- a/tests/math/testpimathmatrix.cpp
+++ b/tests/math/testpimathmatrix.cpp
@@ -111,18 +111,18 @@ TEST(PIMathMatrix_Test, swapCols) {
     double a1[3], a2[3], a3[3];
     double b1[3], b2[3], b3[3];
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix1 = origMatr.identity(3, 3);
     matrix1.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix1.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix1.setCol(2, vector);
     for(int i = 0; i < 3; i++) {
         a1[i] = matrix1.element(i, 0);
@@ -146,18 +146,18 @@ TEST(PIMathMatrix_Test, swapRows) {
     double a1[3], a2[3], a3[3];
     double b1[3], b2[3], b3[3];
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix1 = origMatr.identity(3, 3);
     matrix1.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix1.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix1.setCol(2, vector);
     for(int i = 0; i < 3; i++) {
         a1[i] = matrix1.element(0, i);
@@ -339,17 +339,17 @@ TEST(PIMathMatrix_Test, determinantIfSquare) {
     PIMathMatrix<double> matrix(3, 3, 0.0);
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix.setCol(2, vector);
     d = matrix.determinant();
     ASSERT_DOUBLE_EQ(d, i);
@@ -367,17 +367,17 @@ TEST(PIMathMatrix_Test, trace) {
     double i = 9.0;
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix.setCol(2, vector);
     t = matrix.trace();
     ASSERT_DOUBLE_EQ(t, i);
@@ -395,17 +395,17 @@ TEST(PIMathMatrix_Test, toUpperTriangular) {
     int i;
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix.setCol(2, vector);
     d1 = matrix.determinant();
     matrix.toUpperTriangular();
@@ -424,17 +424,17 @@ TEST(PIMathMatrix_Test, invert) {
     PIMathMatrix<double> matrix4(3, 3, 0.0);
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix1.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix1.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix1.setCol(2, vector);
     d1 = matrix1.determinant();
     matrix2 = matrix1;
@@ -452,17 +452,17 @@ TEST(PIMathMatrix_Test, inverted) {
     PIMathMatrix<double> matrix4(3, 3, 0.0);
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix1.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix1.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix1.setCol(2, vector);
     d1 = matrix1.determinant();
     matrix2 = matrix1;
@@ -480,18 +480,17 @@ TEST(PIMathMatrix_Test, transposed) {
     PIMathMatrix<double> matrix3;
     PIMathVector<double> vector;
     vector.resize(3, 3.0);
-    vector.at(0) = 3.0;
-    vector.at(1) = 6.0;
-    vector.at(2) = 8.0;
-    matrix1 = origMatr.identity(3, 3);
+    vector[0] = 3.0;
+    vector[1] = 6.0;
+    vector[2] = 8.0;
     matrix1.setCol(0, vector);
-    vector.at(0) = 2.0;
-    vector.at(1) = 1.0;
-    vector.at(2) = 4.0;
+    vector[0] = 2.0;
+    vector[1] = 1.0;
+    vector[2] = 4.0;
     matrix1.setCol(1, vector);
-    vector.at(0) = 6.0;
-    vector.at(1) = 2.0;
-    vector.at(2) = 5.0;
+    vector[0] = 6.0;
+    vector[1] = 2.0;
+    vector[2] = 5.0;
     matrix1.setCol(2, vector);
     d1 = matrix1.determinant();
     matrix2 = matrix1.transposed();
diff --git a/tests/math/testpimathmatrixt.cpp b/tests/math/testpimathmatrixt.cpp
index df96a01c..ff9afc8c 100644
--- a/tests/math/testpimathmatrixt.cpp
+++ b/tests/math/testpimathmatrixt.cpp
@@ -106,9 +106,9 @@ TEST(PIMathMatrixT_Test, row) {
 TEST(PIMathMatrixT_Test, setCol) {
     PIMathMatrixT<rows, cols, double> matr;
     PIMathVectorT<rows, double> vect;
-    vect.at(0) = 1.0;
-    vect.at(1) = 3.0;
-    vect.at(2) = 5.0;
+    vect[0] = 1.0;
+    vect[1] = 3.0;
+    vect[2] = 5.0;
     uint g = 1;
     matr.setCol(g, vect);
     for(uint i = 0; i < vect.size(); i++) {
@@ -122,9 +122,9 @@ TEST(PIMathMatrixT_Test, setCol) {
 TEST(PIMathMatrixT_Test, setRow) {
     PIMathMatrixT<rows, cols, double> matr;
     PIMathVectorT<rows, double> vect;
-    vect.at(0) = 1.0;
-    vect.at(1) = 3.0;
-    vect.at(2) = 5.0;
+    vect[0] = 1.0;
+    vect[1] = 3.0;
+    vect[2] = 5.0;
     uint g = 1;
     matr.setRow(g, vect);
     for(uint i = 0; i < vect.size(); i++) {
diff --git a/tests/math/testpimathvector.cpp b/tests/math/testpimathvector.cpp
new file mode 100644
index 00000000..b12ba4bb
--- /dev/null
+++ b/tests/math/testpimathvector.cpp
@@ -0,0 +1,364 @@
+#include "gtest/gtest.h"
+#include "pimathvector.h"
+
+bool cmpVectorWithValue(PIMathVector<double> vector, double val, int num) {
+    bool b = true;
+    for(int i = 0; i < num; i++) {
+        if(vector[i] != val) {
+            b = false;
+        }
+    }
+    return b;
+}
+
+TEST(PIMathVector_Test, size) {
+    auto vector = PIMathVector<double>(3u);
+    ASSERT_TRUE(vector.size() == 3u);
+}
+
+TEST(PIMathVector_Test, resize) {
+    PIMathVector<double> vector;
+    vector.resize(4u, 5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 5.0, vector.size()));
+}
+
+TEST(PIMathVector_Test, resized) {
+    PIMathVector<double> vector;
+    vector.resized(4u, 5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 5.0, vector.size()));
+}
+
+TEST(PIMathVector_Test, fill) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 5.0, 3u));
+}
+
+TEST(PIMathVector_Test, moveVal) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.0);
+    vector.move(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 10.0, 3u));
+}
+
+TEST(PIMathVector_Test, moveVec) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vector.fill(5.0);
+    vec.fill(7.0);
+    vector.move(vec);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 12.0, 3u));
+}
+
+TEST(PIMathVector_Test, swap) {
+    PIMathVector<double> vector(3u);
+    double a[3];
+    vector[0] = 5.12;
+    vector[1] = 3.32;
+    vector[2] = 7.12;
+    a[0] = vector[0];
+    a[1] = vector[1];
+    a[2] = vector[2];
+    vector.swap(0u, 1u);
+    ASSERT_TRUE((a[0] == vector[1]) && (a[1] == vector[0]) && (a[2] == vector[2]));
+}
+
+TEST(PIMathVector_Test, lengthSqr) {
+    PIMathVector<double> vector(3u);
+    vector.fill(1.0);
+    ASSERT_EQ(3.0, vector.lengthSqr());
+}
+
+TEST(PIMathVector_Test, length) {
+    PIMathVector<double> vector(3u);
+    vector.fill(1.0);
+    ASSERT_DOUBLE_EQ(sqrt(3.0), vector.length());
+}
+
+TEST(PIMathVector_Test, manhattanLength) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.0);
+    ASSERT_DOUBLE_EQ(15.0, vector.manhattanLength());
+}
+
+TEST(PIMathVector_Test, angleCos) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(cos(0.78539816339744830961566084581988), vector.angleCos(vec));
+}
+
+TEST(PIMathVector_Test, angleSin) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(cos(0.78539816339744830961566084581988), vector.angleSin(vec));
+}
+
+TEST(PIMathVector_Test, angleRad) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(0.78539816339744830961566084581988, vector.angleRad(vec));
+}
+
+TEST(PIMathVector_Test, angleDeg) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(45.0, vector.angleDeg(vec));
+}
+
+TEST(PIMathVector_Test, projection) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vec(2u);
+    vec[0] = 1.0;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    auto vecProj = vector.projection(vec);
+    ASSERT_TRUE(vecProj == vec);
+}
+
+TEST(PIMathVector_Test, normalize) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), 5.0 / sqrt(75.0), 3u));
+}
+
+TEST(PIMathVector_Test, normalized) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector.normalized(), 5.0 / sqrt(75.0), 3u));
+}
+
+TEST(PIMathVector_Test, isNullTrue) {
+    PIMathVector<double> vector(3u);
+    ASSERT_TRUE(vector.isNull());
+}
+
+TEST(PIMathVector_Test, isNullFalse) {
+    PIMathVector<double> vector(3u);
+    vector[0] = 6.273;
+    ASSERT_FALSE(vector.isNull());
+}
+
+TEST(PIMathVector_Test, isValidTrue) {
+    PIMathVector<double> vector(3u);
+    ASSERT_TRUE(vector.isValid());
+}
+
+TEST(PIMathVector_Test, isValidFalse) {
+    PIMathVector<double> vector;
+    ASSERT_FALSE(vector.isValid());
+}
+
+TEST(PIMathVector_Test, isOrthoTrue) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vect(2u);
+    vector[0] = 2.0;
+    vect[1] = 1.0;
+    ASSERT_TRUE(vector.isOrtho(vect));
+}
+
+TEST(PIMathVector_Test, isOrthoFalse) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vect(2u);
+    vector[0] = 2.0;
+    vect[0] = 5.0;
+    vect[1] = 1.0;
+    ASSERT_FALSE(vector.isOrtho(vect));
+}
+
+TEST(PIMathVector_Test, at) {
+    PIMathVector<double> vector(3u);
+    vector.fill(5.5);
+    for(uint i = 0; i < 3u; i++){
+        if(vector.at(i) != 5.5){
+            ASSERT_TRUE(false);
+        }
+    }
+    ASSERT_TRUE(true);
+}
+
+TEST(PIMathVector_Test, operator_AssignmentValue) {
+    PIMathVector<double> vector(3u);
+    vector = 3.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector, 3.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_AssignmentVector) {
+    PIMathVector<double> vector(3u);
+    PIMathVector<double> vec(3u);
+    vec = 5.0;
+    vector = vec;
+    ASSERT_TRUE(cmpVectorWithValue(vector, 5.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_EqualTrue) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vec(2u);
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 7.34;
+    ASSERT_TRUE(vec == vector);
+}
+
+TEST(PIMathVector_Test, operator_EqualFalse) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vec(2u);
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 0.34;
+    ASSERT_FALSE(vec == vector);
+}
+
+TEST(PIMathVector_Test, operator_Not_EqualTrue) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vec(2u);
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 0.34;
+    ASSERT_TRUE(vec != vector);
+}
+
+TEST(PIMathVector_Test, operator_Not_EqualFalse) {
+    PIMathVector<double> vector(2u);
+    PIMathVector<double> vec(2u);
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 7.34;
+    ASSERT_FALSE(vec != vector);
+}
+
+TEST(PIMathVector_Test, operator_Addition_Aassignment) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 += vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 7.72, 3));
+}
+
+TEST(PIMathVector_Test, operator_Subtraction_Assignment) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 -= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 4.28, 3));
+}
+
+TEST(PIMathVector_Test, operator_Multiplication_AssignmentValue) {
+    PIMathVector<double> vector1(3u);
+    vector1.fill(6.0);
+    vector1 *= 4.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 24.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_Multiplication_AssignmentVector) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 *= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 10.32, 3));
+}
+
+TEST(PIMathVector_Test, operator_Division_AssignmentValue) {
+    PIMathVector<double> vector1(3u);
+    vector1.fill(6.0);
+    vector1 /= 4.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 1.5, 3));
+}
+
+TEST(PIMathVector_Test, operator_Division_AssignmentVector) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.5);
+    vector1 /= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 4.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_Addition) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, 7.72, 3));
+}
+
+TEST(PIMathVector_Test, operator_Subtraction) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, 4.28, 3));
+}
+
+TEST(PIMathVector_Test, operator_MultiplicationValue) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 * 4.0, 24.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_MultiplicationVector1) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_MultiplicationVector2) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1[0] = 1.0;
+    vector2[1] = 1.0;
+    ASSERT_TRUE(((vector1 * vector2)[0] == 0.0) && ((vector1 * vector2)[1] == 0.0) && ((vector1 * vector2)[2] == 1.0));
+}
+
+TEST(PIMathVector_Test, operator_DivisionVector) {
+    PIMathVector<double> vector1(3u);
+    vector1.fill(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 / 4.0, 1.5, 3));
+}
+
+TEST(PIMathVector_Test, operator_MultiplVect) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, 30.0, 3));
+}
+
+TEST(PIMathVector_Test, operator_absDotProduct) {
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vector1.fill(6.0);
+    vector2.fill(5.0);
+    ASSERT_TRUE(90.0 == (vector1 ^ vector2));
+}
+
+TEST(PIMathVector_Test, distToLine) {
+    PIMathVector<double> vect(3u);
+    PIMathVector<double> vector1(3u);
+    PIMathVector<double> vector2(3u);
+    vect.fill(6.0);
+    vector1[0] = 1.0;
+    vector2[1] = -1.0;
+    ASSERT_DOUBLE_EQ(vect.distToLine(vector1, vector2), sqrt(2.0)/2.0);
+}
diff --git a/tests/math/testpimathvectort.cpp b/tests/math/testpimathvectort.cpp
new file mode 100644
index 00000000..82125a28
--- /dev/null
+++ b/tests/math/testpimathvectort.cpp
@@ -0,0 +1,427 @@
+#include "gtest/gtest.h"
+#include "pimathvector.h"
+#include "pimathmatrix.h"
+
+const uint size = 3u;
+
+bool cmpVectorWithValue(PIMathVectorT<size, double> vector, double val, int num) {
+    bool b = true;
+    for(int i = 0; i < num; i++) {
+        if(vector[i] != val) {
+            b = false;
+        }
+    }
+    return b;
+}
+
+TEST(PIMathVectorT_Test, size) {
+    PIMathVectorT<size, double> vector;
+    ASSERT_TRUE(vector.size() == 3u);
+}
+
+TEST(PIMathVectorT_Test, fill) {
+    PIMathVectorT<size, double> vector;
+    ASSERT_TRUE(cmpVectorWithValue(vector.fill(5.0), 5.0, 3));
+}
+
+TEST(PIMathVectorT_Test, set) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector.set(vector1.fill(5.0), vector2.fill(3.0)), -2.0, 3));
+}
+
+TEST(PIMathVectorT_Test, MoveVal) {
+    PIMathVectorT<size, double> vector;
+    ASSERT_TRUE(cmpVectorWithValue(vector.move(4.0), 4.0, 3));
+}
+
+TEST(PIMathVectorT_Test, MoveVector) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vector1;
+    ASSERT_TRUE(cmpVectorWithValue(vector.move(vector1.fill(5.0)), 5.0, 3));
+}
+
+TEST(PIMathVectorT_Test, lengthSqr) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(1.0);
+    ASSERT_EQ(3.0, vector.lengthSqr());
+}
+
+TEST(PIMathVectorT_Test, length) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(1.0);
+    ASSERT_DOUBLE_EQ(sqrt(3.0), vector.length());
+}
+
+TEST(PIMathVectorT_Test, manhattanLength) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(5.0);
+    ASSERT_DOUBLE_EQ(15.0, vector.manhattanLength());
+}
+
+TEST(PIMathVectorT_Test, angleCos) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(cos(0.78539816339744830961566084581988), vector.angleCos(vec));
+}
+
+TEST(PIMathVectorT_Test, angleSin) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(cos(0.78539816339744830961566084581988), vector.angleSin(vec));
+}
+
+TEST(PIMathVectorT_Test, angleRad) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(0.78539816339744830961566084581988, vector.angleRad(vec));
+}
+
+TEST(PIMathVectorT_Test, angleDeg) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(45.0, vector.angleDeg(vec));
+}
+
+TEST(PIMathVectorT_Test, angleElevation) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    vec[1] = 1.0;
+    ASSERT_DOUBLE_EQ(-45.0, vector.angleElevation(vec));
+}
+
+TEST(PIMathVectorT_Test, projection) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vec[0] = 1.0;
+    vector[0] = 1.0;
+    vector[1] = 1.0;
+    auto vecProj = vector.projection(vec);
+    ASSERT_TRUE(vecProj == vec);
+}
+
+TEST(PIMathVectorT_Test, normalize) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector.normalize(), 5.0 / sqrt(75.0), 3u));
+}
+
+TEST(PIMathVectorT_Test, normalized) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector.normalized(), 5.0 / sqrt(75.0), 3u));
+}
+
+TEST(PIMathVectorT_Test, cross1) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue(vector1.cross(vector2), 0.0, 3));
+}
+
+TEST(PIMathVectorT_Test, cross2) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    vector1[0] = 1.0;
+    vector2[1] = 1.0;
+    ASSERT_TRUE(((vector1 * vector2)[0] == 0.0) && ((vector1 * vector2)[1] == 0.0) && ((vector1 * vector2)[2] == 1.0));
+}
+
+TEST(PIMathVectorT_Test, dot) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(5.0);
+    ASSERT_EQ(vector1.dot(vector2), 90.0);
+}
+
+TEST(PIMathVectorT_Test, isNullTrue) {
+    PIMathVectorT<size, double> vector;
+    ASSERT_TRUE(vector.isNull());
+}
+
+TEST(PIMathVectorT_Test, isNullFalse) {
+    PIMathVectorT<size, double> vector;
+    vector[0] = 6.273;
+    ASSERT_FALSE(vector.isNull());
+}
+
+TEST(PIMathVectorT_Test, isOrthoTrue) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vect;
+    vector[0] = 2.0;
+    vect[1] = 1.0;
+    ASSERT_TRUE(vector.isOrtho(vect));
+}
+
+TEST(PIMathVectorT_Test, isOrthoFalse) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vect;
+    vector[0] = 2.0;
+    vect[0] = 5.0;
+    vect[1] = 1.0;
+    ASSERT_FALSE(vector.isOrtho(vect));
+}
+
+TEST(PIMathVectorT_Test, at) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(5.5);
+    for(uint i = 0; i < 3u; i++){
+        if(vector.at(i) != 5.5){
+            ASSERT_TRUE(false);
+        }
+    }
+    ASSERT_TRUE(true);
+}
+
+TEST(PIMathVectorT_Test, operator_AssignmentValue) {
+    PIMathVectorT<size, double> vector;
+    vector = 3.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector, 3.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_AssignmentVector) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vec = 5.0;
+    vector = vec;
+    ASSERT_TRUE(cmpVectorWithValue(vector, 5.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_EqualTrue) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 7.34;
+    ASSERT_TRUE(vec == vector);
+}
+
+TEST(PIMathVectorT_Test, operator_EqualFalse) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 0.34;
+    ASSERT_FALSE(vec == vector);
+}
+
+TEST(PIMathVectorT_Test, operator_Not_EqualTrue) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 0.34;
+    ASSERT_TRUE(vec != vector);
+}
+
+TEST(PIMathVectorT_Test, operator_Not_EqualFalse) {
+    PIMathVectorT<size, double> vector;
+    PIMathVectorT<size, double> vec;
+    vector[0] = 5.12;
+    vector[1] = 7.34;
+    vec[0] = 5.12;
+    vec[1] = 7.34;
+    ASSERT_FALSE(vec != vector);
+}
+
+TEST(PIMathVectorT_Test, operator_Addition_Aassignment) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 += vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 7.72, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Subtraction_Assignment) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 -= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 4.28, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentValue) {
+    PIMathVectorT<size, double> vector1;
+    vector1.fill(6.0);
+    vector1 *= 4.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 24.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Multiplication_AssignmentVector) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    vector1 *= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 10.32, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Division_AssignmentValue) {
+    PIMathVectorT<size, double> vector1;
+    vector1.fill(6.0);
+    vector1 /= 4.0;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 1.5, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Division_AssignmentVector) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.5);
+    vector1 /= vector2;
+    ASSERT_TRUE(cmpVectorWithValue(vector1, 4.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Addition) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 + vector2, 7.72, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_Subtraction) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 - vector2, 4.28, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_MultiplicationValue) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 * 4.0, 24.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_MultiplicationVector1) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(cmpVectorWithValue((vector1 * vector2), 0.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_MultiplicationVector2) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1[0] = 1.0;
+    vector2[1] = 1.0;
+    ASSERT_TRUE(((vector1 * vector2)[0] == 0.0) && ((vector1 * vector2)[1] == 0.0) && ((vector1 * vector2)[2] == 1.0));
+}
+
+TEST(PIMathVectorT_Test, operator_DivisionVal) {
+    PIMathVectorT<size, double> vector1;
+    vector1.fill(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 / 4.0, 1.5, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_DivisionVector) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(4.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 / vector2, 1.5, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_MultiplVect) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(5.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector1 & vector2, 30.0, 3));
+}
+
+TEST(PIMathVectorT_Test, operator_absDotProduct) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(5.0);
+    ASSERT_TRUE(90.0 == (vector1 ^ vector2));
+}
+
+TEST(PIMathVectorT_Test, transposed) {
+    PIMathVectorT<size, double> vector;
+    vector.fill(6.0);
+    auto matrix = vector.transposed();
+    for(int i = 0; i < size; i++){
+        if(matrix[0][i] != 6.0)
+        {
+            ASSERT_TRUE(false);
+        }
+    }
+    ASSERT_TRUE(true);
+}
+
+TEST(PIMathVectorT_Test, filled) {
+    auto vector = PIMathVectorT<size, double>::filled(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(vector, 6.0, 3));
+}
+
+TEST(PIMathVectorT_Test, distToLine) {
+    PIMathVectorT<size, double> vect;
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size, double> vector2;
+    vect.fill(6.0);
+    vector1[0] = 1.0;
+    vector2[1] = -1.0;
+    ASSERT_DOUBLE_EQ(vect.distToLine(vector1, vector2), sqrt(2.0)/2.0);
+}
+
+TEST(PIMathVectorT_Test, turnTo) {
+    PIMathVectorT<size, double> vect;
+    vect.fill(6.0);
+    auto vector = vect.turnTo<2u, double>();
+    ASSERT_TRUE((vector.size() == 2) && (vector.size() == 2));
+}
+
+TEST(PIMathVectorT_Test, LogicalOrTrue) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1.fill(6.0);
+    vector2.fill(1.72);
+    ASSERT_TRUE(vector1 || vector2);
+}
+
+TEST(PIMathVectorT_Test, LogicalOrFalse) {
+    PIMathVectorT<size, double> vector1;
+    PIMathVectorT<size,double> vector2;
+    vector1[0] = 1.0;
+    vector2[1] = 1.0;
+    ASSERT_FALSE(vector1 || vector2);
+}
+
+TEST(PIMathVectorT_Test, sqrt) {
+    PIMathVectorT<size, double> vector1;
+    vector1.fill(36.0);
+    ASSERT_TRUE(cmpVectorWithValue(sqrt(vector1), 6.0, 3u));
+}
+
+TEST(PIMathVectorT_Test, sqr) {
+    PIMathVectorT<size, double> vector1;
+    vector1.fill(6.0);
+    ASSERT_TRUE(cmpVectorWithValue(sqr(vector1), 36.0, 3u));
+}