pip/tests/core/pistringTest.cpp

#include "gtest/gtest.h"
#include "pistring.h"
#include "pistringlist.h"

TEST(PIString_Tests, operator_concatenation_pichar){
    PIString str1 = "AB C";
    const PIChar str2 = " ";
    str1 += str2;
    PIString res = "AB C ";
    ASSERT_EQ(str1, res);
}

TEST(PIString_Tests, operator_concatenation_pichar_zero1){
    PIString str1 = "";
    const PIChar str2 = "D";
    str1 += str2;
    ASSERT_EQ(str1, "D");
}

TEST(PIString_Tests, operator_concatenation_char){
    PIString str1 = "AB C";
    const char *str2 = "D D ";
    str1 += str2;
    ASSERT_EQ(str1, "AB CD D ");
}

TEST(PIString_Tests, operator_concatenation_char_zero1){
    PIString str1 = "";
    const char *str2 = "D D ";
    str1 += str2;
    ASSERT_EQ(str1, "D D ");
}

TEST(PIString_Tests, operator_concatenation_wchar){
    PIString str1= "AB C";
    wchar_t str2[] = L"C";
    str1 += str2;
    ASSERT_EQ(str1, "AB CC");
}

TEST(PIString_Tests, operator_concatenation_wchar_zero1){
    PIString str1 = "";
    wchar_t str2[] = L"C";
    str1 += str2;
    ASSERT_EQ(str1, "C");
}

TEST(PIString_Tests, operator_concatenation_pistring){
    PIString str1 = "AB C";
    PIString str2 = " CD  ";
    str1 += str2;
    ASSERT_EQ(str1, "AB C CD  ");
}

TEST(PIString_Tests, operator_concatenation_pistring_zero1){
    PIString str1 = "";
    PIString str2 = "D DD";
    str1 += str2;
    ASSERT_EQ(str1, "D DD");
}

TEST(PIString_Tests, operator_concatenation_pistring_zero2){
    PIString str1 = "AB C";
    PIString str2 = "";
    str1 += str2;
    ASSERT_EQ(str1, "AB C");
}

TEST(PIString_Tests, operator_concatenation_pistring_zero_zero){
    PIString str1;
    PIString str2;
    str1 += str2;
    ASSERT_EQ(str1, "");
}

TEST(PIString_Tests, operator_concatenation_piByteArray){
    PIString str1 = "AB C";
    PIByteArray str2;
    str2.append('g');
    str1 += str2;
    ASSERT_EQ(str1, "AB Cg");
}

TEST(PIString_Tests, operator_concatenation_piByteArray_zero1){
    PIString str1 = "";
    PIByteArray str2;
    str2.append('0');
    str1 += str2;
    ASSERT_EQ(str1, "0");
}

TEST(PIString_Tests, operator_concatenation_piByteArray_zero2){
    PIString str1 = "AB C";
    PIByteArray str2;
    str1 += str2;
    ASSERT_EQ(str1, "AB C");
}

TEST(PIString_Tests, operator_concatenation_piByteArray_zero_zero){
    PIString str1;
    PIByteArray str2;
    str1 += str2;
    ASSERT_EQ(str1, "");
}

TEST(PIString_Tests, construct_pistring){
    PIString str1 = "New";
    ASSERT_EQ(str1, PIString("New"));
}

TEST(PIString_Tests, construct_pichar){
    PIChar str1 = 'n';
    PIString res = "n";
    ASSERT_EQ(res, PIString(str1));
}

TEST(PIString_Tests, construct_char){
    char str1 = 'n';
    PIString res = "n";
    ASSERT_EQ(res, PIString(str1));
}

TEST(PIString_Tests, construct_chars){
    char str1[] = "mew";
    PIString res = "mew";
    ASSERT_EQ(res, PIString(str1));
}

TEST(PIString_Tests, construct_wchar_t){
    wchar_t str1[] = L"gav";
    PIString res = "gav";
    ASSERT_EQ(res, PIString(str1));
}

TEST(PIString_Tests, construct_pibyte_array){
    PIByteArray str1;
    str1.append('m');
    PIString res = "m";
    ASSERT_EQ(res, PIString(str1));
}

TEST(PIString_Tests, construct_pichar_size){
    PIChar *str1 = new PIChar[3];
    str1[0] = 'n';
    str1[1] = 'e';
    str1[2] = 'w';
    PIString res = "new";
    ASSERT_EQ(res, PIString(str1, 3));
}

