assert on strange lengths of string literals

It's better to detect corner cases this way rather than get possibly
incorrect results. And strlen() should be easy to optimize out
for string literals.

Change-Id: Id762e256207668a0cbefe4e13d5f2067f373e783

8 files changed, 54 insertions, 9 deletions

diff --git a/sal/inc/rtl/strbuf.hxx b/sal/inc/rtl/strbuf.hxx
index 945d1d2b179a..5efd0557430e 100644
--- a/sal/inc/rtl/strbuf.hxx
+++ b/sal/inc/rtl/strbuf.hxx
@@ -196,6 +196,7 @@ public:
         : pData(NULL)
         , nCapacity( internal::ConstCharArrayDetector< T, void >::size - 1 + 16 )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 16 );
 #ifdef RTL_STRING_UNITTEST
         rtl_string_unittest_const_literal = true;
@@ -463,6 +464,7 @@ public:
     typename internal::ConstCharArrayDetector< T, OStringBuffer& >::Type append( T& literal )
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_stringbuffer_insert( &pData, &nCapacity, getLength(), literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
         return *this;
     }
@@ -652,6 +654,7 @@ public:
     typename internal::ConstCharArrayDetector< T, OStringBuffer& >::Type insert( sal_Int32 offset, T& literal )
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_stringbuffer_insert( &pData, &nCapacity, offset, literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
         return *this;
     }
diff --git a/sal/inc/rtl/string.hxx b/sal/inc/rtl/string.hxx
index a2cee5153d2f..2c7a43dba897 100644
--- a/sal/inc/rtl/string.hxx
+++ b/sal/inc/rtl/string.hxx
@@ -202,6 +202,7 @@ public:
     template< typename T >
     OString( T& literal, typename internal::ConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy() ) SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         pData = 0;
         rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
 #ifdef RTL_STRING_UNITTEST
@@ -295,6 +296,7 @@ public:
     typename internal::ConstCharArrayDetector< T, OString& >::Type operator=( T& literal ) SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_string_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
         return *this;
     }
@@ -529,6 +531,7 @@ public:
     typename internal::ConstCharArrayDetector< T, bool >::Type  equalsIgnoreAsciiCase( T& literal ) const SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         if ( pData->length != internal::ConstCharArrayDetector< T, void >::size - 1 )
             return false;
         return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
@@ -594,6 +597,7 @@ public:
     typename internal::ConstCharArrayDetector< T, bool >::Type  match( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_str_shortenedCompare_WithLength(
             pData->buffer + fromIndex, pData->length - fromIndex,
             literal, internal::ConstCharArrayDetector< T, void >::size - 1, internal::ConstCharArrayDetector< T, void >::size - 1) == 0;
@@ -666,6 +670,7 @@ public:
     typename internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
             literal, internal::ConstCharArrayDetector< T, void >::size - 1, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     }
@@ -720,6 +725,7 @@ public:
     typename internal::ConstCharArrayDetector< T, bool >::Type endsWith( T& literal ) const
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return internal::ConstCharArrayDetector< T, void >::size - 1 <= getLength()
             && match(literal, getLength() - ( internal::ConstCharArrayDetector< T, void >::size - 1 ));
     }
@@ -788,6 +794,7 @@ public:
     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator==( const OString& rStr, T& literal ) SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rStr.getLength() == internal::ConstCharArrayDetector< T, void >::size - 1
             && rtl_str_compare_WithLength( rStr.pData->buffer, rStr.pData->length, literal,
                 internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
@@ -802,6 +809,7 @@ public:
     friend typename internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OString& rStr ) SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rStr.getLength() == internal::ConstCharArrayDetector< T, void >::size - 1
             && rtl_str_compare_WithLength( rStr.pData->buffer, rStr.pData->length, literal,
                 internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
@@ -946,6 +954,7 @@ public:
     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
         RTL_STRING_CONST_FUNCTION
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         sal_Int32 n = rtl_str_indexOfStr_WithLength(
             pData->buffer + fromIndex, pData->length - fromIndex, literal, internal::ConstCharArrayDetector< T, void >::size - 1);
         return n < 0 ? n : n + fromIndex;
@@ -1466,7 +1475,7 @@ This class is not part of public API and is meant to be used only in LibreOffice
 struct SAL_WARN_UNUSED OStringLiteral
 {
     template< int N >
-    OStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) {}
+    OStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
     int size;
     const char* data;
 };
