Fix unit test style in core/{dom,editing,html}/.

Source/core/html/track/vtt/VTTScannerTest.cpp

 /*
  * Copyright (c) 2013, Opera Software ASA. 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
@@ skipping 13 matching lines @@
  * 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 "core/html/track/vtt/VTTScanner.h"
 
 #include "wtf/text/WTFString.h"
-
 #include <gtest/gtest.h>
 
-using blink::VTTScanner;
+namespace blink {
 
-namespace {
-
-TEST(VTTScanner, Constructor)
+TEST(VTTScannerTest, Constructor)
 {
     String data8("foo");
     EXPECT_TRUE(data8.is8Bit());
     VTTScanner scanner8(data8);
     EXPECT_FALSE(scanner8.isAtEnd());
 
     String data16(data8);
     data16.ensure16Bit();
     EXPECT_FALSE(data16.is8Bit());
     VTTScanner scanner16(data16);
@@ skipping 30 matching lines @@
     TESTFUNC(data8);                        \
     \
     String data16(data8);                   \
     data16.ensure16Bit();                   \
     EXPECT_FALSE(data16.is8Bit());          \
     TESTFUNC(data16);                       \
 } while (false)
 
 
 // Exercises match(c) and scan(c).
-TEST(VTTScanner, BasicOperations1)
+TEST(VTTScannerTest, BasicOperations1)
 {
     TEST_WITH(scanSequenceHelper1, "foe");
 }
 
 void scanSequenceHelper2(const String& input)
 {
     VTTScanner scanner(input);
     EXPECT_FALSE(scanner.isAtEnd());
     EXPECT_FALSE(scanner.scan("fe"));
 
     EXPECT_TRUE(scanner.scan("fo"));
     EXPECT_FALSE(scanner.isAtEnd());
 
     EXPECT_FALSE(scanner.scan("ee"));
 
     EXPECT_TRUE(scanner.scan('e'));
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Exercises scan(<literal>[, length]).
-TEST(VTTScanner, BasicOperations2)
+TEST(VTTScannerTest, BasicOperations2)
 {
     TEST_WITH(scanSequenceHelper2, "foe");
 }
 
 bool lowerCaseAlpha(UChar c)
 {
     return c >= 'a' && c <= 'z';
 }
 
 void scanWithPredicate(const String& input)
@@ skipping 16 matching lines @@
     lcRun = scanner.collectWhile<lowerCaseAlpha>();
     // collectWhile doesn't move the scan position.
     EXPECT_FALSE(scanner.isAtEnd());
     // Consume "bing".
     scanner.skipWhile<lowerCaseAlpha>();
     EXPECT_TRUE(scanner.isAt(lcRun.end()));
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests skipWhile() and collectWhile().
-TEST(VTTScanner, PredicateScanning)
+TEST(VTTScannerTest, PredicateScanning)
 {
     TEST_WITH(scanWithPredicate, "badAbing");
 }
 
 void scanWithInvPredicate(const String& input)
 {
     VTTScanner scanner(input);
     EXPECT_FALSE(scanner.isAtEnd());
     // Collect "BAD".
     VTTScanner::Run ucRun = scanner.collectUntil<lowerCaseAlpha>();
@@ skipping 11 matching lines @@
     ucRun = scanner.collectUntil<lowerCaseAlpha>();
     // collectUntil doesn't move the scan position.
     EXPECT_FALSE(scanner.isAtEnd());
     // Consume "BING".
     scanner.skipUntil<lowerCaseAlpha>();
     EXPECT_TRUE(scanner.isAt(ucRun.end()));
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests skipUntil() and collectUntil().
-TEST(VTTScanner, InversePredicateScanning)
+TEST(VTTScannerTest, InversePredicateScanning)
 {
     TEST_WITH(scanWithInvPredicate, "BADaBING");
 }
 
 void scanRuns(const String& input)
 {
     String fooString("foo");
     String barString("bar");
     VTTScanner scanner(input);
     EXPECT_FALSE(scanner.isAtEnd());
@@ skipping 10 matching lines @@
     EXPECT_TRUE(scanner.match(':'));
     EXPECT_TRUE(scanner.scan(':'));
 
     word = scanner.collectWhile<lowerCaseAlpha>();
     EXPECT_FALSE(scanner.scanRun(word, fooString));
     EXPECT_TRUE(scanner.scanRun(word, barString));
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests scanRun/skipRun.
-TEST(VTTScanner, RunScanning)
+TEST(VTTScannerTest, RunScanning)
 {
     TEST_WITH(scanRuns, "foo:baz:bar");
 }
 
 void scanRunsToStrings(const String& input)
 {
     VTTScanner scanner(input);
     EXPECT_FALSE(scanner.isAtEnd());
     VTTScanner::Run word = scanner.collectWhile<lowerCaseAlpha>();
     String fooString = scanner.extractString(word);
     EXPECT_EQ(fooString, "foo");
     EXPECT_TRUE(scanner.isAt(word.end()));
 
     EXPECT_TRUE(scanner.match(':'));
     EXPECT_TRUE(scanner.scan(':'));
 
     word = scanner.collectWhile<lowerCaseAlpha>();
     String barString = scanner.extractString(word);
     EXPECT_EQ(barString, "bar");
     EXPECT_TRUE(scanner.isAt(word.end()));
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests extractString.
-TEST(VTTScanner, ExtractString)
+TEST(VTTScannerTest, ExtractString)
 {
     TEST_WITH(scanRunsToStrings, "foo:bar");
 }
 
 void tailStringExtract(const String& input)
 {
     VTTScanner scanner(input);
     EXPECT_TRUE(scanner.scan("foo"));
     EXPECT_TRUE(scanner.scan(':'));
     String barSuffix = scanner.restOfInputAsString();
     EXPECT_EQ(barSuffix, "bar");
 
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests restOfInputAsString().
-TEST(VTTScanner, ExtractRestAsString)
+TEST(VTTScannerTest, ExtractRestAsString)
 {
     TEST_WITH(tailStringExtract, "foo:bar");
 }
 
 void scanDigits1(const String& input)
 {
     VTTScanner scanner(input);
     EXPECT_TRUE(scanner.scan("foo"));
     int number;
     EXPECT_EQ(scanner.scanDigits(number), 0u);
@@ skipping 25 matching lines @@
 
     EXPECT_TRUE(scanner.scan(' '));
 
     EXPECT_EQ(scanner.scanDigits(number), 19u);
     EXPECT_EQ(number, std::numeric_limits<int>::max());
 
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests scanDigits().
-TEST(VTTScanner, ScanDigits)
+TEST(VTTScannerTest, ScanDigits)
 {
     TEST_WITH(scanDigits1, "foo 123 bar 45678");
     TEST_WITH(scanDigits2, "-654 1000000000000000000");
 }
 
 void scanFloatValue(const String& input)
 {
     VTTScanner scanner(input);
     float value;
     // "1."
@@ skipping 23 matching lines @@
     EXPECT_TRUE(scanner.scan(' '));
 
     // "01.000"
     EXPECT_TRUE(scanner.scanFloat(value));
     EXPECT_EQ(value, 1.0f);
 
     EXPECT_TRUE(scanner.isAtEnd());
 }
 
 // Tests scanFloat().
-TEST(VTTScanner, ScanFloat)
+TEST(VTTScannerTest, ScanFloat)
 {
     TEST_WITH(scanFloatValue, "1. 1.0 .0 . 1.0000 01.000");
 }
 
 #undef TEST_WITH
 
-} // namespace
+} // namespace blink