no need to use a throw-away bitmap, just use th eone built-in to the

[wxWidgets.git] / tests / strings / strings.cpp

diff --git a/tests/strings/strings.cpp b/tests/strings/strings.cpp
index 25b8a595748916deaf85d43e61798fed3e2debd3..34ec5197df7a2d0494768252d40eaa94c3908459 100644 (file)
--- a/tests/strings/strings.cpp
+++ b/tests/strings/strings.cpp
@@ -37,14 +37,20 @@ private:
         CPPUNIT_TEST( Format );
         CPPUNIT_TEST( Constructors );
         CPPUNIT_TEST( Extraction );
         CPPUNIT_TEST( Format );
         CPPUNIT_TEST( Constructors );
         CPPUNIT_TEST( Extraction );

+        CPPUNIT_TEST( Trim );

         CPPUNIT_TEST( Find );
         CPPUNIT_TEST( Replace );
         CPPUNIT_TEST( Match );
         CPPUNIT_TEST( CaseChanges );
         CPPUNIT_TEST( Compare );
         CPPUNIT_TEST( CompareNoCase );
         CPPUNIT_TEST( Find );
         CPPUNIT_TEST( Replace );
         CPPUNIT_TEST( Match );
         CPPUNIT_TEST( CaseChanges );
         CPPUNIT_TEST( Compare );
         CPPUNIT_TEST( CompareNoCase );

+        CPPUNIT_TEST( Contains );

         CPPUNIT_TEST( ToLong );
         CPPUNIT_TEST( ToULong );
         CPPUNIT_TEST( ToLong );
         CPPUNIT_TEST( ToULong );

+#ifdef wxLongLong_t
+        CPPUNIT_TEST( ToLongLong );
+        CPPUNIT_TEST( ToULongLong );
+#endif // wxLongLong_t

         CPPUNIT_TEST( ToDouble );
     CPPUNIT_TEST_SUITE_END();
 
         CPPUNIT_TEST( ToDouble );
     CPPUNIT_TEST_SUITE_END();
 


@@ -53,14 +59,20 @@ private:
     void Format();
     void Constructors();
     void Extraction();
     void Format();
     void Constructors();
     void Extraction();

+    void Trim();

     void Find();
     void Replace();
     void Match();
     void CaseChanges();
     void Compare();
     void CompareNoCase();
     void Find();
     void Replace();
     void Match();
     void CaseChanges();
     void Compare();
     void CompareNoCase();

+    void Contains();

     void ToLong();
     void ToULong();
     void ToLong();
     void ToULong();

+#ifdef wxLongLong_t
+    void ToLongLong();
+    void ToULongLong();
+#endif // wxLongLong_t

     void ToDouble();
 
     DECLARE_NO_COPY_CLASS(StringTestCase)
     void ToDouble();
 
     DECLARE_NO_COPY_CLASS(StringTestCase)


@@ -198,6 +210,24 @@ void StringTestCase::Extraction()
     #undef TEST_ENDS_WITH
 }
 
     #undef TEST_ENDS_WITH
 }
 

+void StringTestCase::Trim()
+{
+    #define TEST_TRIM( str , dir , result )  \
+        CPPUNIT_ASSERT( wxString(str).Trim(dir) == result )
+
+    TEST_TRIM( _T("  Test  "),  true, _T("  Test") );
+    TEST_TRIM( _T("    "),      true, _T("")       );
+    TEST_TRIM( _T(" "),         true, _T("")       );
+    TEST_TRIM( _T(""),          true, _T("")       );
+
+    TEST_TRIM( _T("  Test  "),  false, _T("Test  ") );
+    TEST_TRIM( _T("    "),      false, _T("")       );
+    TEST_TRIM( _T(" "),         false, _T("")       );
+    TEST_TRIM( _T(""),          false, _T("")       );
+
+    #undef TEST_TRIM
+}
+

 void StringTestCase::Find()
 {
     #define TEST_FIND( str , start , result )  \
 void StringTestCase::Find()
 {
     #define TEST_FIND( str , start , result )  \


@@ -390,62 +420,153 @@ void StringTestCase::CompareNoCase()
     CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
 }
 
     CPPUNIT_CNCNEQ_ASSERT( s1, neq3 );
 }
 