diff --git a/sal/inc/rtl/stringconcat.hxx b/sal/inc/rtl/stringconcat.hxx
index fddf6ed49b6f..9fb95680faa7 100644
--- a/sal/inc/rtl/stringconcat.hxx
+++ b/sal/inc/rtl/stringconcat.hxx
@@ -128,7 +128,7 @@ struct ToStringHelper< char[ N ] >
 template< int N >
 struct ToStringHelper< const char[ N ] >
     {
-    static int length( const char[ N ] ) { return N - 1; }
+    static int length( const char str[ N ] ) { assert( strlen( str ) == N - 1 ); return N - 1; }
     static char* addData( char* buffer, const char str[ N ] ) { return addDataHelper( buffer, str, N - 1 ); }
     static sal_Unicode* addData( sal_Unicode* buffer, const char str[ N ] ) { return addDataLiteral( buffer, str, N - 1 ); }
     static const bool allowOStringConcat = true;
diff --git a/sal/inc/rtl/stringutils.hxx b/sal/inc/rtl/stringutils.hxx
index b1e19e5327b1..c6e44b66d4b1 100644
--- a/sal/inc/rtl/stringutils.hxx
+++ b/sal/inc/rtl/stringutils.hxx
@@ -124,7 +124,7 @@ struct NonConstCharArrayDetector< const char[], T >
 };
 #endif
 
-template< typename T1, typename T2 >
+template< typename T1, typename T2 = void >
 struct ConstCharArrayDetector
 {
     static const bool ok = false;
diff --git a/sal/inc/rtl/ustrbuf.hxx b/sal/inc/rtl/ustrbuf.hxx
index 7d36356cd404..06d906e864eb 100644
--- a/sal/inc/rtl/ustrbuf.hxx
+++ b/sal/inc/rtl/ustrbuf.hxx
@@ -150,6 +150,7 @@ public:
         : pData(NULL)
         , nCapacity( N - 1 + 16 )
     {
+        assert( strlen( literal ) == N - 1 );
         rtl_uString_newFromLiteral( &pData, literal, N - 1, 16 );
 #ifdef RTL_STRING_UNITTEST
         rtl_string_unittest_const_literal = true;
@@ -179,6 +180,7 @@ public:
         : pData(NULL)
         , nCapacity( internal::ConstCharArrayDetector< T, void >::size - 1 + 16 )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uString_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 16 );
 #ifdef RTL_STRING_UNITTEST
         rtl_string_unittest_const_literal = true;
@@ -480,6 +482,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, OUStringBuffer& >::Type append( T& literal )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uStringbuffer_insert_ascii( &pData, &nCapacity, getLength(), literal,
             internal::ConstCharArrayDetector< T, void >::size - 1 );
         return *this;
@@ -740,6 +743,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, OUStringBuffer& >::Type insert( sal_Int32 offset, T& literal )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uStringbuffer_insert_ascii( &pData, &nCapacity, offset, literal,
             internal::ConstCharArrayDetector< T, void >::size - 1 );
         return *this;
@@ -1097,6 +1101,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
             pData->buffer + fromIndex, pData->length - fromIndex, literal,
             internal::ConstCharArrayDetector< T, void >::size - 1);
@@ -1159,6 +1164,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_ustr_lastIndexOfAscii_WithLength(
             pData->buffer, pData->length, literal, internal::ConstCharArrayDetector< T, void >::size - 1);
     }
diff --git a/sal/inc/rtl/ustring.hxx b/sal/inc/rtl/ustring.hxx
index ec7c29009d55..534bd889f05a 100644
--- a/sal/inc/rtl/ustring.hxx
+++ b/sal/inc/rtl/ustring.hxx
@@ -198,6 +198,9 @@ public:
     template< int N >
     OUString( const char (&literal)[ N ] )
     {
+        // Check that the string literal is in fact N - 1 long (no embedded \0's),
+        // any decent compiler should optimize out calls to strlen with literals.
+        assert( strlen( literal ) == N - 1 );
         pData = 0;
         rtl_uString_newFromLiteral( &pData, literal, N - 1, 0 );
 #ifdef RTL_STRING_UNITTEST
@@ -225,6 +228,7 @@ public:
     template< typename T >
     OUString( T& literal, typename internal::ConstCharArrayDetector< T, internal::Dummy >::Type = internal::Dummy() )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         pData = 0;
         rtl_uString_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
 #ifdef RTL_STRING_UNITTEST
@@ -381,6 +385,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, OUString& >::Type operator=( T& literal )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uString_newFromLiteral( &pData, literal, internal::ConstCharArrayDetector< T, void >::size - 1, 0 );
         return *this;
     }