TEST(PIString_Tests, construct_char_size){
    char str1[] = "good";
    PIString res = "good";
    ASSERT_EQ(res, PIString(str1, 4));
}

TEST(PIString_Tests, construct_char_len){
    char str1 = 'n';
    PIString res = "nnn";
    ASSERT_EQ(res, PIString(3, str1));
}

TEST(PIString_Tests, construct_pichar_len){
    PIChar str1 = 'n';
    PIString res = "nnnnn";
    ASSERT_EQ(res, PIString(5, str1));
}

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;
    PIString res = "shift good";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_pichar){
    PIString str1 = "shif";
    PIChar str2 = 't';
    str1 << str2;
    PIString res = "shift";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_char){
    PIString str1 = "shif";
    char str2[] = "t chat";
    str1 << str2;
    PIString res = "shift chat";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_wchar_t){
    PIString str1 = "shif";
    wchar_t str2[] = L"t cc";
    str1 << str2;
    PIString res = "shift cc";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_int){
    PIString str1 = "shift ";
    int numb = -2147483648;
    str1 << numb;
    PIString res = "shift -2147483648";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_uint){
    PIString str1 = "shift ";
    uint numb = 4294967295;
    str1 << numb;
    PIString res = "shift 4294967295";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_short){
    PIString str1 = "shift ";
    short numb = -32768;
    str1 << numb;
    PIString res = "shift -32768";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_ushort){
    PIString str1 = "shift ";
    ushort numb = 65535;
    str1 << numb;
    PIString res = "shift 65535";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_long){
    PIString str1 = "shift ";
    long numb = -2147483648;
    str1 << numb;
    PIString res = "shift -2147483648";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_ulong){
    PIString str1 = "shift ";
    ulong numb = 4294967295;
    str1 << numb;
    PIString res = "shift 4294967295";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_llong){
    PIString str1 = "shift ";
    llong numb = -9223372036854775807;
    str1 << numb;
    PIString res = "shift -9223372036854775807";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_ullong){
    PIString str1 = "shift ";
    ullong numb = 1844674407370955161;
    str1 << numb;
    PIString res = "shift 1844674407370955161";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_float){
    PIString str1 = "shift ";
    float numb = -67.88999939;
    str1 << numb;
    PIString res = "shift -67.88999939";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_shift_double){
    PIString str1 = "shift ";
    double numb = 13.34300000;
    str1 << numb;
    PIString res = "shift 13.34300000";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, prepend){
    PIString str1 = "idea";
    PIString str2 = "Good ";
    str1.prepend(str2);
    PIString res = "Good idea";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, append){
    PIString str1 = "Good";
    PIString str2 = " idea";
    str1.append(str2);
    PIString res = "Good idea";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, mid){
    PIString str1 = "Good idea for new project 144";
    PIString res = "fo";
    ASSERT_EQ(res, str1.mid(10, 2));
}

TEST(PIString_Tests, mid_len_0){
    PIString str1 = "Good idea for new project 144";
    PIString res = "";
    ASSERT_EQ(res, str1.mid(10, 0));
}


TEST(PIString_Tests, mid_start_more){
    PIString str1 = "Good idea for new project 144";
    PIString res = "";
    ASSERT_EQ(res, str1.mid(1000, 0));
}

TEST(PIString_Tests, mid_len_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "for new project 144";
    ASSERT_EQ(res, str1.mid(10, -2));
}

TEST(PIString_Tests, mid_len_more){
    PIString str1 = "Good idea for new project 144";
    PIString res = "for new project 144";
    ASSERT_EQ(res, str1.mid(10, 100));
}

TEST(PIString_Tests, subString){
    PIString str1 = "Good idea for new project 144";
    PIString res = "for new project 144";
    ASSERT_EQ(res, str1.mid(10, 46));
}

TEST(PIString_Tests, mid_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.mid(-10, 47));
}

TEST(PIString_Tests, subString_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Go";
    ASSERT_EQ(res, str1.mid(-10, 12));
}

TEST(PIString_Tests, left){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Go";
    ASSERT_EQ(res, str1.left(2));
}

TEST(PIString_Tests, left_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "";
    ASSERT_EQ(res, str1.left(-2));
}

