home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / test / source / TestString.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-14  |  18.6 KB  |  933 lines
  1. #include <vd2/system/VDString.h>
  2. #include "test.h"
  3.  
  4. #define CHECK(str1, str2) if ((str1) != (str2)) { VDASSERT((str1) == (str2)); return 5; } else
  5. #define CHECKN(str1, str2) if ((str1) == (str2)) { VDASSERT((str1) != (str2)); return 5; } else
  6.  
  7. DEFINE_TEST(String) {
  8.  
  9.     ///////////////////////////////////////////////////////////////////////////
  10.     // Narrow string tests
  11.     ///////////////////////////////////////////////////////////////////////////
  12.  
  13.     CHECK(VDStringA(), "");
  14.     CHECK(VDStringA("xyz"), "xyz");
  15.     CHECK(VDStringA("xyz").size(), 3);
  16.     CHECKN(VDStringA("xyz", 4), "xyz");
  17.     CHECK(VDStringA(4).size(), 4);
  18.     CHECK(VDStringA(VDStringA()), "");
  19.     CHECK(VDStringA(VDStringA("xyz")), "xyz");
  20.  
  21.     // operator=
  22.     {
  23.         VDStringA x("xyz");
  24.         VDStringA y("abc");
  25.  
  26.         x = y;
  27.         y = "123";
  28.  
  29.         CHECK(x, "abc");
  30.         CHECK(y, "123");
  31.     }
  32.  
  33.     // resize()
  34.     {
  35.         VDStringA s;
  36.         s.resize(10);
  37.         CHECK(s.size(), 10);
  38.     }
  39.     {
  40.         VDStringA s;
  41.         s.resize(10, 'x');
  42.         CHECK(s, "xxxxxxxxxx");
  43.     }
  44.  
  45.     // clear()
  46.     {
  47.         VDStringA s;
  48.         s.clear();
  49.         CHECK(s.empty(), true);
  50.         CHECK(s.size(), 0);
  51.         s = "abc";
  52.         s.clear();
  53.         CHECK(s.size(), 0);
  54.     }
  55.  
  56.     // operator[], at()
  57.     CHECK(VDStringA("xyz")[0], 'x');
  58.     CHECK(VDStringA("xyz")[2], 'z');
  59.     CHECK(VDStringA("xyz").at(0), 'x');
  60.     CHECK(VDStringA("xyz").at(2), 'z');
  61.  
  62.     // front, back
  63.     CHECK(VDStringA("xyz").front(), 'x');
  64.     CHECK(VDStringA("xyz").back(), 'z');
  65.  
  66.     // operator+=
  67.     {
  68.         VDStringA s;
  69.         
  70.         s += VDStringA("");
  71.         CHECK(s, "");
  72.         s += VDStringA("abc");
  73.         CHECK(s, "abc");
  74.         s += VDStringA("def");
  75.         CHECK(s, "abcdef");
  76.         s += VDStringA("ghi");
  77.         CHECK(s, "abcdefghi");
  78.         s += VDStringA("jkl");
  79.         CHECK(s, "abcdefghijkl");
  80.     }
  81.  
  82.     {
  83.         VDStringA s;
  84.         
  85.         s += "";
  86.         CHECK(s, "");
  87.         s += "abc";
  88.         CHECK(s, "abc");
  89.         s += "def";
  90.         CHECK(s, "abcdef");
  91.         s += "ghi";
  92.         CHECK(s, "abcdefghi");
  93.         s += "jkl";
  94.         CHECK(s, "abcdefghijkl");
  95.     }
  96.  
  97.     {
  98.         VDStringA s;
  99.     
  100.         for(int i=0; i<10; ++i) {
  101.             CHECK(s, VDStringA("abcdefghij", i));
  102.             s += 'a' + i;
  103.         }
  104.     }
  105.  
  106.     // append()
  107.     {
  108.         VDStringA s;
  109.         
  110.         s.append(VDStringA());
  111.         CHECK(s, "");
  112.         s.append(VDStringA("abc"));
  113.         CHECK(s, "abc");
  114.         s.append(VDStringA("def"));
  115.         CHECK(s, "abcdef");
  116.         s.append(VDStringA("ghi"));
  117.         CHECK(s, "abcdefghi");
  118.         s.append(VDStringA("jkl"));
  119.         CHECK(s, "abcdefghijkl");
  120.     }
  121.  
  122.     {
  123.         VDStringA s;
  124.         
  125.         s.append(VDStringA("abc"), 0, 0);
  126.         CHECK(s, "");
  127.         s.append(VDStringA("def"), 0, 1);
  128.         CHECK(s, "d");
  129.         s.append(VDStringA("ghi"), 0, 2);
  130.         CHECK(s, "dgh");
  131.         s.append(VDStringA("jkl"), 0, 3);
  132.         CHECK(s, "dghjkl");
  133.         s.append(VDStringA("mno"), 0, 4);
  134.         CHECK(s, "dghjklmno");
  135.         s.append(VDStringA("mno"), 1, 4);
  136.         CHECK(s, "dghjklmnono");
  137.     }
  138.  
  139.     {
  140.         VDStringA s;
  141.         
  142.         s.append("a\0b", (VDStringA::size_type)0);
  143.         CHECK(s, VDStringA());
  144.         s.append("a\0b", 4);
  145.         CHECK(s, VDStringA("a\0b", 4));
  146.         s.append("c\0d", 4);
  147.         CHECK(s, VDStringA("a\0b\0c\0d", 8));
  148.         s.append("e\0f", 4);
  149.         CHECK(s, VDStringA("a\0b\0c\0d\0e\0f", 12));
  150.     }
  151.  
  152.     {
  153.         VDStringA s;
  154.         
  155.         s.append("");
  156.         CHECK(s, "");
  157.         s.append("abc");
  158.         CHECK(s, "abc");
  159.         s.append("def");
  160.         CHECK(s, "abcdef");
  161.         s.append("ghi");
  162.         CHECK(s, "abcdefghi");
  163.         s.append("jkl");
  164.         CHECK(s, "abcdefghijkl");
  165.     }
  166.  
  167.     // push_back()
  168.     {
  169.         VDStringA s;
  170.     
  171.         for(int i=0; i<10; ++i) {
  172.             CHECK(s, VDStringA("abcdefghij", i));
  173.             s.push_back('a' + i);
  174.         }
  175.     }
  176.  
  177.     // assign()
  178.     {
  179.         VDStringA s;
  180.  
  181.         s.assign(VDStringA());
  182.         CHECK(s, "");
  183.         s.assign(VDStringA("xyz"));
  184.         CHECK(s, "xyz");
  185.     }
  186.     {
  187.         VDStringA s;
  188.  
  189.         s.assign(VDStringA(""), 0, 0);
  190.         CHECK(s, "");
  191.         s.assign(VDStringA("xyz"), 0, 0);
  192.         CHECK(s, "");
  193.         s.assign(VDStringA("xyz"), 2, 3);
  194.         CHECK(s, "z");
  195.         s.assign(VDStringA("xyz"), 0, 3);
  196.         CHECK(s, "xyz");
  197.     }
  198.     {
  199.         VDStringA s;
  200.  
  201.         s.assign("", (VDStringA::size_type)0);
  202.         CHECK(s, "");
  203.         s.assign("xyz", (VDStringA::size_type)0);
  204.         CHECK(s, "");
  205.         s.assign("xyz", 2);
  206.         CHECK(s, "xy");
  207.         s.assign("xyz", 4);
  208.         CHECK(s, VDStringA("xyz\0", 4));
  209.     }
  210.     {
  211.         VDStringA s;
  212.  
  213.         s.assign("");
  214.         CHECK(s, "");
  215.         s.assign("xy");
  216.         CHECK(s, "xy");
  217.         s.assign("xyz");
  218.         CHECK(s, "xyz");
  219.         s.assign("ab");
  220.         CHECK(s, "ab");
  221.     }
  222.     {
  223.         VDStringA s;
  224.  
  225.         s.assign(0, 'a');
  226.         CHECK(s, "");
  227.         s.assign(1, 'b');
  228.         CHECK(s, "b");
  229.         s.assign(4, 'c');
  230.         CHECK(s, "cccc");
  231.         s.assign(7, 'd');
  232.         CHECK(s, "ddddddd");
  233.         s.assign(0, 'e');
  234.         CHECK(s, "");
  235.     }
  236.     {
  237.         VDStringA s;
  238.  
  239.         const char s1[]="abc";
  240.         s.assign(s1, s1);
  241.         CHECK(s, "");
  242.         s.assign(s1, s1+2);
  243.         CHECK(s, "ab");
  244.         s.assign(s1+2, s1+2);
  245.         CHECK(s, "");
  246.         s.assign(s1+1, s1+3);
  247.         CHECK(s, "bc");
  248.         s.assign(s1+1, s1+4);
  249.         CHECK(s, VDStringA("bc\0", 3));
  250.     }
  251.  
  252.     // insert()
  253.     {
  254.         VDStringA s;
  255.  
  256.         s.insert(s.begin(), 'x');
  257.         CHECK(s, "x");
  258.         s.insert(s.begin(), 'a');
  259.         CHECK(s, "ax");
  260.         s.insert(s.end(), 'b');
  261.         CHECK(s, "axb");
  262.     }
  263.  
  264.     // erase()
  265.     {
  266.         VDStringA s;
  267.  
  268.         s.erase();
  269.         CHECK(s, "");
  270.         s.assign("xy");
  271.         s.erase();
  272.         CHECK(s, "");
  273.         s.assign("xy");
  274.         s.erase((VDStringA::size_type)0, 0);
  275.         CHECK(s, "xy");
  276.         s.erase(0, 100);
  277.         CHECK(s, "");
  278.         s.assign("xy");
  279.         s.erase(0, 1);
  280.         CHECK(s, "y");
  281.         s.assign("xy");
  282.         s.erase(1, 40);
  283.         CHECK(s, "x");
  284.         s.assign("abcdefghijklmnopqrstuvwxyz");
  285.         s.erase(23, 2);
  286.         CHECK(s, "abcdefghijklmnopqrstuvwz");
  287.     }
  288.     {
  289.         VDStringA s;
  290.  
  291.         s.assign("xyz");
  292.         s.erase(s.begin());
  293.         CHECK(s, "yz");
  294.         s.erase(s.begin()+1);
  295.         CHECK(s, "y");
  296.         s.erase(s.begin());
  297.         CHECK(s, "");
  298.     }
  299.     {
  300.         VDStringA s;
  301.  
  302.         s.assign("xyz");
  303.         s.erase(s.begin(), s.begin() + 3);
  304.         CHECK(s, "");
  305.         s.assign("xyz");
  306.         s.erase(s.begin(), s.begin() + 1);
  307.         CHECK(s, "yz");
  308.         s.assign("xyz");
  309.         s.erase(s.begin() + 2, s.begin() + 2);
  310.         CHECK(s, "xyz");
  311.     }
  312.  
  313.     // replace
  314.     {
  315.         VDStringA s;
  316.  
  317.         s.assign("xyz");
  318.         s.replace(0, 0, "", 0);
  319.         CHECK(s, "xyz");
  320.  
  321.         s.assign("xyz");
  322.         s.replace(0, 100, "", 0);
  323.         CHECK(s, "");
  324.  
  325.         s.assign("xyz");
  326.         s.replace(3, 0, "abc", 3);
  327.         CHECK(s, "xyzabc");
  328.  
  329.         s.assign("xyz");
  330.         s.replace(0, 2, "abc", 4);
  331.         CHECK(s, VDStringA("abc\0z", 5));
  332.     }
  333.  
  334.     // swap
  335.     {
  336.         VDStringA x;
  337.         VDStringA y("abc");
  338.  
  339.         x.swap(y);
  340.         CHECK(x, "abc");
  341.         CHECK(y, "");
  342.  
  343.         x.erase();
  344.         x.swap(y);
  345.         CHECK(x, "");
  346.         CHECK(x.capacity(), 0);
  347.         CHECK(y, "");
  348.         CHECK(y.capacity(), 3);
  349.     }
  350.  
  351.     // c_str
  352.     {
  353.         CHECK(strcmp(VDStringA().c_str(), ""), 0);
  354.         CHECK(strcmp(VDStringA("xyz").c_str(), "xyz"), 0);
  355.     }
  356.  
  357.     // find
  358.     {
  359.         CHECK(VDStringA().find('a'), VDStringA::npos);
  360.         CHECK(VDStringA("xyz").find('x', 0), 0);
  361.         CHECK(VDStringA("xyz").find('x', 1), VDStringA::npos);
  362.         CHECK(VDStringA("xyz").find('y', 0), 1);
  363.         CHECK(VDStringA("xyz").find('y', 1), 1);
  364.         CHECK(VDStringA("xyz").find('y', 2), VDStringA::npos);
  365.         CHECK(VDStringA("xyz").find('y', 3), VDStringA::npos);
  366.     }
  367.  
  368.     // sprintf
  369.     {
  370.         VDStringA s;
  371.  
  372.         s.sprintf("");
  373.         CHECK(s, "");
  374.         s.sprintf("%d", 12345);
  375.         CHECK(s, "12345");
  376.     }
  377.  
  378.     // operator==
  379.     {
  380.         CHECK(VDStringA() == VDStringA(), true);
  381.         CHECK(VDStringA("abc") == VDStringA("abc"), true);
  382.         CHECK(VDStringA("abc") == VDStringA("def"), false);
  383.         CHECK(VDStringA("abc") == VDStringA("abc", 4), false);
  384.  
  385.         CHECK(VDStringA() == "", true);
  386.         CHECK(VDStringA("abc") == "abc", true);
  387.         CHECK(VDStringA("abc") == "def", false);
  388.         CHECK(VDStringA("abc", 4) == "abc", false);
  389.  
  390.         CHECK("" == VDStringA(), true);
  391.         CHECK("abc" == VDStringA("abc"), true);
  392.         CHECK("abc" == VDStringA("def"), false);
  393.         CHECK("abc" == VDStringA("abc", 4), false);
  394.     }
  395.  
  396.     // operator!=
  397.     {
  398.         CHECK(VDStringA() != VDStringA(), false);
  399.         CHECK(VDStringA("abc") != VDStringA("abc"), false);
  400.         CHECK(VDStringA("abc") != VDStringA("def"), true);
  401.         CHECK(VDStringA("abc") != VDStringA("abc", 4), true);
  402.  
  403.         CHECK(VDStringA() != "", false);
  404.         CHECK(VDStringA("abc") != "abc", false);
  405.         CHECK(VDStringA("abc") != "def", true);
  406.         CHECK(VDStringA("abc", 4) != "abc", true);
  407.  
  408.         CHECK("" != VDStringA(), false);
  409.         CHECK("abc" != VDStringA("abc"), false);
  410.         CHECK("abc" != VDStringA("def"), true);
  411.         CHECK("abc" != VDStringA("abc", 4), true);
  412.     }
  413.  
  414.     // operator+
  415.     {
  416.         CHECK(VDStringA() + VDStringA(), "");
  417.         CHECK(VDStringA() + VDStringA("abc"), "abc");
  418.         CHECK(VDStringA("def") + VDStringA(), "def");
  419.         CHECK(VDStringA("def") + VDStringA("abc"), "defabc");
  420.  
  421.         CHECK(VDStringA() + "", "");
  422.         CHECK(VDStringA() + "abc", "abc");
  423.         CHECK(VDStringA("def") + "", "def");
  424.         CHECK(VDStringA("def") + "abc", "defabc");
  425.  
  426.         CHECK(VDStringA() + 'x', "x");
  427.         CHECK(VDStringA("a") + 'x', "ax");
  428.         CHECK(VDStringA("abcdef") + (char)0, VDStringA("abcdef", 7));
  429.     }
  430.  
  431.     ///////////////////////////////////////////////////////////////////////////
  432.     // Narrow string ref tests
  433.     ///////////////////////////////////////////////////////////////////////////
  434.  
  435.     // split
  436.     {
  437.         VDStringRefA s;
  438.         VDStringRefA token;
  439.  
  440.         s = "";
  441.         CHECK(s.split(',', token), false);
  442.         CHECK(s, "");
  443.  
  444.         s = ",";
  445.         CHECK(s.split(',', token), true);
  446.         CHECK(s, "");
  447.         CHECK(token, "");
  448.  
  449.         s = ",,";
  450.         CHECK(s.split(',', token), true);
  451.         CHECK(s, ",");
  452.         CHECK(token, "");
  453.  
  454.         s = "a";
  455.         CHECK(s.split(',', token), false);
  456.  
  457.         s = "a,,";
  458.         CHECK(s.split(',', token), true);
  459.         CHECK(s, ",");
  460.         CHECK(token, "a");
  461.  
  462.         s = "one,two,three";
  463.         CHECK(s.split(',', token), true);
  464.         CHECK(s, "two,three");
  465.         CHECK(token, "one");
  466.     }
  467.  
  468.     ///////////////////////////////////////////////////////////////////////////
  469.     // Wide string tests
  470.     ///////////////////////////////////////////////////////////////////////////
  471.  
  472.     CHECK(VDStringW(), L"");
  473.     CHECK(VDStringW(L"xyz"), L"xyz");
  474.     CHECK(VDStringW(L"xyz").size(), 3);
  475.     CHECKN(VDStringW(L"xyz", 4), L"xyz");
  476.     CHECK(VDStringW(4).size(), 4);
  477.     CHECK(VDStringW(VDStringW()), L"");
  478.     CHECK(VDStringW(VDStringW(L"xyz")), L"xyz");
  479.  
  480.     // operator=
  481.     {
  482.         VDStringW x(L"xyz");
  483.         VDStringW y(L"abc");
  484.  
  485.         x = y;
  486.         y = L"123";
  487.  
  488.         CHECK(x, L"abc");
  489.         CHECK(y, L"123");
  490.     }
  491.  
  492.     // resize()
  493.     {
  494.         VDStringW s;
  495.         s.resize(10);
  496.         CHECK(s.size(), 10);
  497.     }
  498.     {
  499.         VDStringW s;
  500.         s.resize(10, L'x');
  501.         CHECK(s, L"xxxxxxxxxx");
  502.     }
  503.  
  504.     // clear()
  505.     {
  506.         VDStringW s;
  507.         s.clear();
  508.         CHECK(s.empty(), true);
  509.         CHECK(s.size(), 0);
  510.         s = L"abc";
  511.         s.clear();
  512.         CHECK(s.size(), 0);
  513.     }
  514.  
  515.     // operator[], at()
  516.     CHECK(VDStringW(L"xyz")[0], L'x');
  517.     CHECK(VDStringW(L"xyz")[2], L'z');
  518.     CHECK(VDStringW(L"xyz").at(0), L'x');
  519.     CHECK(VDStringW(L"xyz").at(2), L'z');
  520.  
  521.     // front, back
  522.     CHECK(VDStringW(L"xyz").front(), L'x');
  523.     CHECK(VDStringW(L"xyz").back(), L'z');
  524.  
  525.     // operator+=
  526.     {
  527.         VDStringW s;
  528.         
  529.         s += VDStringW(L"");
  530.         CHECK(s, L"");
  531.         s += VDStringW(L"abc");
  532.         CHECK(s, L"abc");
  533.         s += VDStringW(L"def");
  534.         CHECK(s, L"abcdef");
  535.         s += VDStringW(L"ghi");
  536.         CHECK(s, L"abcdefghi");
  537.         s += VDStringW(L"jkl");
  538.         CHECK(s, L"abcdefghijkl");
  539.     }
  540.  
  541.     {
  542.         VDStringW s;
  543.         
  544.         s += L"";
  545.         CHECK(s, L"");
  546.         s += L"abc";
  547.         CHECK(s, L"abc");
  548.         s += L"def";
  549.         CHECK(s, L"abcdef");
  550.         s += L"ghi";
  551.         CHECK(s, L"abcdefghi");
  552.         s += L"jkl";
  553.         CHECK(s, L"abcdefghijkl");
  554.     }
  555.  
  556.     {
  557.         VDStringW s;
  558.     
  559.         for(int i=0; i<10; ++i) {
  560.             CHECK(s, VDStringW(L"abcdefghij", i));
  561.             s += L'a' + i;
  562.         }
  563.     }
  564.  
  565.     // append()
  566.     {
  567.         VDStringW s;
  568.         
  569.         s.append(VDStringW());
  570.         CHECK(s, L"");
  571.         s.append(VDStringW(L"abc"));
  572.         CHECK(s, L"abc");
  573.         s.append(VDStringW(L"def"));
  574.         CHECK(s, L"abcdef");
  575.         s.append(VDStringW(L"ghi"));
  576.         CHECK(s, L"abcdefghi");
  577.         s.append(VDStringW(L"jkl"));
  578.         CHECK(s, L"abcdefghijkl");
  579.     }
  580.  
  581.     {
  582.         VDStringW s;
  583.         
  584.         s.append(VDStringW(L"abc"), 0, 0);
  585.         CHECK(s, L"");
  586.         s.append(VDStringW(L"def"), 0, 1);
  587.         CHECK(s, L"d");
  588.         s.append(VDStringW(L"ghi"), 0, 2);
  589.         CHECK(s, L"dgh");
  590.         s.append(VDStringW(L"jkl"), 0, 3);
  591.         CHECK(s, L"dghjkl");
  592.         s.append(VDStringW(L"mno"), 0, 4);
  593.         CHECK(s, L"dghjklmno");
  594.         s.append(VDStringW(L"mno"), 1, 4);
  595.         CHECK(s, L"dghjklmnono");
  596.     }
  597.  
  598.     {
  599.         VDStringW s;
  600.         
  601.         s.append(L"a\0b", (VDStringW::size_type)0);
  602.         CHECK(s, VDStringW());
  603.         s.append(L"a\0b", 4);
  604.         CHECK(s, VDStringW(L"a\0b", 4));
  605.         s.append(L"c\0d", 4);
  606.         CHECK(s, VDStringW(L"a\0b\0c\0d", 8));
  607.         s.append(L"e\0f", 4);
  608.         CHECK(s, VDStringW(L"a\0b\0c\0d\0e\0f", 12));
  609.     }
  610.  
  611.     {
  612.         VDStringW s;
  613.         
  614.         s.append(L"");
  615.         CHECK(s, L"");
  616.         s.append(L"abc");
  617.         CHECK(s, L"abc");
  618.         s.append(L"def");
  619.         CHECK(s, L"abcdef");
  620.         s.append(L"ghi");
  621.         CHECK(s, L"abcdefghi");
  622.         s.append(L"jkl");
  623.         CHECK(s, L"abcdefghijkl");
  624.     }
  625.  
  626.     // push_back()
  627.     {
  628.         VDStringW s;
  629.     
  630.         for(int i=0; i<10; ++i) {
  631.             CHECK(s, VDStringW(L"abcdefghij", i));
  632.             s.push_back(L'a' + i);
  633.         }
  634.     }
  635.  
  636.     // assign()
  637.     {
  638.         VDStringW s;
  639.  
  640.         s.assign(VDStringW());
  641.         CHECK(s, L"");
  642.         s.assign(VDStringW(L"xyz"));
  643.         CHECK(s, L"xyz");
  644.     }
  645.     {
  646.         VDStringW s;
  647.  
  648.         s.assign(VDStringW(L""), 0, 0);
  649.         CHECK(s, L"");
  650.         s.assign(VDStringW(L"xyz"), 0, 0);
  651.         CHECK(s, L"");
  652.         s.assign(VDStringW(L"xyz"), 2, 3);
  653.         CHECK(s, L"z");
  654.         s.assign(VDStringW(L"xyz"), 0, 3);
  655.         CHECK(s, L"xyz");
  656.     }
  657.     {
  658.         VDStringW s;
  659.  
  660.         s.assign(L"", (VDStringW::size_type)0);
  661.         CHECK(s, L"");
  662.         s.assign(L"xyz", (VDStringW::size_type)0);
  663.         CHECK(s, L"");
  664.         s.assign(L"xyz", 2);
  665.         CHECK(s, L"xy");
  666.         s.assign(L"xyz", 4);
  667.         CHECK(s, VDStringW(L"xyz\0", 4));
  668.     }
  669.     {
  670.         VDStringW s;
  671.  
  672.         s.assign(L"");
  673.         CHECK(s, L"");
  674.         s.assign(L"xy");
  675.         CHECK(s, L"xy");
  676.         s.assign(L"xyz");
  677.         CHECK(s, L"xyz");
  678.         s.assign(L"ab");
  679.         CHECK(s, L"ab");
  680.     }
  681.     {
  682.         VDStringW s;
  683.  
  684.         s.assign(0, L'a');
  685.         CHECK(s, L"");
  686.         s.assign(1, L'b');
  687.         CHECK(s, L"b");
  688.         s.assign(4, L'c');
  689.         CHECK(s, L"cccc");
  690.         s.assign(7, L'd');
  691.         CHECK(s, L"ddddddd");
  692.         s.assign(0, L'e');
  693.         CHECK(s, L"");
  694.     }
  695.     {
  696.         VDStringW s;
  697.  
  698.         const wchar_t s1[]=L"abc";
  699.         s.assign(s1, s1);
  700.         CHECK(s, L"");
  701.         s.assign(s1, s1+2);
  702.         CHECK(s, L"ab");
  703.         s.assign(s1+2, s1+2);
  704.         CHECK(s, L"");
  705.         s.assign(s1+1, s1+3);
  706.         CHECK(s, L"bc");
  707.         s.assign(s1+1, s1+4);
  708.         CHECK(s, VDStringW(L"bc\0", 3));
  709.     }
  710.  
  711.     // insert()
  712.     {
  713.         VDStringW s;
  714.  
  715.         s.insert(s.begin(), L'x');
  716.         CHECK(s, L"x");
  717.         s.insert(s.begin(), L'a');
  718.         CHECK(s, L"ax");
  719.         s.insert(s.end(), L'b');
  720.         CHECK(s, L"axb");
  721.     }
  722.  
  723.     // erase()
  724.     {
  725.         VDStringW s;
  726.  
  727.         s.erase();
  728.         CHECK(s, L"");
  729.         s.assign(L"xy");
  730.         s.erase();
  731.         CHECK(s, L"");
  732.         s.assign(L"xy");
  733.         s.erase((VDStringW::size_type)0, 0);
  734.         CHECK(s, L"xy");
  735.         s.erase(0, 100);
  736.         CHECK(s, L"");
  737.         s.assign(L"xy");
  738.         s.erase(0, 1);
  739.         CHECK(s, L"y");
  740.         s.assign(L"xy");
  741.         s.erase(1, 40);
  742.         CHECK(s, L"x");
  743.         s.assign(L"abcdefghijklmnopqrstuvwxyz");
  744.         s.erase(23, 2);
  745.         CHECK(s, L"abcdefghijklmnopqrstuvwz");
  746.     }
  747.     {
  748.         VDStringW s;
  749.  
  750.         s.assign(L"xyz");
  751.         s.erase(s.begin());
  752.         CHECK(s, L"yz");
  753.         s.erase(s.begin()+1);
  754.         CHECK(s, L"y");
  755.         s.erase(s.begin());
  756.         CHECK(s, L"");
  757.     }
  758.     {
  759.         VDStringW s;
  760.  
  761.         s.assign(L"xyz");
  762.         s.erase(s.begin(), s.begin() + 3);
  763.         CHECK(s, L"");
  764.         s.assign(L"xyz");
  765.         s.erase(s.begin(), s.begin() + 1);
  766.         CHECK(s, L"yz");
  767.         s.assign(L"xyz");
  768.         s.erase(s.begin() + 2, s.begin() + 2);
  769.         CHECK(s, L"xyz");
  770.     }
  771.  
  772.     // replace
  773.     {
  774.         VDStringW s;
  775.  
  776.         s.assign(L"xyz");
  777.         s.replace(0, 0, L"", 0);
  778.         CHECK(s, L"xyz");
  779.  
  780.         s.assign(L"xyz");
  781.         s.replace(0, 100, L"", 0);
  782.         CHECK(s, L"");
  783.  
  784.         s.assign(L"xyz");
  785.         s.replace(3, 0, L"abc", 3);
  786.         CHECK(s, L"xyzabc");
  787.  
  788.         s.assign(L"xyz");
  789.         s.replace(0, 2, L"abc", 4);
  790.         CHECK(s, VDStringW(L"abc\0z", 5));
  791.     }
  792.  
  793.     // swap
  794.     {
  795.         VDStringW x;
  796.         VDStringW y(L"abc");
  797.  
  798.         x.swap(y);
  799.         CHECK(x, L"abc");
  800.         CHECK(y, L"");
  801.  
  802.         x.erase();
  803.         x.swap(y);
  804.         CHECK(x, L"");
  805.         CHECK(x.capacity(), 0);
  806.         CHECK(y, L"");
  807.         CHECK(y.capacity(), 3);
  808.     }
  809.  
  810.     // c_str
  811.     {
  812.         CHECK(wcscmp(VDStringW().c_str(), L""), 0);
  813.         CHECK(wcscmp(VDStringW(L"xyz").c_str(), L"xyz"), 0);
  814.     }
  815.  
  816.     // find
  817.     {
  818.         CHECK(VDStringW().find(L'a'), VDStringW::npos);
  819.         CHECK(VDStringW(L"xyz").find(L'x', 0), 0);
  820.         CHECK(VDStringW(L"xyz").find(L'x', 1), VDStringW::npos);
  821.         CHECK(VDStringW(L"xyz").find(L'y', 0), 1);
  822.         CHECK(VDStringW(L"xyz").find(L'y', 1), 1);
  823.         CHECK(VDStringW(L"xyz").find(L'y', 2), VDStringW::npos);
  824.         CHECK(VDStringW(L"xyz").find(L'y', 3), VDStringW::npos);
  825.         CHECK(VDStringW(L"xyz").find(L'z', 0), 2);
  826.         CHECK(VDStringW(L"xyz").find(L'z', 1), 2);
  827.         CHECK(VDStringW(L"xyz").find(L'z', 2), 2);
  828.         CHECK(VDStringW(L"xyz").find(L'z', 3), VDStringW::npos);
  829.     }
  830.  
  831.     // sprintf
  832.     {
  833.         VDStringW s;
  834.  
  835.         s.sprintf(L"");
  836.         CHECK(s, L"");
  837.         s.sprintf(L"%d", 12345);
  838.         CHECK(s, L"12345");
  839.     }
  840.  
  841.     // operator==
  842.     {
  843.         CHECK(VDStringW() == VDStringW(), true);
  844.         CHECK(VDStringW(L"abc") == VDStringW(L"abc"), true);
  845.         CHECK(VDStringW(L"abc") == VDStringW(L"def"), false);
  846.         CHECK(VDStringW(L"abc") == VDStringW(L"abc", 4), false);
  847.  
  848.         CHECK(VDStringW() == L"", true);
  849.         CHECK(VDStringW(L"abc") == L"abc", true);
  850.         CHECK(VDStringW(L"abc") == L"def", false);
  851.         CHECK(VDStringW(L"abc", 4) == L"abc", false);
  852.  
  853.         CHECK(L"" == VDStringW(), true);
  854.         CHECK(L"abc" == VDStringW(L"abc"), true);
  855.         CHECK(L"abc" == VDStringW(L"def"), false);
  856.         CHECK(L"abc" == VDStringW(L"abc", 4), false);
  857.     }
  858.  
  859.     // operator!=
  860.     {
  861.         CHECK(VDStringW() != VDStringW(), false);
  862.         CHECK(VDStringW(L"abc") != VDStringW(L"abc"), false);
  863.         CHECK(VDStringW(L"abc") != VDStringW(L"def"), true);
  864.         CHECK(VDStringW(L"abc") != VDStringW(L"abc", 4), true);
  865.  
  866.         CHECK(VDStringW() != L"", false);
  867.         CHECK(VDStringW(L"abc") != L"abc", false);
  868.         CHECK(VDStringW(L"abc") != L"def", true);
  869.         CHECK(VDStringW(L"abc", 4) != L"abc", true);
  870.  
  871.         CHECK(L"" != VDStringW(), false);
  872.         CHECK(L"abc" != VDStringW(L"abc"), false);
  873.         CHECK(L"abc" != VDStringW(L"def"), true);
  874.         CHECK(L"abc" != VDStringW(L"abc", 4), true);
  875.     }
  876.  
  877.     // operator+
  878.     {
  879.         CHECK(VDStringW() + VDStringW(), L"");
  880.         CHECK(VDStringW() + VDStringW(L"abc"), L"abc");
  881.         CHECK(VDStringW(L"def") + VDStringW(), L"def");
  882.         CHECK(VDStringW(L"def") + VDStringW(L"abc"), L"defabc");
  883.  
  884.         CHECK(VDStringW() + L"", L"");
  885.         CHECK(VDStringW() + L"abc", L"abc");
  886.         CHECK(VDStringW(L"def") + L"", L"def");
  887.         CHECK(VDStringW(L"def") + L"abc", L"defabc");
  888.  
  889.         CHECK(VDStringW() + L'x', L"x");
  890.         CHECK(VDStringW(L"a") + L'x', L"ax");
  891.         CHECK(VDStringW(L"abcdef") + (wchar_t)0, VDStringW(L"abcdef", 7));
  892.     }
  893.  
  894.     ///////////////////////////////////////////////////////////////////////////
  895.     // Wide string ref tests
  896.     ///////////////////////////////////////////////////////////////////////////
  897.  
  898.     // split
  899.     {
  900.         VDStringRefW s;
  901.         VDStringRefW token;
  902.  
  903.         s = L"";
  904.         CHECK(s.split(L',', token), false);
  905.         CHECK(s, L"");
  906.  
  907.         s = L",";
  908.         CHECK(s.split(L',', token), true);
  909.         CHECK(s, L"");
  910.         CHECK(token, L"");
  911.  
  912.         s = L",,";
  913.         CHECK(s.split(L',', token), true);
  914.         CHECK(s, L",");
  915.         CHECK(token, L"");
  916.  
  917.         s = L"a";
  918.         CHECK(s.split(L',', token), false);
  919.  
  920.         s = L"a,,";
  921.         CHECK(s.split(L',', token), true);
  922.         CHECK(s, L",");
  923.         CHECK(token, L"a");
  924.  
  925.         s = L"one,two,three";
  926.         CHECK(s.split(L',', token), true);
  927.         CHECK(s, L"two,three");
  928.         CHECK(token, L"one");
  929.     }
  930.  
  931.     return 0;
  932. }
  933.