@@ -571,6 +576,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& literal ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         if ( pData->length != internal::ConstCharArrayDetector< T, void >::size - 1 )
             return sal_False;
 
@@ -606,6 +612,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type match( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
             literal, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     }
@@ -643,6 +650,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
             literal, internal::ConstCharArrayDetector< T, void >::size - 1 ) == 0;
     }
@@ -933,6 +941,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type startsWith( T& literal ) const
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
             && rtl_ustr_asciil_reverseEquals_WithLength( pData->buffer, literal,
                 internal::ConstCharArrayDetector< T, void >::size - 1);
@@ -964,6 +973,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type startsWithIgnoreAsciiCase( T& literal ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                     pData->buffer,
                     internal::ConstCharArrayDetector< T, void >::size - 1, literal,
@@ -994,6 +1004,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type endsWith( T& literal ) const
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
             && rtl_ustr_asciil_reverseEquals_WithLength(
                 pData->buffer + pData->length - ( internal::ConstCharArrayDetector< T, void >::size - 1 ), literal,
@@ -1047,6 +1058,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, bool >::Type endsWithIgnoreAsciiCase( T& literal ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return internal::ConstCharArrayDetector< T, void >::size - 1 <= pData->length
             && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                     pData->buffer + pData->length - ( internal::ConstCharArrayDetector< T, void >::size - 1 ),
@@ -1108,6 +1120,7 @@ public:
     template< typename T >
     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator==( const OUString& string, T& literal )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     }
     /**
@@ -1120,6 +1133,7 @@ public:
     template< typename T >
     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OUString& string )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     }
     /**
@@ -1132,6 +1146,7 @@ public:
     template< typename T >
     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OUString& string, T& literal )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return !string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     }
     /**
@@ -1144,6 +1159,7 @@ public:
     template< typename T >
     friend inline typename internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OUString& string )
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return !string.equalsAsciiL( literal, internal::ConstCharArrayDetector< T, void >::size - 1 );
     }
 
@@ -1239,6 +1255,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
             pData->buffer + fromIndex, pData->length - fromIndex, literal,
             internal::ConstCharArrayDetector< T, void >::size - 1);
@@ -1337,6 +1354,7 @@ public:
     template< typename T >
     typename internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const SAL_THROW(())
     {
+        assert( strlen( literal ) == internal::ConstCharArrayDetector< T >::size - 1 );
         return rtl_ustr_lastIndexOfAscii_WithLength(
             pData->buffer, pData->length, literal, internal::ConstCharArrayDetector< T, void >::size - 1);
     }
@@ -1517,6 +1535,7 @@ public:
     {
         rtl_uString * s = 0;
         sal_Int32 i = 0;
+        assert( strlen( from ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uString_newReplaceFirstAsciiL(
             &s, pData, from, internal::ConstCharArrayDetector< T, void >::size - 1, to.pData, index == 0 ? &i : index);
         return OUString(s, SAL_NO_ACQUIRE);
@@ -1546,6 +1565,8 @@ public:
     {
         rtl_uString * s = 0;
         sal_Int32 i = 0;
+        assert( strlen( from ) == internal::ConstCharArrayDetector< T1 >::size - 1 );
+        assert( strlen( to ) == internal::ConstCharArrayDetector< T2 >::size - 1 );
         rtl_uString_newReplaceFirstAsciiLAsciiL(
             &s, pData, from, internal::ConstCharArrayDetector< T1, void >::size - 1, to,
             internal::ConstCharArrayDetector< T2, void >::size - 1, index == 0 ? &i : index);
@@ -1590,6 +1611,7 @@ public:
     typename internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( T& from, OUString const & to) const
     {
         rtl_uString * s = 0;
+        assert( strlen( from ) == internal::ConstCharArrayDetector< T >::size - 1 );
         rtl_uString_newReplaceAllAsciiL(&s, pData, from, internal::ConstCharArrayDetector< T, void >::size - 1, to.pData);
         return OUString(s, SAL_NO_ACQUIRE);
     }
@@ -1612,6 +1634,8 @@ public:
         replaceAll( T1& from, T2& to ) const
     {
         rtl_uString * s = 0;
+        assert( strlen( from ) == internal::ConstCharArrayDetector< T1 >::size - 1 );
+        assert( strlen( to ) == internal::ConstCharArrayDetector< T2 >::size - 1 );
         rtl_uString_newReplaceAllAsciiLAsciiL(
             &s, pData, from, internal::ConstCharArrayDetector< T1, void >::size - 1,
             to, internal::ConstCharArrayDetector< T2, void >::size - 1);
@@ -2094,7 +2118,7 @@ This class is not part of public API and is meant to be used only in LibreOffice
 struct SAL_WARN_UNUSED OUStringLiteral
 {
     template< int N >
-    OUStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) {}
+    OUStringLiteral( const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
     int size;
     const char* data;
 };
diff --git a/sal/qa/rtl/strings/test_ostring_stringliterals.cxx b/sal/qa/rtl/strings/test_ostring_stringliterals.cxx
index 8a78b89adfa7..9276e99c7cec 100644
--- a/sal/qa/rtl/strings/test_ostring_stringliterals.cxx
+++ b/sal/qa/rtl/strings/test_ostring_stringliterals.cxx
@@ -114,10 +114,10 @@ void test::ostring::StringLiterals::checkCtors()
 #endif
 
 // This one is technically broken, since the first element is 6 characters test\0\0,
-// but there does not appear a way to detect this by compile time (runtime will complain).
+// but there does not appear a way to detect this by compile time (runtime will assert()).
 // RTL_CONSTASCII_USTRINGPARAM() has the same flaw.
     const char bad7[][ 6 ] = { "test", "test2" };
-    CPPUNIT_ASSERT( CONST_CTOR_USED( bad7[ 0 ] ));
+//    CPPUNIT_ASSERT( CONST_CTOR_USED( bad7[ 0 ] ));
     CPPUNIT_ASSERT( CONST_CTOR_USED( bad7[ 1 ] ));
 
 // Check that contents are correct and equal to the case when const char* ctor is used.
diff --git a/sal/qa/rtl/strings/test_oustring_stringliterals.cxx b/sal/qa/rtl/strings/test_oustring_stringliterals.cxx
index 8d8254342334..a6d7145b9700 100644
--- a/sal/qa/rtl/strings/test_oustring_stringliterals.cxx
+++ b/sal/qa/rtl/strings/test_oustring_stringliterals.cxx
@@ -89,18 +89,21 @@ void test::oustring::StringLiterals::checkCtors()
     testcall( good1 );
 
 // This one is technically broken, since the first element is 6 characters test\0\0,
-// but there does not appear a way to detect this by compile time (runtime will complain).
+// but there does not appear a way to detect this by compile time (runtime will assert()).
 // RTL_CONSTASCII_USTRINGPARAM() has the same flaw.
     const char bad5[][ 6 ] = { "test", "test2" };
 //    CPPUNIT_ASSERT( VALID_CONVERSION( bad5[ 0 ] ));
     CPPUNIT_ASSERT( VALID_CONVERSION( bad5[ 1 ] ));
 
 // Check that contents are correct and equal to the case when RTL_CONSTASCII_USTRINGPARAM is used.
-// Also check that embedded \0 is included.
     CPPUNIT_ASSERT_EQUAL( rtl::OUString( "" ), rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "" )));
-    CPPUNIT_ASSERT_EQUAL( rtl::OUString( "\0" ), rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\0" )));
     CPPUNIT_ASSERT_EQUAL( rtl::OUString( "ab" ), rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ab" )));
+#if 0
+// Also check that embedded \0 is included.
+// In fact, allowing this is probably just trouble, so this now asserts.
+    CPPUNIT_ASSERT_EQUAL( rtl::OUString( "\0" ), rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\0" )));
     CPPUNIT_ASSERT_EQUAL( rtl::OUString( "a\0b" ), rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "a\0b" )));
+#endif
 }
 
 void test::oustring::StringLiterals::testcall( const char str[] )