-void StringTestCase::ToLong()
+void StringTestCase::Contains()

 {
 {

-    long l;
-    static const struct ToLongData
+    static const struct ContainsData

     {
     {

-        const wxChar *str;
-        long value;
-        bool ok;
-    } longData[] =
+        const wxChar *hay;
+        const wxChar *needle;
+        bool contains;
+    } containsData[] =

     {
     {

-        { _T("1"), 1, true },
-        { _T("0"), 0, true },
-        { _T("a"), 0, false },
-        { _T("12345"), 12345, true },
-        { _T("-1"), -1, true },
-        { _T("--1"), 0, false },
+        { _T(""),       _T(""),         true  },
+        { _T(""),       _T("foo"),      false },
+        { _T("foo"),    _T(""),         true  },
+        { _T("foo"),    _T("f"),        true  },
+        { _T("foo"),    _T("o"),        true  },
+        { _T("foo"),    _T("oo"),       true  },
+        { _T("foo"),    _T("ooo"),      false },
+        { _T("foo"),    _T("oooo"),     false },
+        { _T("foo"),    _T("fooo"),     false },

     };
 
     };
 

-    size_t n;
-    for ( n = 0; n < WXSIZEOF(longData); n++ )
+    for ( size_t n = 0; n < WXSIZEOF(containsData); n++ )
+    {
+        const ContainsData& cd = containsData[n];
+        CPPUNIT_ASSERT_EQUAL( cd.contains, wxString(cd.hay).Contains(cd.needle) );
+    }
+}
+
+// flags used in ToLongData.flags
+enum
+{
+    Number_Ok       = 0,
+    Number_Invalid  = 1,
+    Number_Unsigned = 2,    // if not specified, works for signed conversion
+    Number_Signed   = 4,    // if not specified, works for unsigned
+    Number_LongLong = 8,    // only for long long tests
+    Number_Long     = 16,   // only for long tests
+};
+
+static const struct ToLongData
+{
+    const wxChar *str;
+#ifdef wxLongLong_t
+    wxLongLong_t value;
+#else
+    long value;
+#endif // wxLongLong_t
+    int flags;
+
+    long LValue() const { return value; }
+    unsigned long ULValue() const { return value; }
+#ifdef wxLongLong_t
+    wxLongLong_t LLValue() const { return value; }
+    wxULongLong_t ULLValue() const { return (wxULongLong_t)value; }
+#endif // wxLongLong_t
+
+    bool IsOk() const { return !(flags & Number_Invalid); }
+} longData[] =
+{
+    { _T("1"), 1, Number_Ok },
+    { _T("0"), 0, Number_Ok },
+    { _T("a"), 0, Number_Invalid },
+    { _T("12345"), 12345, Number_Ok },
+    { _T("--1"), 0, Number_Invalid },
+
+    { _T("-1"), -1, Number_Signed | Number_Long },
+    // this is surprizing but consistent with strtoul() behaviour
+    { _T("-1"), ULONG_MAX, Number_Unsigned | Number_Long },
+
+    // this must overflow, even with 64 bit long
+    { _T("922337203685477580711"), 0, Number_Invalid },
+
+#ifdef wxLongLong_t
+    { _T("2147483648"), wxLL(2147483648), Number_LongLong },
+    { _T("-2147483648"), wxLL(-2147483648), Number_LongLong | Number_Signed },
+    { _T("9223372036854775808"), wxULL(9223372036854775808), Number_LongLong |
+                                                             Number_Unsigned },
+#endif // wxLongLong_t
+};
+
+void StringTestCase::ToLong()
+{
+    long l;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )

     {
         const ToLongData& ld = longData[n];
     {
         const ToLongData& ld = longData[n];

-        CPPUNIT_ASSERT_EQUAL( ld.ok, wxString(ld.str).ToLong(&l) );
-        if ( ld.ok )
-            CPPUNIT_ASSERT_EQUAL( ld.value, l );
+
+        if ( ld.flags & (Number_LongLong | Number_Unsigned) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLong(&l) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.LValue(), l );

     }
 }
 
 void StringTestCase::ToULong()
 {
     unsigned long ul;
     }
 }
 
 void StringTestCase::ToULong()
 {
     unsigned long ul;

-    static const struct ToULongData
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )

     {
     {

-        const wxChar *str;
-        unsigned long value;
-        bool ok;
-    } ulongData[] =
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_LongLong | Number_Signed) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULong(&ul) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul );
+    }
+}
+
+#ifdef wxLongLong_t
+
+void StringTestCase::ToLongLong()
+{
+    wxLongLong_t l;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )

     {
     {

-        { _T("1"), 1, true },
-        { _T("0"), 0, true },
-        { _T("a"), 0, false },
-        { _T("12345"), 12345, true },
-        // this is surprizing but consistent with strtoul() behaviour
-        { _T("-1"), ULONG_MAX, true },
-    };
+        const ToLongData& ld = longData[n];

 
 

-    size_t n;
-    for ( n = 0; n < WXSIZEOF(ulongData); n++ )
+        if ( ld.flags & (Number_Long | Number_Unsigned) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLongLong(&l) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.LLValue(), l );
+    }
+}
+
+void StringTestCase::ToULongLong()
+{
+    wxULongLong_t ul;
+    for ( size_t n = 0; n < WXSIZEOF(longData); n++ )

     {
     {

-        const ToULongData& uld = ulongData[n];
-        CPPUNIT_ASSERT_EQUAL( uld.ok, wxString(uld.str).ToULong(&ul) );
-        if ( uld.ok )
-            CPPUNIT_ASSERT_EQUAL( uld.value, ul );
+        const ToLongData& ld = longData[n];
+
+        if ( ld.flags & (Number_Long | Number_Signed) )
+            continue;
+
+        CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULongLong(&ul) );
+        if ( ld.IsOk() )
+            CPPUNIT_ASSERT_EQUAL( ld.ULLValue(), ul );

     }
 }
 
     }
 }
 

+#endif // wxLongLong_t
+

 void StringTestCase::ToDouble()
 {
     double d;
 void StringTestCase::ToDouble()
 {
     double d;