TEST(PIString_Tests, right){
    PIString str1 = "Good idea for new project 144";
    PIString res = "44";
    ASSERT_EQ(res, str1.right(2));
}

TEST(PIString_Tests, right_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "";
    ASSERT_EQ(res, str1.right(-2));
}

TEST(PIString_Tests, cutMid){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good for new project 144";
    ASSERT_EQ(res, str1.cutMid(5,5));
}

TEST(PIString_Tests, cutMid_len_zero){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.cutMid(5,0));
}

TEST(PIString_Tests, cutMid_len_min){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good ";
    ASSERT_EQ(res, str1.cutMid(5,-2));
}

TEST(PIString_Tests, cutMid_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "ood idea for new project 144";
    ASSERT_EQ(res, str1.cutMid(-5, 6));
}

TEST(PIString_Tests, cutMid_zero){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.cutMid(-5, 5));
}

TEST(PIString_Tests, cutleft){
    PIString str1 = "Good idea for new project 144";
    PIString res = "od idea for new project 144";
    ASSERT_EQ(res, str1.cutLeft(2));
}

TEST(PIString_Tests, cutleft_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.cutLeft(-2));
}

TEST(PIString_Tests, cutright){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 1";
    ASSERT_EQ(res, str1.cutRight(2));
}

TEST(PIString_Tests, cutright_minus){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.cutRight(-2));
}

TEST(PIString_Tests, trim){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.trim());
}

TEST(PIString_Tests, trim_without){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.trim());
}

TEST(PIString_Tests, trim_link){
    PIString str1 = " Good idea for new project 144 ";
    PIString &str2 = str1.trim();
    str1 = "link";
    PIString res = "link";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, trimmed){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.trimmed());
}

TEST(PIString_Tests, trimmed_without){
    PIString str1 = "Good idea for new project 144";
    PIString res = "Good idea for new project 144";
    ASSERT_EQ(res, str1.trimmed());
}

TEST(PIString_Tests, replace){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = " Good thin for new project 144 ";
    ASSERT_EQ(res, str1.replace(6,4, "thin"));
}

