Fix unit test style in Source/wtf/.

Source/wtf/FunctionalTest.cpp

 /*
  * Copyright (C) 2011 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/Functional.h"
 
-#include "wtf/Functional.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefCounted.h"
 #include <gtest/gtest.h>
 
-namespace {
+namespace WTF {
 
 class UnwrappedClass {
 public:
     explicit UnwrappedClass(int value)
         : m_value(value)
     {
     }
 
     int value() const { return m_value; }
 
@@ skipping 22 matching lines @@
         : m_value(value)
     {
     }
 
     WrappedClass wrap() const { return WrappedClass(m_value); }
 
 private:
     int m_value;
 };
 
-} // namespace
-
-namespace WTF {
-
 template<> struct ParamStorageTraits<ClassToBeWrapped> {
     using StorageType = WrappedClass;
     static StorageType wrap(const ClassToBeWrapped& value) { return value.wrap(); }
     static UnwrappedClass unwrap(const StorageType& value) { return value.unwrap(); }
 };
 
-} // namespace WTF
-
 namespace {
 
-static int returnFortyTwo()
+int returnFortyTwo()
 {
     return 42;
 }
 
 TEST(FunctionalTest, Basic)
 {
     OwnPtr<Function<int()>> returnFortyTwoFunction = bind(returnFortyTwo);
     EXPECT_EQ(42, (*returnFortyTwoFunction)());
 }
 
-static int multiplyByTwo(int n)
+int multiplyByTwo(int n)
 {
     return n * 2;
 }
 
-static double multiplyByOneAndAHalf(double d)
+double multiplyByOneAndAHalf(double d)
 {
     return d * 1.5;
 }
 
 TEST(FunctionalTest, UnaryBind)
 {
     OwnPtr<Function<int()>> multiplyFourByTwoFunction = bind(multiplyByTwo, 4);
     EXPECT_EQ(8, (*multiplyFourByTwoFunction)());
 
     OwnPtr<Function<double()>> multiplyByOneAndAHalfFunction = bind(multiplyByOneAndAHalf, 3);
     EXPECT_EQ(4.5, (*multiplyByOneAndAHalfFunction)());
 }
 
 TEST(FunctionalTest, UnaryPartBind)
 {
     OwnPtr<Function<int(int)>> multiplyByTwoFunction = bind<int>(multiplyByTwo);
     EXPECT_EQ(8, (*multiplyByTwoFunction)(4));
 
     OwnPtr<Function<double(double)>> multiplyByOneAndAHalfFunction = bind<double>(multiplyByOneAndAHalf);
     EXPECT_EQ(4.5, (*multiplyByOneAndAHalfFunction)(3));
 }
 
-static int multiply(int x, int y)
+int multiply(int x, int y)
 {
     return x * y;
 }
 
-static int subtract(int x, int y)
+int subtract(int x, int y)
 {
     return x - y;
 }
 
 TEST(FunctionalTest, BinaryBind)
 {
     OwnPtr<Function<int()>> multiplyFourByTwoFunction = bind(multiply, 4, 2);
     EXPECT_EQ(8, (*multiplyFourByTwoFunction)());
 
     OwnPtr<Function<int()>> subtractTwoFromFourFunction = bind(subtract, 4, 2);
     EXPECT_EQ(2, (*subtractTwoFromFourFunction)());
 }
 
 TEST(FunctionalTest, BinaryPartBind)
 {
     OwnPtr<Function<int(int)>> multiplyFourFunction = bind<int>(multiply, 4);
     EXPECT_EQ(8, (*multiplyFourFunction)(2));
     OwnPtr<Function<int(int, int)>> multiplyFunction = bind<int, int>(multiply);
     EXPECT_EQ(8, (*multiplyFunction)(4, 2));
 
     OwnPtr<Function<int(int)>> subtractFromFourFunction = bind<int>(subtract, 4);
     EXPECT_EQ(2, (*subtractFromFourFunction)(2));
     OwnPtr<Function<int(int, int)>> subtractFunction = bind<int, int>(subtract);
     EXPECT_EQ(2, (*subtractFunction)(4, 2));
 }
 
-static void sixArgFunc(int a, double b, char c, int* d, double* e, char* f)
+void sixArgFunc(int a, double b, char c, int* d, double* e, char* f)
 {
     *d = a;
     *e = b;
     *f = c;
 }
 
-static void assertArgs(int actualInt, double actualDouble, char actualChar, int expectedInt, double expectedDouble, char expectedChar)
+void assertArgs(int actualInt, double actualDouble, char actualChar, int expectedInt, double expectedDouble, char expectedChar)
 {
     EXPECT_EQ(expectedInt, actualInt);
     EXPECT_EQ(expectedDouble, actualDouble);
     EXPECT_EQ(expectedChar, actualChar);
 }
 
 TEST(FunctionalTest, MultiPartBind)
 {
     int a = 0;
     double b = 0.5;
@@ skipping 89 matching lines @@
 
 private:
     explicit Number(int value)
         : m_value(value)
     {
     }
 
     int m_value;
 };
 
-static int multiplyNumberByTwo(Number* number)
+int multiplyNumberByTwo(Number* number)
 {
     return number->value() * 2;
 }
 
 TEST(FunctionalTest, RefCountedStorage)
 {
     RefPtr<Number> five = Number::create(5);
     OwnPtr<Function<int()>> multiplyFiveByTwoFunction = bind(multiplyNumberByTwo, five);
     EXPECT_EQ(10, (*multiplyFiveByTwoFunction)());
 
@@ skipping 22 matching lines @@
     OwnPtr<Function<int()>> function = bind(processUnwrappedClass, ClassToBeWrapped(3), 7);
     EXPECT_EQ(21, (*function)());
 }
 
 TEST(FunctionalTest, WrapUnwrapInPartialBind)
 {
     OwnPtr<Function<int(int)>> partiallyBoundFunction = bind<int>(processUnwrappedClass, ClassToBeWrapped(3));
     EXPECT_EQ(21, (*partiallyBoundFunction)(7));
 }
 
-} // namespace
+} // anonymous namespace
+
+} // namespace WTF