pip/tests/core/piStringListTest.cpp

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

using namespace std;

TEST(PIStringList_Tests, construct_empty){
    PIStringList lis;
    ASSERT_TRUE(lis.isEmpty());
}

TEST(PIStringList_Tests, construct_one_str_size){
    PIString str1 = "first string";
    PIStringList lis {str1};
    ASSERT_EQ(lis.length(),1);
}

TEST(PIStringList_Tests, construct_one_str_data){
    PIString str1 = "first string";
    PIStringList lis {str1};
    ASSERT_EQ(str1, lis[0]);
}

TEST(PIStringList_Tests, construct_one_str_rvalue_size){
    PIString str1 = "first string";
    PIStringList lis {"first string"};
    ASSERT_EQ(lis.length(), 1);
}

TEST(PIStringList_Tests, construct_one_str_rvalue_data){
    PIString str1 = "first string";
    PIStringList lis {"first string"};
    ASSERT_EQ(str1, lis[0]);
}
TEST(PIStringList_Tests, construct_two_str_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList lis {str1, str2};
    ASSERT_EQ(lis.length(), 2);
}

TEST(PIStringList_Tests, construct_two_str_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList lis {str1, str2};
    ASSERT_EQ(str1, lis[0]);
    ASSERT_EQ(str2, lis[1]);
}

TEST(PIStringList_Tests, construct_two_str_rvalue_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList lis {"first string", "second string"};
    ASSERT_EQ(lis.length(), 2);
}

TEST(PIStringList_Tests, construct_two_str_rvalue_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList lis {"first string", "second string"};
    ASSERT_EQ(str1, lis[0]);
    ASSERT_EQ(lis[1], str2);
}

TEST(PIStringList_Tests, construct_three_str_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIStringList lis {str1, str2, str3};
    ASSERT_EQ(lis.length(),3);
}

TEST(PIStringList_Tests, construct_three_str_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIStringList lis {str1, str2, str3};
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
}

TEST(PIStringList_Tests, construct_three_str_rvalue_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIStringList lis {"first string", "second string", "third string"};
    ASSERT_EQ(lis.length(), 3);
}

TEST(PIStringList_Tests, construct_three_str_rvalue_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIStringList lis {"first string", "second string", "third string"};
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
}

TEST(PIStringList_Tests, construct_four_str_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, construct_four_str_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
    ASSERT_EQ(lis[3], str4);
}

TEST(PIStringList_Tests, construct_four_str_rvalue_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {"first string", "second string", "third string", "fourth string"};
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, construct_four_str_rvalue){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {"first string", "second string", "third string", "fourth string"};
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
    ASSERT_EQ(lis[3], str4);
}

TEST(PIStringList_Tests, construct_list_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList list {lis};
    ASSERT_EQ(list.length(), 4);
}

TEST(PIStringList_Tests, construct_list_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList list {lis};
    ASSERT_EQ(list[0], str1);
    ASSERT_EQ(list[1], str2);
    ASSERT_EQ(list[2], str3);
    ASSERT_EQ(list[3], str4);
}

TEST(PIStringList_Tests, construct_list_rvalue_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {"first string", "second string", "third string", "fourth string"};
    PIStringList list {move(lis)};
    ASSERT_EQ(list.length(), 4);
}

TEST(PIStringList_Tests, construct_list_rvalue_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {"first string", "second string", "third string", "fourth string"};
    PIStringList list {move(lis)};
    ASSERT_EQ(list[0], str1);
    ASSERT_EQ(list[1], str2);
    ASSERT_EQ(list[2], str3);
    ASSERT_EQ(list[3], str4);
}

TEST(PIStringList_Tests, construct_pivect_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIVector<PIString> vect;
    vect.append(str1);
    vect.append(str2);
    vect.append(str3);
    vect.append(str4);
    PIStringList list {vect};
    ASSERT_EQ(list.length(), 4);
}

TEST(PIStringList_Tests, construct_pivect_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIVector<PIString> vect;
    vect.append(str1);
    vect.append(str2);
    vect.append(str3);
    vect.append(str4);
    PIStringList list {vect};
    ASSERT_EQ(list[0], str1);
    ASSERT_EQ(list[1], str2);
    ASSERT_EQ(list[2], str3);
    ASSERT_EQ(list[3], str4);
}

TEST(PIStringList_Tests, construct_list_pideq_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIDeque<PIString> deq;
    deq.append(str1);
    deq.append(str2);
    deq.append(str3);
    deq.append(str4);
    PIStringList list {deq};
    ASSERT_EQ(list.length(), 4);
}

TEST(PIStringList_Tests, construct_list_pideq_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIDeque<PIString> deq;
    deq.append(str1);
    deq.append(str2);
    deq.append(str3);
    deq.append(str4);
    PIStringList list {deq};
    ASSERT_EQ(list[0], str1);
    ASSERT_EQ(list[1], str2);
    ASSERT_EQ(list[2], str3);
    ASSERT_EQ(list[3], str4);
}

TEST(PIStringList_Tests, join){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIString del = ", ";
    PIStringList lis {str1, str2, str3, str4};
    ASSERT_EQ(lis.join(del), "first string, second string, third string, fourth string");
}

TEST(PIStringList_Tests, remove_strings_size){
    PIString str1 = "first string";
    PIString str2 = "string";
    PIString str3 = "third string";
    PIString str4 = "string";
    PIString val = "string";
    PIStringList lis {str1, str2, str3, str4};
    lis.removeStrings(val);
    ASSERT_EQ(lis.length(), 2);
}

