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

Source/core/html/HTMLDimensionTest.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * 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 18 matching lines @@
  */
 
 #include "config.h"
 #include "core/html/HTMLDimension.h"
 
 #include "wtf/text/WTFString.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 
-// This assertion-prettify function needs to be in the WebCore namespace.
+// This assertion-prettify function needs to be in the blink namespace.
 void PrintTo(const HTMLDimension& dimension, ::std::ostream* os)
 {
     *os << "HTMLDimension => type: " << dimension.type() << ", value=" << dimension.value();
 }
 
-}
-
-using namespace blink;
-
-namespace {
-
-TEST(WebCoreHTMLDimension, parseListOfDimensionsEmptyString)
+TEST(HTMLDimensionTest, parseListOfDimensionsEmptyString)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String(""));
     ASSERT_EQ(Vector<HTMLDimension>(), result);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberAbsolute)
+TEST(HTMLDimensionTest, parseListOfDimensionsNoNumberAbsolute)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String(" \t"));
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(0, HTMLDimension::Relative), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberPercent)
+TEST(HTMLDimensionTest, parseListOfDimensionsNoNumberPercent)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String(" \t%"));
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(0, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsNoNumberRelative)
+TEST(HTMLDimensionTest, parseListOfDimensionsNoNumberRelative)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("\t *"));
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(0, HTMLDimension::Relative), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSingleAbsolute)
+TEST(HTMLDimensionTest, parseListOfDimensionsSingleAbsolute)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSinglePercentageWithSpaces)
+TEST(HTMLDimensionTest, parseListOfDimensionsSinglePercentageWithSpaces)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("50  %"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(50, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSingleRelative)
+TEST(HTMLDimensionTest, parseListOfDimensionsSingleRelative)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("25*"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(25, HTMLDimension::Relative), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsDoubleAbsolute)
+TEST(HTMLDimensionTest, parseListOfDimensionsDoubleAbsolute)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10.054"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10.054, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpaceAbsolute)
+TEST(HTMLDimensionTest, parseListOfDimensionsLeadingSpaceAbsolute)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("\t \t 10"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpaceRelative)
+TEST(HTMLDimensionTest, parseListOfDimensionsLeadingSpaceRelative)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String(" \r25*"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(25, HTMLDimension::Relative), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsLeadingSpacePercentage)
+TEST(HTMLDimensionTest, parseListOfDimensionsLeadingSpacePercentage)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("\n 25%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(25, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsDoublePercentage)
+TEST(HTMLDimensionTest, parseListOfDimensionsDoublePercentage)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10.054%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10.054, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsDoubleRelative)
+TEST(HTMLDimensionTest, parseListOfDimensionsDoubleRelative)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10.054*"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10.054, HTMLDimension::Relative), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoubleAbsolute)
+TEST(HTMLDimensionTest, parseListOfDimensionsSpacesInIntegerDoubleAbsolute)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("1\n0 .025%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(1, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoublePercent)
+TEST(HTMLDimensionTest, parseListOfDimensionsSpacesInIntegerDoublePercent)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("1\n0 .025%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(1, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInIntegerDoubleRelative)
+TEST(HTMLDimensionTest, parseListOfDimensionsSpacesInIntegerDoubleRelative)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("1\n0 .025*"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(1, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInFractionAfterDotDoublePercent)
+TEST(HTMLDimensionTest, parseListOfDimensionsSpacesInFractionAfterDotDoublePercent)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10.  0 25%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10.025, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsSpacesInFractionAfterDigitDoublePercent)
+TEST(HTMLDimensionTest, parseListOfDimensionsSpacesInFractionAfterDigitDoublePercent)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10.05\r25%"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10.0525, HTMLDimension::Percentage), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsTrailingComma)
+TEST(HTMLDimensionTest, parseListOfDimensionsTrailingComma)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10,"));
 
     ASSERT_EQ(1U, result.size());
     ASSERT_EQ(HTMLDimension(10, HTMLDimension::Absolute), result[0]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsTwoDimensions)
+TEST(HTMLDimensionTest, parseListOfDimensionsTwoDimensions)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10*,25 %"));
 
     ASSERT_EQ(2U, result.size());
     ASSERT_EQ(HTMLDimension(10, HTMLDimension::Relative), result[0]);
     ASSERT_EQ(HTMLDimension(25, HTMLDimension::Percentage), result[1]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsMultipleDimensionsWithSpaces)
+TEST(HTMLDimensionTest, parseListOfDimensionsMultipleDimensionsWithSpaces)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("10   *   ,\t25 , 10.05\n5%"));
 
     ASSERT_EQ(3U, result.size());
     ASSERT_EQ(HTMLDimension(10, HTMLDimension::Relative), result[0]);
     ASSERT_EQ(HTMLDimension(25, HTMLDimension::Absolute), result[1]);
     ASSERT_EQ(HTMLDimension(10.055, HTMLDimension::Percentage), result[2]);
 }
 
-TEST(WebCoreHTMLDimension, parseListOfDimensionsMultipleDimensionsWithOneEmpty)
+TEST(HTMLDimensionTest, parseListOfDimensionsMultipleDimensionsWithOneEmpty)
 {
     Vector<HTMLDimension> result = parseListOfDimensions(String("2*,,8.%"));
 
     ASSERT_EQ(3U, result.size());
     ASSERT_EQ(HTMLDimension(2, HTMLDimension::Relative), result[0]);
     ASSERT_EQ(HTMLDimension(0, HTMLDimension::Relative), result[1]);
     ASSERT_EQ(HTMLDimension(8., HTMLDimension::Percentage), result[2]);
 }
 
-}
+} // namespace blink