TEST(PIString_Tests, replace_more){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = " Good thin";
    ASSERT_EQ(res, 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";
    PIString res = "link";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, replace_minus){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "BAD idea for new project 144 ";
    ASSERT_EQ(res, str1.replace(0, 5, "BAD"));
}

TEST(PIString_Tests, replace_zero){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "thin Good idea for new project 144 ";
    ASSERT_EQ(res, str1.replace(0, 0, "thin"));
}

TEST(PIString_Tests, replace_all){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "BAD";
    ASSERT_EQ(res, str1.replaced(0, 100, "BAD"));
}

TEST(PIString_Tests, replaced){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = " Good thin for new project 144 ";
    ASSERT_EQ(res, str1.replaced(6,4, "thin"));
}

TEST(PIString_Tests, replaced_minus){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "BAD idea for new project 144 ";
    ASSERT_EQ(res, str1.replaced(0, 5, "BAD"));
}

TEST(PIString_Tests, replaced_zero){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "thin Good idea for new project 144 ";
    ASSERT_EQ(res, str1.replaced(0, 0, "thin"));
}


TEST(PIString_Tests, replaced_all){
    PIString str1 = " Good idea for new project 144 ";
    PIString res = "thin";
    ASSERT_EQ(res, 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);
    PIString res = " bad idea for new Good project 144 ";
    ASSERT_EQ(res, 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";
    PIString res = "link";
    ASSERT_EQ(res, 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);
    PIString res = "  idea for new Good project 144 ";
    ASSERT_EQ(res, 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);
    PIString res = " bad idea for new Good project 144 ";
    ASSERT_EQ(res, 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);
    PIString res = "  idea for new Good project 144 ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, replaceall){
    PIString str1 = " Good idea for new Good project 144 ";
    str1.replaceAll("Good", "bad");
    PIString res = " bad idea for new bad project 144 ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, replaceall_no_find){
    PIString str1 = " Good idea for new Good project 144 ";
    str1.replaceAll("God", "bad");
    PIString res = " Good idea for new Good project 144 ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, replaceall_str){
    PIString str1 = " Good idea for new Good project 144 ";
    PIString str2 = str1.replaceAll("Good", "bad");
    PIString res = " bad idea for new bad project 144 ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, replaceall_str_no_find){
    PIString str1 = " Good idea for new Good project 144 ";
    PIString str2 = str1.replaceAll("God", "bad");
    PIString res = " Good idea for new Good project 144 ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, replaceall_link){
    PIString str1 = " Good idea for new Good project 144 ";
    PIString &str2 = str1.replaceAll("Good", "bad");
    PIString res = " bad idea for new bad project 144 ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, replaceall_link_change){
    PIString str1 = " Good idea for new Good project 144 ";
    PIString &str2 = str1.replaceAll("Good", "bad");
    str1 = "link";
    PIString res = "link";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, repeat){
    PIString str1 = "string ";
    PIString str2 = str1.repeat(6);
    PIString res = "string string string string string string ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, repeat_zero){
    PIString str1 = "string ";
    PIString str2 = str1.repeat(0);
    PIString res = "string ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, repeat_link){
    PIString str1 = "string ";
    PIString &str2 = str1.repeat(6);
    str1 = "link";
    PIString res = "link";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, repeated){
    PIString str1 = "string ";
    str1.repeat(6);
    PIString res = "string string string string string string ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, repeated_zero){
    PIString str1 = "string ";
    str1.repeat(0);
    PIString res = "string ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, insert_char){
    PIString str1 = "strng ";
    char sym = 'i';
    str1.insert(3, sym);
    PIString res = "string ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, insert_pichar){
    PIString str1 = "strng ";
    PIChar sym = 'i';
    str1.insert(3, sym);
    PIString res = "string ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, insert_pistring){
    PIString str1 = "string out";
    PIString str2 = " go";
    str1.insert(6, str2);
    PIString res = "string go out";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, insert_chars){
    PIString str1 = "see boy";
    char str2[] = " big";
    str1.insert(3, str2);
    PIString res = "see big boy";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, expandRightTo){
    PIString str1 = "see boy ";
    PIChar symbol = "x";
    str1.expandRightTo(11, symbol);
    PIString res = "see boy xxx";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, expandRightTo_null){
    PIString str1 = "see boy ";
    PIChar symbol = "x";
    str1.expandRightTo(0, symbol);
    PIString res = "see boy ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, expandLeftTo){
    PIString str1 = " see boy";
    PIChar symbol = "x";
    str1.expandLeftTo(11, symbol);
    PIString res = "xxx see boy";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, expandLeftTo_null){
    PIString str1 = "see boy ";
    PIChar symbol = "x";
    str1.expandLeftTo(0, symbol);
    PIString res = "see boy ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, quote){
    PIString str1 = "see boy";
    PIChar symbol = " ";
    str1.quote(symbol);
    PIString res = " see boy ";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, quote_link){
    PIString str1 = "see boy";
    PIChar symbol = " ";
    PIString &str2 = str1.quote(symbol);
    str1 = "link";
    PIString res = "link";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, quoted){
    PIString str1 = "see boy";
    PIChar symbol = " ";
    PIString str2 = str1.quoted(symbol);
    PIString res = " see boy ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, reverse){
    PIString str1 = "see boy";
    PIString &str2 = str1.reverse();
    PIString res = "yob ees";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, reverse_link){
    PIString str1 = "see boy";
    PIString &str2 = str1.reverse();
    str1 = "yes";
    PIString res = "yes";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, reversed){
    PIString str1 = "see boy";
    PIString str2 = str1.reversed();
    PIString res = "yob ees";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, elide){
    PIString str1 = "BMSTU is best university in space";
    PIString &str2 = str1.elide(8, 1);
    PIString res = "BMSTU ..";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, elide_small){
    PIString str1 = "BMSTU is best university in space";
    PIString &str2 = str1.elide(2, 1);
    PIString res = "..";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, elide_all){
    PIString str1 = "BMSTU is best university in space";
    PIString &str2 = str1.elide(100, 1);
    PIString res = "BMSTU is best university in space";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, elide_link){
    PIString str1 = "BMSTU is best university in space";
    PIString &str2 = str1.elide(8, 1);
    str1 = "space";
    PIString res = "space";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, elided){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.elided(8, 1);
    PIString res = "BMSTU ..";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takemid){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeMid(9, 4);
    PIString res = "best";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeleft){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeLeft(5);
    PIString res = "BMSTU";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeright){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeRight(5);
    PIString res = "space";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takesymbol){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeSymbol();
    PIString res = "B";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takesymbol_with_rubbish){
    PIString str1 = " \t \n \r BMSTU is best university in space";
    PIString str2 = str1.takeSymbol();
    PIString res = "B";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takesymbol_without){
    PIString str1 = " \t \n \r ";
    PIString str2 = str1.takeSymbol();
    PIString res = "";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeword){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeWord();
    PIString res = "BMSTU";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeword_space){
    PIString str1 = "   \r\n\tBMSTU is best university in space";
    PIString str2 = str1.takeWord();
    PIString res = "BMSTU";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeword_without_word){
    PIString str1 = "   \r\n\t";
    PIString str2 = str1.takeWord();
    PIString res = "";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takecword){
    PIString str1 = "_6 BMSTU is best university in space";
    PIString str2 = str1.takeCWord();
    PIString res = "_6";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takecword_space){
    PIString str1 = "  \t\r\n_6 BMSTU is best university in space";
    PIString str2 = str1.takeCWord();
    PIString res = "_6";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takecword_space_w){
    PIString str1 = "  \t\r\n BMSTU is best university in space";
    PIString str2 = str1.takeCWord();
    PIString res = "BMSTU";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takecword_not_cword){
    PIString str1 = "  \t\r\n ";
    PIString str2 = str1.takeCWord();
    PIString res = "";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeline){
    PIString str1 = "BMSTU is best\n university in space";
    PIString str2 = str1.takeLine();
    PIString res = "BMSTU is best";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeline_without){
    PIString str1 = "BMSTU is best";
    PIString str2 = str1.takeLine();
    PIString res = "";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takeline_first){
    PIString str1 = "\nBMSTU is best";
    PIString str2 = str1.takeLine();
    PIString res = "";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takenumber){
    PIString str1 = "6.6";
    PIString str2 = str1.takeNumber();
    PIString res = "6.6";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takenumber_sign){
    PIString str1 = "-66";
    PIString str2 = str1.takeNumber();
    PIString res = "-66";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takenumber_suffix){
    PIString str1 = "66L";
    PIString str2 = str1.takeNumber();
    PIString res = "66L";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takerange){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeRange('B', 'i', ' ');
    PIString res = "MSTU is best un";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takerange_without_shield){
    PIString str1 = "BMSTU is best university in space";
    PIString str2 = str1.takeRange('B', 'i');
    PIString res = "MSTU ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takerange_space){
    PIString str1 = " \t\r\nBMSTU is best university in space";
    PIString str2 = str1.takeRange('B', 'i', ' ');
    PIString res = "MSTU is best un";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, takerange_without_shield_space){
    PIString str1 = " \t\r\nBMSTU is best university in space";
    PIString str2 = str1.takeRange('B', 'i');
    PIString res = "MSTU ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, inBrackets){
    PIString str1 = "BMSTU is (best) university in space";
    PIString str2 = str1.inBrackets('(', ')');
    PIString res = "best";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, inBrackets_end_start){
    PIString str1 = "BMSTU )is (best) university in space";
    PIString str2 = str1.inBrackets('(', ')');
    PIString res = "best";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, inBrackets_without){
    PIString str1 = "BMSTU )is (best) university in space";
    PIString str2 = str1.inBrackets('0', '1');
    PIString res = "";
    ASSERT_EQ(res, 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();
    PIString res = "BMSTU is (best) university in space\n";
    ASSERT_EQ(res, data);
}

TEST(PIString_Tests, dataconsole){
    PIString str1 = "BMSTU is (best) university in space\n";
    const char *data = str1.dataConsole();
    PIString res = "BMSTU is (best) university in space\n";
    ASSERT_EQ(res, data);
}

TEST(PIString_Tests, dataUTF8){
    PIString str1 = "BMSTU is (best) university in space\n";
    const char *data = str1.dataUTF8();
    PIString res = "BMSTU is (best) university in space\n";
    ASSERT_EQ(res, data);
}

TEST(PIString_Tests, dataAScii){
    PIString str1 = "BMSTU is (best) university in space\n";
    const char *data = str1.dataAscii();
    PIString res = "BMSTU is (best) university in space\n";
    ASSERT_EQ(res, 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_EQ(list[1], list[0]);
}

TEST(PIString_Tests, split_sec){
    PIString str1 = " mirrow best detail ";
    PIStringList list = str1.split("best");
    PIString res = " mirrow ";
    PIString res2 = " detail ";
    ASSERT_EQ(res, list[0]);
    ASSERT_EQ(list[1], res2);
}

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_EQ(list[0], " mirrow best mirrow ");
}

TEST(PIString_Tests, toUpperCase){
    PIString str1 = " miRrow ";
    PIString str2 = str1.toUpperCase();
    PIString res = " MIRROW ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, toLowerCase){
    PIString str1 = " MIrROW ";
    PIString str2 = str1.toLowerCase();
    PIString res = " mirrow ";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, toNativeDecimalPoints){
    PIString str1 = "4546,878";
    PIString str2 = str1.toNativeDecimalPoints();
    PIString res = "4546.878";
    ASSERT_EQ(res, 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);
    PIString res = "131";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_zero){
    PIString str1 = " String";
    const short val = 0;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_base_minus){
    PIString str1 = " String";
    const short val = -10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "-A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ushort){
    PIString str1 = " String";
    const ushort val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, 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);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ushort_base_minus){
    PIString str1 = " String";
    const ushort val = 10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_int){
    PIString str1 = " String";
    const int val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_int_zero){
    PIString str1 = " String";
    const int val = 0;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_int_base_minus){
    PIString str1 = " String";
    const int val = -10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "-A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_uint){
    PIString str1 = " String";
    const uint val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, 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);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_uint_base_minus){
    PIString str1 = " String";
    const uint val = 10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_long){
    PIString str1 = " String";
    const long val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_long_zero){
    PIString str1 = " String";
    const long val = 0;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_long_base_minus){
    PIString str1 = " String";
    const long val = -10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "-A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ulong){
    PIString str1 = " String";
    const ulong val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, 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);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ulong_base_minus){
    PIString str1 = " String";
    const ulong val = 10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_llong){
    PIString str1 = " String";
    const llong val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_llong_zero){
    PIString str1 = " String";
    const llong val = 0;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_llong_base_minus){
    PIString str1 = " String";
    const llong val = -10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "-A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ullong){
    PIString str1 = " String";
    const ullong val = 131;
    bool ok;
    str1.setNumber(val, 10, &ok);
    PIString res = "131";
    ASSERT_EQ(res, 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);
    PIString res = "0";
    ASSERT_EQ(res, 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);
    PIString res = "";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ullong_base_minus){
    PIString str1 = " String";
    const ullong val = 10;
    bool ok;
    str1.setNumber(val, 16, &ok);
    PIString res = "A";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_float){
    PIString str1 = " String";
    const float val = 131.132;
    str1.setNumber(val, 'f', 3);
    PIString res = "131.132";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_double){
    PIString str1 = " String";
    const double val = 131.1324334;
    str1.setNumber(val, 'f', 7);
    PIString res = "131.1324334";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setNumber_ldouble){
    PIString str1 = " String";
    const ldouble val = 131.1324334;
    str1.setNumber(val, 'f', 7);
    PIString res = "131.1324334";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, setReadableSize){
    PIString str1 = " ITELMA";
    PIString res = "1023 B";
    ASSERT_EQ(res, str1.setReadableSize(1023));
}