TEST(PIStringList_Tests, remove_strings_data){
    PIString str1 = "first string";
    PIString str2 = "string";
    PIString str3 = "third string";
    PIString str4 = "string";
    PIString val = "string";
    PIStringList lis {str1, str2, str3, str4};
    lis.removeStrings(val);
    ASSERT_EQ(lis[0], "first string");
    ASSERT_EQ(lis[1], "third string");
}

TEST(PIStringList_Tests, remove_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.remove(2);
    ASSERT_EQ(lis.length(), 3);
}

TEST(PIStringList_Tests, remove_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.remove(2);
    ASSERT_EQ(lis[0], "first string");
    ASSERT_EQ(lis[1], "second string");
    ASSERT_EQ(lis[2], "fourth string");
}

TEST(PIStringList_Tests, remove_count_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.remove(2,2);
    ASSERT_EQ(lis.length(), 2);
}

TEST(PIStringList_Tests, remove_count_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.remove(2,2);
    ASSERT_EQ(lis[0], "first string");
    ASSERT_EQ(lis[1], "second string");
}

TEST(PIStringList_Tests, remove_Duplicates_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "first string";
    PIString str4 = "second string";
    PIStringList lis {str1, str2, str3, str4};
    lis.removeDuplicates();
    ASSERT_EQ(lis.length(), 2);
}

TEST(PIStringList_Tests, remove_Duplicates_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "first string";
    PIString str4 = "second string";
    PIStringList lis {str1, str2, str3, str4};
    lis.removeDuplicates();
    ASSERT_EQ(lis[0], "first string");
    ASSERT_EQ(lis[1], "second string");
}

TEST(PIStringList_Tests, trim_size){
    PIString str1 = " first string ";
    PIString str2 = "second string ";
    PIString str3 = " third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.trim();
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, trim_data){
    PIString str1 = " first string ";
    PIString str2 = "second string ";
    PIString str3 = " third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    lis.trim();
    ASSERT_EQ(lis[0], "first string");
    ASSERT_EQ(lis[1], "second string");
    ASSERT_EQ(lis[2], "third string");
    ASSERT_EQ(lis[3], "fourth string");
}
TEST(PIStringList_Tests, content_size){
    PIString str1 = " first string ";
    PIString str2 = "second string ";
    PIString str3 = " third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    ASSERT_EQ(lis.contentSize(), 54);
}

TEST(PIStringList_Tests, operator_compare){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_TRUE(lis == lis1);
}

TEST(PIStringList_Tests, operator_compare_false){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_FALSE(lis == lis1);
}

TEST(PIStringList_Tests, operator_compare_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_FALSE(lis == lis1);
}

TEST(PIStringList_Tests, operator_compare_unequal

){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_FALSE(lis != lis1);
}

TEST(PIStringList_Tests, operator_compare_unequal_false){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_TRUE(lis != lis1);
}

TEST(PIStringList_Tests, operator_compare_unequal_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "third string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    PIStringList lis1 {"first string", "second string", "third string", "fourth string"};
    ASSERT_TRUE(lis != lis1);
}

TEST(PIStringList_Tests, operator_assignment_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 = lis;
    ASSERT_EQ(lis1.length(), 4);
}

TEST(PIStringList_Tests, operator_assignment_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3, str4};
    PIStringList lis1 = lis;
    ASSERT_EQ(lis1[0], str1);
    ASSERT_EQ(lis1[1], str2);
    ASSERT_EQ(lis1[2], str3);
    ASSERT_EQ(lis1[3], str4);
}

TEST(PIStringList_Tests, operator_shift_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    lis << str4;
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, operator_shift_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    lis << str4;
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
    ASSERT_EQ(lis[3], str4);
}

TEST(PIStringList_Tests, operator_shift_rvalue_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    lis << "fourth string";
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, operator_shift_rvalue_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2, str3};
    lis << "fourth string";
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
    ASSERT_EQ(lis[3], str4);
}

TEST(PIStringList_Tests, operator_shift_pistringlist_size){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2};
    PIStringList lis1 {str3, str4};
    lis << lis1;
    ASSERT_EQ(lis.length(), 4);
}

TEST(PIStringList_Tests, operator_shift_pistringlist_data){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIString str3 = "thord string";
    PIString str4 = "fourth string";
    PIStringList lis {str1, str2};
    PIStringList lis1 {str3, str4};
    lis << lis1;
    ASSERT_EQ(lis[0], str1);
    ASSERT_EQ(lis[1], str2);
    ASSERT_EQ(lis[2], str3);
    ASSERT_EQ(lis[3], str4);
}

TEST(PIStringList_Tests, operator_shift_pibytearray){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList lis {str1, str2};
    PIByteArray arr;
    arr << lis;
    PIByteArray res[] = {2, 0, 0, 0, 12, 0, 0, 0, 102, 0, 105, 0, 114, 0, 115, 0, 116, 0, 32, 0, 115, 0, 116, 0, 114, 0, 105, 0, 110, 0, 103, 0,
                         13, 0, 0, 0, 115, 0, 101, 0, 99, 0, 111, 0, 110, 0, 100, 0, 32, 0, 115, 0, 116, 0, 114, 0, 105, 0, 110, 0, 103, 0};
    bool fl = true;
    for(size_t x = 0; x < arr.length(); x++) {
        if(res[x] != arr[x]) fl = false;
    }
    ASSERT_TRUE(fl);
}

TEST(PIStringList_Tests, operator_shift_right_pibytearray){
    PIString str1 = "first string";
    PIString str2 = "second string";
    PIStringList res {str1, str2};
    PIByteArray arr;
    arr << res;
    PIStringList list;
    arr >> list;
    ASSERT_EQ(res, list);
}