API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 21st, 2017
804
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.29 KB | None | 0 0
raw download clone embed print report
  1. // Copyright 2001, University of Freiburg
  2. // Anton Stepan
  3. // <stepana@informatik.uni-freiburg.de>
  4.  
  5. #include <gtest/gtest.h>
  6. #include "./String.h"
  7.  
  8. template <class T>
  9. void assertStringEquality(const char* e, const String<T>& s)
  10. {
  11.   for (int i = 0; i < s.size(); i++) ASSERT_EQ(e[i], s[i]);
  12.   ASSERT_EQ(e[s.size()], 0);
  13. }
  14.  
  15. // ____________________________________________________________________________
  16. TEST(StringTest, insert)
  17. {
  18.   String<char> str;
  19.   String<char> ins;
  20.   str.set("123");
  21.   ins.set("456");
  22.   str.insert(3, ins);
  23.   ASSERT_EQ(6, str.size());
  24.   SCOPED_TRACE("assertStringEquality called from here");
  25.   assertStringEquality("123456", str);
  26.  
  27.   String<char> s1;
  28.   s1.set("Hier ist der Wolfgang.");
  29.   String<char> s2;
  30.   s2.set("kleine ");
  31.   s1.insert(12, s2);
  32.   ASSERT_EQ('H', s1._contents[0]);
  33.   ASSERT_EQ('k', s1._contents[12]);
  34.   String<char> s;
  35.   String<char> s3;
  36.   s.set("123");
  37.   s3.set("5");
  38.   s.insert(1, s3);
  39.   ASSERT_EQ('1', s._contents[0]);
  40.   ASSERT_EQ('5', s._contents[1]);
  41.   ASSERT_EQ('2', s._contents[2]);
  42.   ASSERT_EQ('3', s._contents[3]);
  43.  
  44.   // [Betim] Meine Tests
  45.   // Insert at the beginnning
  46.   s1.set("abc");
  47.   s2.set("def");
  48.  
  49.   s1.insert(0, s2);
  50.  
  51.   ASSERT_EQ(6, s1._size);
  52.   ASSERT_EQ('d', s1._contents[0]);
  53.   ASSERT_EQ('e', s1._contents[1]);
  54.   ASSERT_EQ('f', s1._contents[2]);
  55.   ASSERT_EQ('a', s1._contents[3]);
  56.   ASSERT_EQ('b', s1._contents[4]);
  57.   ASSERT_EQ('c', s1._contents[5]);
  58.  
  59.   // Insert at the end
  60.   s1.set("abc");
  61.   s2.set("def");
  62.  
  63.   s1.insert(3, s2);
  64.  
  65.   ASSERT_EQ(6, s1._size);
  66.   ASSERT_EQ('a', s1._contents[0]);
  67.   ASSERT_EQ('b', s1._contents[1]);
  68.   ASSERT_EQ('c', s1._contents[2]);
  69.   ASSERT_EQ('d', s1._contents[3]);
  70.   ASSERT_EQ('e', s1._contents[4]);
  71.   ASSERT_EQ('f', s1._contents[5]);
  72.  
  73.   // Insert in the middle
  74.   s1.set("abcdef");
  75.   s2.set("def");
  76.  
  77.   s1.insert(3, s2);
  78.  
  79.   ASSERT_EQ(9, s1._size);
  80.   ASSERT_EQ('a', s1._contents[0]);
  81.   ASSERT_EQ('b', s1._contents[1]);
  82.   ASSERT_EQ('c', s1._contents[2]);
  83.   ASSERT_EQ('d', s1._contents[3]);
  84.   ASSERT_EQ('e', s1._contents[4]);
  85.   ASSERT_EQ('f', s1._contents[5]);
  86.   ASSERT_EQ('d', s1._contents[6]);
  87.   ASSERT_EQ('e', s1._contents[7]);
  88.   ASSERT_EQ('f', s1._contents[8]);
  89.  
  90.  
  91.   // Insert nothing, because pos is negative.
  92.   s1.set("abcdef");
  93.   s2.set("def");
  94.  
  95.   s1.insert(-1, s2);
  96.  
  97.   ASSERT_EQ(6, s1._size);
  98.   ASSERT_EQ('a', s1._contents[0]);
  99.   ASSERT_EQ('b', s1._contents[1]);
  100.   ASSERT_EQ('c', s1._contents[2]);
  101.   ASSERT_EQ('d', s1._contents[3]);
  102.   ASSERT_EQ('e', s1._contents[4]);
  103.   ASSERT_EQ('f', s1._contents[5]);
  104.  
  105.   // Insert nothing, because pos is bigger than the size
  106.   // of first object
  107.   s1.set("abcdef");
  108.   s2.set("def");
  109.  
  110.   s1.insert(6, s2);
  111.  
  112.   ASSERT_EQ(9, s1._size);
  113.   ASSERT_EQ('a', s1._contents[0]);
  114.   ASSERT_EQ('b', s1._contents[1]);
  115.   ASSERT_EQ('c', s1._contents[2]);
  116.   ASSERT_EQ('d', s1._contents[3]);
  117.   ASSERT_EQ('e', s1._contents[4]);
  118.   ASSERT_EQ('f', s1._contents[5]);
  119.  
  120.   {
  121.     String<bool> str1, str2;
  122.     str1 = "100001";
  123.     str2 = "111";
  124.     str1.insert(3, str2);
  125.     ASSERT_EQ(9, str1.size());
  126.     ASSERT_TRUE(str1[0]);
  127.     ASSERT_FALSE(str1[1]);
  128.     ASSERT_FALSE(str1[2]);
  129.     ASSERT_TRUE(str1[3]);
  130.     ASSERT_TRUE(str1[4]);
  131.     ASSERT_TRUE(str1[5]);
  132.     ASSERT_FALSE(str1[6]);
  133.     ASSERT_FALSE(str1[7]);
  134.     ASSERT_TRUE(str1[8]);
  135.   }
  136. }
  137.  
  138. // ____________________________________________________________________________
  139. TEST(StringTest, erase)
  140. {
  141.   String<char> str;
  142.   str.set("123456789");
  143.   str.erase(4, 1);
  144.   SCOPED_TRACE("assertStringEquality called from here");
  145.   assertStringEquality("12346789", str);
  146.  
  147.   String<char> s;
  148.   s.set("01234567");
  149.   s.erase(2, 2);
  150.   ASSERT_EQ(6, s._size);
  151.   ASSERT_EQ('0', s._contents[0]);
  152.   ASSERT_EQ('1', s._contents[1]);
  153.   ASSERT_EQ('4', s._contents[2]);
  154.   ASSERT_EQ('5', s._contents[3]);
  155.  
  156.   // [Betim] Meine Tests
  157.   // Erase nothing
  158.   String<char> s1;
  159.   s1.set("0123456789");
  160.   s1.erase(0, 0);
  161.  
  162.   ASSERT_EQ(10, s1._size);
  163.   ASSERT_EQ('0', s1._contents[0]);
  164.   ASSERT_EQ('1', s1._contents[1]);
  165.   ASSERT_EQ('2', s1._contents[2]);
  166.   ASSERT_EQ('3', s1._contents[3]);
  167.   ASSERT_EQ('4', s1._contents[4]);
  168.   ASSERT_EQ('5', s1._contents[5]);
  169.   ASSERT_EQ('6', s1._contents[6]);
  170.   ASSERT_EQ('7', s1._contents[7]);
  171.   ASSERT_EQ('8', s1._contents[8]);
  172.   ASSERT_EQ('9', s1._contents[9]);
  173.  
  174.   // Erase nothing, because position is negative
  175.   s1.set("0123456789");
  176.   s1.erase(-1, 0);
  177.  
  178.   ASSERT_EQ(10, s1._size);
  179.   ASSERT_EQ('0', s1._contents[0]);
  180.   ASSERT_EQ('1', s1._contents[1]);
  181.   ASSERT_EQ('2', s1._contents[2]);
  182.   ASSERT_EQ('3', s1._contents[3]);
  183.   ASSERT_EQ('4', s1._contents[4]);
  184.   ASSERT_EQ('5', s1._contents[5]);
  185.   ASSERT_EQ('6', s1._contents[6]);
  186.   ASSERT_EQ('7', s1._contents[7]);
  187.   ASSERT_EQ('8', s1._contents[8]);
  188.  
  189.   // Erase all, because length is bigger than the size of the string
  190.   s1.set("0123456789");
  191.   s1.erase(0, 11);
  192.  
  193.   ASSERT_EQ(0, s1._size);
  194.  
  195.   // Erase something at the beginning
  196.   s1.set("0123456789");
  197.   s1.erase(0, 4);
  198.  
  199.   ASSERT_EQ(6, s1._size);
  200.   ASSERT_EQ('4', s1._contents[0]);
  201.   ASSERT_EQ('5', s1._contents[1]);
  202.   ASSERT_EQ('6', s1._contents[2]);
  203.   ASSERT_EQ('7', s1._contents[3]);
  204.   ASSERT_EQ('8', s1._contents[4]);
  205.   ASSERT_EQ('9', s1._contents[5]);
  206.  
  207.   // Erase something at the end
  208.   s1.set("0123456789");
  209.   s1.erase(6, 4);
  210.  
  211.   ASSERT_EQ(6, s1._size);
  212.   ASSERT_EQ('0', s1._contents[0]);
  213.   ASSERT_EQ('1', s1._contents[1]);
  214.   ASSERT_EQ('2', s1._contents[2]);
  215.   ASSERT_EQ('3', s1._contents[3]);
  216.   ASSERT_EQ('4', s1._contents[4]);
  217.   ASSERT_EQ('5', s1._contents[5]);
  218.  
  219.   // Erase something at the end
  220.   s1.set("0123456789");
  221.   s1.erase(4, 20);
  222.  
  223.   ASSERT_EQ(4, s1._size);
  224.   ASSERT_EQ('0', s1._contents[0]);
  225.   ASSERT_EQ('1', s1._contents[1]);
  226.   ASSERT_EQ('2', s1._contents[2]);
  227.   ASSERT_EQ('3', s1._contents[3]);
  228.  
  229.   // Erase something in the middle
  230.   s1.set("0123456789");
  231.   s1.erase(4, 2);
  232.  
  233.   ASSERT_EQ(8, s1._size);
  234.   ASSERT_EQ('0', s1._contents[0]);
  235.   ASSERT_EQ('1', s1._contents[1]);
  236.   ASSERT_EQ('2', s1._contents[2]);
  237.   ASSERT_EQ('3', s1._contents[3]);
  238.   ASSERT_EQ('6', s1._contents[4]);
  239.   ASSERT_EQ('7', s1._contents[5]);
  240.   ASSERT_EQ('8', s1._contents[6]);
  241.   ASSERT_EQ('9', s1._contents[7]);
  242.  
  243.   {
  244.     String<bool> str;
  245.     str = "100010001";
  246.     ASSERT_EQ(9, str.size());
  247.     str.erase(4, 1);
  248.     ASSERT_EQ(8, str.size());
  249.     ASSERT_TRUE(str[0]);
  250.     ASSERT_FALSE(str[1]);
  251.     ASSERT_FALSE(str[2]);
  252.     ASSERT_FALSE(str[3]);
  253.     ASSERT_FALSE(str[4]);
  254.     ASSERT_FALSE(str[5]);
  255.     ASSERT_FALSE(str[6]);
  256.     ASSERT_TRUE(str[7]);
  257.   }
  258.  
  259.   {
  260.     String<bool> str;
  261.     str = "101010";
  262.     ASSERT_EQ(6, str.size());
  263.     str.erase(0, 6);
  264.     ASSERT_EQ(0, str.size());
  265.   }
  266.  
  267.   {
  268.     String<bool> str;
  269.     str = "10";
  270.     ASSERT_EQ(2, str.size());
  271.     str.erase(-2, 1);
  272.     ASSERT_EQ(2, str.size());
  273.   }
  274. }
  275.  
  276. // ____________________________________________________________________________
  277. TEST(StringTest, assignmentOperator)
  278. {
  279.   String<char> str;
  280.   String<char> rts;
  281.   str.set("abcdefgh");
  282.   rts.set("12345678");
  283.   str = rts;
  284.   SCOPED_TRACE("assertStringEquality called from here");
  285.   assertStringEquality("12345678", str);
  286.  
  287.   {
  288.     String<bool> testbool;
  289.     testbool = "100101";
  290.     ASSERT_EQ(6, testbool.size());
  291.     ASSERT_TRUE(testbool[0]);
  292.     ASSERT_FALSE(testbool[1]);
  293.     ASSERT_FALSE(testbool[2]);
  294.     ASSERT_TRUE(testbool[3]);
  295.     ASSERT_FALSE(testbool[4]);
  296.     ASSERT_TRUE(testbool[5]);
  297.  
  298.     testbool = "";
  299.     ASSERT_EQ(0, testbool.size());
  300.   }
  301.  
  302.   {
  303.     String<bool> test;
  304.     test.append(true);
  305.     test.append(false);
  306.     test = "0001";
  307.     ASSERT_EQ(4, test.size());
  308.     ASSERT_FALSE(test[0]);
  309.     ASSERT_FALSE(test[1]);
  310.     ASSERT_FALSE(test[2]);
  311.     ASSERT_TRUE(test[3]);
  312.   }
  313. }
  314.  
  315. // ____________________________________________________________________________
  316. TEST(StringTest, find)
  317. {
  318.   String<char> str;
  319.   String<char> pattern;
  320.   str.set("abcd efgh ijkl");
  321.   pattern.set("ef");
  322.   ASSERT_EQ(5, str.find(0, pattern));
  323. }
  324.  
  325. // ____________________________________________________________________________
  326. TEST(StringTest, append)
  327. {
  328.   String<bool> str;
  329.   str.append(true);
  330.   str.append(true);
  331.   str.append(false);
  332.   str.append(true);
  333.   str.append(true);
  334.   ASSERT_EQ(5, str.size());
  335.   ASSERT_TRUE(str[0]);
  336.   ASSERT_TRUE(str[1]);
  337.   ASSERT_FALSE(str[2]);
  338.   ASSERT_TRUE(str[3]);
  339.   ASSERT_TRUE(str[4]);
  340. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!