TEST(PIString_Tests, setReadableSize_kb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 kB";
    ASSERT_EQ(res, str1.setReadableSize(1024));
}

TEST(PIString_Tests, setReadableSize_mb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 MB";
    ASSERT_EQ(res, str1.setReadableSize(1024*1024));
}

TEST(PIString_Tests, setReadableSize_gb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 GB";
    ASSERT_EQ(res, str1.setReadableSize(1024*1024*1024));
}

TEST(PIString_Tests, setReadableSize_tb){
    PIString str1 = " ITELMA";
    llong val = 99999999999999;
    PIString res = "90.9 TB";
    ASSERT_EQ(res, str1.setReadableSize(val));
}

TEST(PIString_Tests, setReadableSize_pb){
    PIString str1 = " ITELMA";
    llong val = 999999999999999999;
    PIString res = "888.1 PB";
    ASSERT_EQ(res, str1.setReadableSize(val));
}

TEST(PIString_Tests, fromNumber){
    PIString str1 = " String";
    const short val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, str1.fromNumber(val, 10, &ok));
}

TEST(PIString_Tests, fromNumberr_zero){
    PIString str1 = " String";
    const short val = 0;
    bool ok;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_base_minus){
    PIString str1 = " String";
    const short val = -10;
    bool ok;
    PIString res = "-A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_ushort){
    PIString str1 = " String";
    const ushort val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, 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;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_ushort_base_minus){
    PIString str1 = " String";
    const ushort val = 10;
    bool ok;
    PIString res = "A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_int){
    PIString str1 = " String";
    const int val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, str1.fromNumber(val, 10, &ok));
}

