Fix unit test style in Source/platform/, part 2.

Source/platform/text/UnicodeUtilitiesTest.cpp

 /*
  * Copyright (c) 2013 Yandex LLC. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #include "config.h"
 #include "platform/text/UnicodeUtilities.h"
 
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/unicode/CharacterNames.h"
 #include <gtest/gtest.h>
 #include <unicode/uchar.h>
 
-using namespace blink;
-
-namespace {
+namespace blink {
 
 static const UChar32 kMaxLatinCharCount = 256;
 
 static bool isTestFirstAndLastCharsInCategoryFailed = false;
 UBool U_CALLCONV testFirstAndLastCharsInCategory(const void *context, UChar32 start, UChar32 limit, UCharCategory type)
 {
     if (start >= kMaxLatinCharCount
         && U_MASK(type) & (U_GC_S_MASK | U_GC_P_MASK | U_GC_Z_MASK | U_GC_CF_MASK)
         && (!isSeparator(start) || !isSeparator(limit - 1))) {
         isTestFirstAndLastCharsInCategoryFailed = true;
 
         // Break enumeration process
         return 0;
     }
 
     return 1;
 }
 
-TEST(WebCoreUnicodeUnit, Separators)
+TEST(UnicodeUtilitiesTest, Separators)
 {
     static const bool latinSeparatorTable[kMaxLatinCharCount] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // space ! " # $ % & ' ( ) * + , - . /
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, //                         : ; < = > ?
         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //   @
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, //                         [ \ ] ^ _
         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //   `
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, //                           { | } ~
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
         1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0
     };
 
     for (UChar32 character = 0; character < kMaxLatinCharCount; ++character) {
         EXPECT_EQ(isSeparator(character), latinSeparatorTable[character]);
     }
 
     isTestFirstAndLastCharsInCategoryFailed = false;
     u_enumCharTypes(&testFirstAndLastCharsInCategory, 0);
     EXPECT_FALSE(isTestFirstAndLastCharsInCategoryFailed);
 }
 
-TEST(WebCoreUnicodeUnit, KanaLetters)
+TEST(UnicodeUtilitiesTest, KanaLetters)
 {
     // Non Kana symbols
     for (UChar character = 0; character < 0x3041; ++character)
         EXPECT_FALSE(isKanaLetter(character));
 
     // Hiragana letters.
     for (UChar character = 0x3041; character <= 0x3096; ++character)
         EXPECT_TRUE(isKanaLetter(character));
 
     // Katakana letters.
     for (UChar character = 0x30A1; character <= 0x30FA; ++character)
         EXPECT_TRUE(isKanaLetter(character));
 }
 
-TEST(WebCoreUnicodeUnit, ContainsKanaLetters)
+TEST(UnicodeUtilitiesTest, ContainsKanaLetters)
 {
     // Non Kana symbols
     String nonKanaString;
     for (UChar character = 0; character < 0x3041; ++character)
         nonKanaString.append(character);
     EXPECT_FALSE(containsKanaLetters(nonKanaString));
 
     // Hiragana letters.
     for (UChar character = 0x3041; character <= 0x3096; ++character) {
         String str(nonKanaString);
         str.append(character);
         EXPECT_TRUE(containsKanaLetters(str));
     }
 
     // Katakana letters.
     for (UChar character = 0x30A1; character <= 0x30FA; ++character) {
         String str(nonKanaString);
         str.append(character);
         EXPECT_TRUE(containsKanaLetters(str));
     }
 }
 
-TEST(WebCoreUnicodeUnit, FoldQuoteMarkOrSoftHyphenTest)
+TEST(UnicodeUtilitiesTest, FoldQuoteMarkOrSoftHyphenTest)
 {
     const UChar charactersToFold[] = {
         hebrewPunctuationGershayimCharacter, leftDoubleQuotationMarkCharacter, rightDoubleQuotationMarkCharacter,
         hebrewPunctuationGereshCharacter, leftSingleQuotationMarkCharacter, rightSingleQuotationMarkCharacter,
         softHyphenCharacter
     };
 
     String stringToFold(charactersToFold, WTF_ARRAY_LENGTH(charactersToFold));
     Vector<UChar> buffer;
     stringToFold.appendTo(buffer);
 
     foldQuoteMarksAndSoftHyphens(stringToFold);
 
     const String foldedString("\"\"\"\'\'\'\0", WTF_ARRAY_LENGTH(charactersToFold));
     EXPECT_EQ(stringToFold, foldedString);
 
     foldQuoteMarksAndSoftHyphens(buffer.data(), buffer.size());
     EXPECT_EQ(String(buffer), foldedString);
 }
 
-TEST(WebCoreUnicodeUnit, OnlyKanaLettersEqualityTest)
+TEST(UnicodeUtilitiesTest, OnlyKanaLettersEqualityTest)
 {
     const UChar nonKanaString1[] = { 'a', 'b', 'c', 'd' };
     const UChar nonKanaString2[] = { 'e', 'f', 'g' };
 
     // Check that non-Kana letters will be skipped.
     EXPECT_TRUE(checkOnlyKanaLettersInStrings(
         nonKanaString1, WTF_ARRAY_LENGTH(nonKanaString1),
         nonKanaString2, WTF_ARRAY_LENGTH(nonKanaString2)));
 
     const UChar kanaString[] = { 'e', 'f', 'g', 0x3041 };
@@ skipping 19 matching lines @@
     EXPECT_TRUE(checkOnlyKanaLettersInStrings(
         voicedKanaString1, WTF_ARRAY_LENGTH(voicedKanaString1),
         voicedKanaString2, WTF_ARRAY_LENGTH(voicedKanaString2)));
 
     voicedKanaString2[0] = 0x3043;
     EXPECT_FALSE(checkOnlyKanaLettersInStrings(
         voicedKanaString1, WTF_ARRAY_LENGTH(voicedKanaString1),
         voicedKanaString2, WTF_ARRAY_LENGTH(voicedKanaString2)));
 }
 
-TEST(WebCoreUnicodeUnit, StringsWithKanaLettersTest)
+TEST(UnicodeUtilitiesTest, StringsWithKanaLettersTest)
 {
     const UChar nonKanaString1[] = { 'a', 'b', 'c' };
     const UChar nonKanaString2[] = { 'a', 'b', 'c' };
 
     // Check that non-Kana letters will be compared.
     EXPECT_TRUE(checkKanaStringsEqual(
         nonKanaString1, WTF_ARRAY_LENGTH(nonKanaString1),
         nonKanaString2, WTF_ARRAY_LENGTH(nonKanaString2)));
 
     const UChar kanaString[] = { 'a', 'b', 'c', 0x3041 };
@@ skipping 37 matching lines @@
     EXPECT_TRUE(checkKanaStringsEqual(
         voicedKanaString1, WTF_ARRAY_LENGTH(voicedKanaString1),
         voicedKanaString2, WTF_ARRAY_LENGTH(voicedKanaString2)));
 
     voicedKanaString2[0] = 0x3043;
     EXPECT_FALSE(checkKanaStringsEqual(
         voicedKanaString1, WTF_ARRAY_LENGTH(voicedKanaString1),
         voicedKanaString2, WTF_ARRAY_LENGTH(voicedKanaString2)));
 }
 
-} // namespace
+} // namespace blink