Fix unit test style in Source/wtf/.

Source/wtf/text/WTFStringTest.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
+#include "wtf/text/WTFString.h"
 
 #include "wtf/MathExtras.h"
 #include "wtf/text/CString.h"
-#include "wtf/text/WTFString.h"
 #include <gtest/gtest.h>
 #include <limits>
 
-namespace {
+namespace WTF {
 
-TEST(WTF, StringCreationFromLiteral)
+TEST(StringTest, CreationFromLiteral)
 {
     String stringFromLiteral("Explicit construction syntax");
-    ASSERT_EQ(strlen("Explicit construction syntax"), stringFromLiteral.length());
-    ASSERT_TRUE(stringFromLiteral == "Explicit construction syntax");
-    ASSERT_TRUE(stringFromLiteral.is8Bit());
-    ASSERT_TRUE(String("Explicit construction syntax") == stringFromLiteral);
+    EXPECT_EQ(strlen("Explicit construction syntax"), stringFromLiteral.length());
+    EXPECT_TRUE(stringFromLiteral == "Explicit construction syntax");
+    EXPECT_TRUE(stringFromLiteral.is8Bit());
+    EXPECT_TRUE(String("Explicit construction syntax") == stringFromLiteral);
 }
 
-TEST(WTF, StringASCII)
+TEST(StringTest, ASCII)
 {
     CString output;
 
     // Null String.
     output = String().ascii();
-    ASSERT_STREQ("", output.data());
+    EXPECT_STREQ("", output.data());
 
     // Empty String.
     output = emptyString().ascii();
-    ASSERT_STREQ("", output.data());
+    EXPECT_STREQ("", output.data());
 
     // Regular String.
     output = String("foobar").ascii();
-    ASSERT_STREQ("foobar", output.data());
+    EXPECT_STREQ("foobar", output.data());
 }
 
 static void testNumberToStringECMAScript(double number, const char* reference)

[kochi, 2015/06/15 03:34:22]

Use anonymous namespace?

[tkent, 2015/06/15 04:45:57]

Done.

 {
     CString numberString = String::numberToStringECMAScript(number).latin1();
-    ASSERT_STREQ(reference, numberString.data());
+    EXPECT_STREQ(reference, numberString.data());
 }
 
-TEST(WTF, StringNumberToStringECMAScriptBoundaries)
+TEST(StringTest, NumberToStringECMAScriptBoundaries)
 {
     typedef std::numeric_limits<double> Limits;
 
     // Infinity.
     testNumberToStringECMAScript(Limits::infinity(), "Infinity");
     testNumberToStringECMAScript(-Limits::infinity(), "-Infinity");
 
     // NaN.
     testNumberToStringECMAScript(-Limits::quiet_NaN(), "NaN");
 
     // Zeros.
     testNumberToStringECMAScript(0, "0");
     testNumberToStringECMAScript(-0, "0");
 
     // Min-Max.
     testNumberToStringECMAScript(Limits::min(), "2.2250738585072014e-308");
     testNumberToStringECMAScript(Limits::max(), "1.7976931348623157e+308");
 }
 
-TEST(WTF, StringNumberToStringECMAScriptRegularNumbers)
+TEST(StringTest, NumberToStringECMAScriptRegularNumbers)
 {
     // Pi.
     testNumberToStringECMAScript(piDouble, "3.141592653589793");
     testNumberToStringECMAScript(piFloat, "3.1415927410125732");
     testNumberToStringECMAScript(piOverTwoDouble, "1.5707963267948966");
     testNumberToStringECMAScript(piOverTwoFloat, "1.5707963705062866");
     testNumberToStringECMAScript(piOverFourDouble, "0.7853981633974483");
     testNumberToStringECMAScript(piOverFourFloat, "0.7853981852531433");
 
     // e.
     const double e = 2.71828182845904523536028747135266249775724709369995;
     testNumberToStringECMAScript(e, "2.718281828459045");
 
     // c, speed of light in m/s.
     const double c = 299792458;
     testNumberToStringECMAScript(c, "299792458");
 
     // Golen ratio.
     const double phi = 1.6180339887498948482;
     testNumberToStringECMAScript(phi, "1.618033988749895");
 }
 
-TEST(WTF, StringReplaceWithLiteral)
+TEST(StringTest, ReplaceWithLiteral)
 {
     // Cases for 8Bit source.
     String testString = "1224";
-    ASSERT_TRUE(testString.is8Bit());
+    EXPECT_TRUE(testString.is8Bit());
     testString.replaceWithLiteral('2', "");
-    ASSERT_STREQ("14", testString.utf8().data());
+    EXPECT_STREQ("14", testString.utf8().data());
 
     testString = "1224";
-    ASSERT_TRUE(testString.is8Bit());
+    EXPECT_TRUE(testString.is8Bit());
     testString.replaceWithLiteral('2', "3");
-    ASSERT_STREQ("1334", testString.utf8().data());
+    EXPECT_STREQ("1334", testString.utf8().data());
 
     testString = "1224";
-    ASSERT_TRUE(testString.is8Bit());
+    EXPECT_TRUE(testString.is8Bit());
     testString.replaceWithLiteral('2', "555");
-    ASSERT_STREQ("15555554", testString.utf8().data());
+    EXPECT_STREQ("15555554", testString.utf8().data());
 
     testString = "1224";
-    ASSERT_TRUE(testString.is8Bit());
+    EXPECT_TRUE(testString.is8Bit());
     testString.replaceWithLiteral('3', "NotFound");
-    ASSERT_STREQ("1224", testString.utf8().data());
+    EXPECT_STREQ("1224", testString.utf8().data());
 
     // Cases for 16Bit source.
     // U+00E9 (=0xC3 0xA9 in UTF-8) is e with accent.
     testString = String::fromUTF8("r\xC3\xA9sum\xC3\xA9");
-    ASSERT_FALSE(testString.is8Bit());
+    EXPECT_FALSE(testString.is8Bit());
     testString.replaceWithLiteral(UChar(0x00E9), "e");
-    ASSERT_STREQ("resume", testString.utf8().data());
+    EXPECT_STREQ("resume", testString.utf8().data());
 
     testString = String::fromUTF8("r\xC3\xA9sum\xC3\xA9");
-    ASSERT_FALSE(testString.is8Bit());
+    EXPECT_FALSE(testString.is8Bit());
     testString.replaceWithLiteral(UChar(0x00E9), "");
-    ASSERT_STREQ("rsum", testString.utf8().data());
+    EXPECT_STREQ("rsum", testString.utf8().data());
 
     testString = String::fromUTF8("r\xC3\xA9sum\xC3\xA9");
-    ASSERT_FALSE(testString.is8Bit());
+    EXPECT_FALSE(testString.is8Bit());
     testString.replaceWithLiteral('3', "NotFound");
-    ASSERT_STREQ("r\xC3\xA9sum\xC3\xA9", testString.utf8().data());
+    EXPECT_STREQ("r\xC3\xA9sum\xC3\xA9", testString.utf8().data());
 }
 
-TEST(WTF, StringComparisonOfSameStringVectors)
+TEST(StringTest, ComparisonOfSameStringVectors)
 {
     Vector<String> stringVector;
     stringVector.append("one");
     stringVector.append("two");
 
     Vector<String> sameStringVector;
     sameStringVector.append("one");
     sameStringVector.append("two");
 
-    ASSERT_EQ(stringVector, sameStringVector);
+    EXPECT_EQ(stringVector, sameStringVector);
 }
 
 TEST(WTF, SimplifyWhiteSpace)
 {
     String extraSpaces("  Hello  world  ");
-    ASSERT_EQ(String("Hello world"), extraSpaces.simplifyWhiteSpace());
-    ASSERT_EQ(String("  Hello  world  "), extraSpaces.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
+    EXPECT_EQ(String("Hello world"), extraSpaces.simplifyWhiteSpace());
+    EXPECT_EQ(String("  Hello  world  "), extraSpaces.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
 
     String extraSpacesAndNewlines(" \nHello\n world\n ");
-    ASSERT_EQ(String("Hello world"), extraSpacesAndNewlines.simplifyWhiteSpace());
-    ASSERT_EQ(String("  Hello  world  "), extraSpacesAndNewlines.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
+    EXPECT_EQ(String("Hello world"), extraSpacesAndNewlines.simplifyWhiteSpace());
+    EXPECT_EQ(String("  Hello  world  "), extraSpacesAndNewlines.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
 
     String extraSpacesAndTabs(" \nHello\t world\t ");
-    ASSERT_EQ(String("Hello world"), extraSpacesAndTabs.simplifyWhiteSpace());
-    ASSERT_EQ(String("  Hello  world  "), extraSpacesAndTabs.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
+    EXPECT_EQ(String("Hello world"), extraSpacesAndTabs.simplifyWhiteSpace());
+    EXPECT_EQ(String("  Hello  world  "), extraSpacesAndTabs.simplifyWhiteSpace(WTF::DoNotStripWhiteSpace));
 }
 
 struct CaseFoldingTestData {
     const char* sourceDescription;
     const char* source;
     const char** localeList;
     size_t localeListLength;
     const char* expected;
 };
 
@@ skipping 16 matching lines @@
 const char* nonGreekLocales[] = {
     "en", "en-US", "en_US", "en@foo=bar", "EN", "En",
     "ja", "tr", "az", "fil", "fi", "lt", };
 const char* lithuanianLocales[] = {
     "lt", "lt-LT", "lt_LT", "lt@foo=bar", "lt-US", "LT", "lt-lt", "lT",
 };
 // Should not have "tr" or "az" because "lt" and 'tr/az' rules conflict with each other.
 const char* nonLithuanianLocales[] = {
     "en", "en-US", "en_US", "en@foo=bar", "EN", "En", "ja", "fil", "fi", "el", };
 
-TEST(WTF, StringToUpperLocale)
+TEST(StringTest, ToUpperLocale)
 {
     CaseFoldingTestData testDataList[] = {
         {
             "Turkic input",
             turkicInput,
             turkicLocales,
             sizeof(turkicLocales) / sizeof(const char*),
             "IS\xC4\xB0\xC4\xB0 \xC4\xB0SII",
         }, {
             "Turkic input",
@@ skipping 31 matching lines @@
     for (size_t i = 0; i < sizeof(testDataList) / sizeof(testDataList[0]); ++i) {
         const char* expected = testDataList[i].expected;
         String source = String::fromUTF8(testDataList[i].source);
         for (size_t j = 0; j < testDataList[i].localeListLength; ++j) {
             const char* locale = testDataList[i].localeList[j];
             EXPECT_STREQ(expected, source.upper(locale).utf8().data()) << testDataList[i].sourceDescription << "; locale=" << locale;
         }
     }
 }
 
-TEST(WTF, StringToLowerLocale)
+TEST(StringTest, ToLowerLocale)
 {
     CaseFoldingTestData testDataList[] = {
         {
             "Turkic input",
             turkicInput,
             turkicLocales,
             sizeof(turkicLocales) / sizeof(const char*),
             "\xC4\xB1sii is\xC4\xB1\xC4\xB1",
         }, {
             "Turkic input",
@@ skipping 51 matching lines @@
     String nonASCII = String::fromUTF8("LIN\xE2\x84\xAA");
     EXPECT_FALSE(startsWithIgnoringASCIICase(allASCII, nonASCII));
     EXPECT_TRUE(startsWithIgnoringASCIICase(allASCII, nonASCII.lower()));
 
     EXPECT_FALSE(startsWithIgnoringASCIICase(nonASCII, allASCII));
     EXPECT_FALSE(startsWithIgnoringASCIICase(nonASCII, allASCIILowerCase));
     EXPECT_FALSE(startsWithIgnoringASCIICase(nonASCII, allASCIIMixedCase));
     EXPECT_FALSE(startsWithIgnoringASCIICase(nonASCII, allASCIIDifferent));
 }
 
-} // namespace
+} // namespace WTF