TEST(PIString_Tests, fromNumber_int_zero){
    PIString str1 = " String";
    const int val = 0;
    bool ok;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_int_base_minus){
    PIString str1 = " String";
    const int val = -10;
    bool ok;
    PIString res = "-A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_uint){
    PIString str1 = " String";
    const uint val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, 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;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_uint_base_minus){
    PIString str1 = " String";
    const uint val = 10;
    bool ok;
    PIString res = "A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_long){
    PIString str1 = " String";
    const long val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, str1.fromNumber(val, 10, &ok));
}

TEST(PIString_Tests, fromNumber_long_zero){
    PIString str1 = " String";
    const long val = 0;
    bool ok;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_long_base_minus){
    PIString str1 = " String";
    const long val = -10;
    bool ok;
    PIString res = "-A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_ulong){
    PIString str1 = " String";
    const ulong val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, 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;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_ulong_base_minus){
    PIString str1 = " String";
    const ulong val = 10;
    bool ok;
    PIString res = "A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_llong){
    PIString str1 = " String";
    const llong val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, str1.fromNumber(val, 10, &ok));
}

TEST(PIString_Tests, fromNumber_llong_zero){
    PIString str1 = " String";
    const llong val = 0;
    bool ok;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_llong_base_minus){
    PIString str1 = " String";
    const llong val = -10;
    bool ok;
    PIString res = "-A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_ullong){
    PIString str1 = " String";
    const ullong val = 131;
    bool ok;
    PIString res = "131";
    ASSERT_EQ(res, 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;
    PIString res = "0";
    ASSERT_EQ(res, 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;
    PIString res = "";
    ASSERT_EQ(res, str1.fromNumber(val, 1, &ok));
}

TEST(PIString_Tests, fromNumber_ullong_base_minus){
    PIString str1 = " String";
    const ullong val = 10;
    bool ok;
    PIString res = "A";
    ASSERT_EQ(res, str1.fromNumber(val, 16, &ok));
}

TEST(PIString_Tests, fromNumber_float){
    PIString str1 = " String";
    const float val = 131.132;
    PIString res = "131.132";
    ASSERT_EQ(res, str1.fromNumber(val, 'f', 3));
}

TEST(PIString_Tests, fromNumber_double){
    PIString str1 = " String";
    const double val = 131.1324334;
    PIString res = "131.1324334";
    ASSERT_EQ(res, str1.fromNumber(val, 'f', 7));
}

TEST(PIString_Tests, fromNumber_ldouble){
    PIString str1 = " String";
    const ldouble val = 131.1324334;
    PIString res = "131.1324334";
    ASSERT_EQ(res, str1.fromNumber(val, 'f', 7));
}

TEST(PIString_Tests, fromBool_true){
    PIString str1;
    bool val = true;
    PIString res = "true";
    ASSERT_EQ(res, str1.fromBool(val));
}

TEST(PIString_Tests, fromBool_false){
    PIString str1;
    bool val = false;
    PIString res = "false";
    ASSERT_EQ(res, str1.fromBool(val));
}

TEST(PIString_Tests, from_Console){
    PIString str1;
    char s[] = "true boy";
    PIString res = "true boy";
    ASSERT_EQ(res, str1.fromConsole(s));
}

TEST(PIString_Tests, from_System){
    PIString str1;
    char s[] = "true boy";
    PIString res = "true boy";
    ASSERT_EQ(res, str1.fromSystem(s));
}

TEST(PIString_Tests, from_UTF8){
    PIString str1;
    char s[] = "true boy";
    PIString res = "true boy";
    ASSERT_EQ(res, 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');
    PIString res = "true";
    ASSERT_EQ(res, str1.fromUTF8(s));
}

TEST(PIString_Tests, from_Ascii){
    PIString str1;
    char s[] = "true boy";
    PIString res = "true boy";
    ASSERT_EQ(res, str1.fromAscii(s));
}

TEST(PIString_Tests, from_Codepage){
    PIString str1 = "Nul";
    char s[] = "true";
    char c[] = "utf8";
    PIString str2 = str1.fromCodepage(s, c);
    PIString res = "true";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, ReadableSize){
    PIString str1 = " ITELMA";
    PIString res = "1023 B";
    ASSERT_EQ(res, str1.readableSize(1023));
}

TEST(PIString_Tests, readableSize_kb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 kB";
    ASSERT_EQ(res, str1.readableSize(1024));
}

TEST(PIString_Tests, readableSize_mb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 MB";
    ASSERT_EQ(res, str1.readableSize(1024*1024));
}

TEST(PIString_Tests, readableSize_gb){
    PIString str1 = " ITELMA";
    PIString res = "1.0 GB";
    ASSERT_EQ(res, str1.readableSize(1024*1024*1024));
}

TEST(PIString_Tests, readableSize_tb){
    PIString str1 = " ITELMA";
    llong val = 99999999999999;
    PIString res = "90.9 TB";
    ASSERT_EQ(res, str1.readableSize(val));
}

TEST(PIString_Tests, readableSize_pb){
    PIString str1 = " ITELMA";
    llong val = 999999999999999999;
    PIString res = "888.1 PB";
    ASSERT_EQ(res, str1.readableSize(val));
}

TEST(PIString_Tests, removeAll_char){
    PIString str1 = "A very strong programmer wrote this code";
    char v = ' ';
    PIString res = "Averystrongprogrammerwrotethiscode";
    ASSERT_EQ(res, str1.removeAll(v));
}

TEST(PIString_Tests, removeAll_pistring){
    PIString str1 = "A very strong programmer wrote this code";
    PIString v = "very strong ";
    PIString res = "A programmer wrote this code";
    ASSERT_EQ(res, str1.removeAll(v));
}

TEST(PIString_Tests, operator_ba_pstr){
    PIString str1 = '1';
    PIByteArray s;
    s << str1;
    PIString res = "010000003100";
    ASSERT_EQ(res, 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;
    PIString res = "1true";
    ASSERT_EQ(res, str1);
}

TEST(PIString_Tests, operator_plus_pstr_pstr){
    PIString str1 = "first ";
    PIString str2 = "second";
    PIString res = "first second";
    ASSERT_EQ(res, str1 + str2);
}

TEST(PIString_Tests, operator_plus_pstr_chars){
    PIString str1 = "first ";
    char str2[] = "second";
    PIString res = "first second";
    ASSERT_EQ(res, str1 + str2);
}

TEST(PIString_Tests, operator_plus_chars_pstr){
    PIString str1 = "first";
    char str2[] = "second ";
    PIString res = "second first";
    ASSERT_EQ(res, str2 + str1);
}

TEST(PIString_Tests, version_Compare){
    ASSERT_EQ(-1, versionCompare("1.0.0_rc2-999", "1.0.1_rc2-999"));
}

TEST(PIString_Tests, version_Compare_eq){
    ASSERT_EQ(0, versionCompare(".2-alpha", "0.2_alpha"));
}

TEST(PIString_Tests, version_Compare_more){
    ASSERT_EQ(1, versionCompare("1.0.0", "0.9.2"));
}

TEST(PIString_Tests, version_Compare_component){
    ASSERT_EQ(0, versionCompare("1.0.0_r1", "1.0.0", 3));
}

TEST(PIString_Tests, version_Normalize){
    PIString str1 = "first second";
    PIString res = "0.0_first second";
    ASSERT_EQ(res, versionNormalize(str1));
}

TEST(PIString_Tests, pi_Hash){
    PIString str1 = "first";
    ASSERT_EQ(898448032, piHash(str1));
}

TEST(PIString_Tests, pi_Swap){
    PIString str1 = "first";
    PIString str2 = "second";
    piSwap(str1, str2);
    PIString res = "first";
    ASSERT_EQ(res, str2);
}

TEST(PIString_Tests, piSwap_sec){
    PIString str1 = "first";
    PIString str2 = "second";
    piSwap(str1, str2);
    PIString res = "second";
    ASSERT_EQ(res, str1);
}