Replace fprintf with mojo logging macro.

mojo/public/cpp/bindings/tests/validation_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 167 matching lines @@
   }
 }
 
 class DummyMessageReceiver : public MessageReceiver {
  public:
   virtual bool Accept(Message* message) MOJO_OVERRIDE {
     return true;  // Any message is OK.
   }
 };
 
-class ValidationIntegrationTest : public testing::Test {
+class ValidationTest : public testing::Test {
+ public:
+  virtual ~ValidationTest() {
+  }
+
+ private:
+  Environment env_;
+};
+
+class ValidationIntegrationTest : public ValidationTest {
  public:
   ValidationIntegrationTest() : test_message_receiver_(NULL) {
   }
 
   virtual ~ValidationIntegrationTest() {
   }
 
   virtual void SetUp() MOJO_OVERRIDE {
     ScopedMessagePipeHandle tester_endpoint;
     ASSERT_EQ(MOJO_RESULT_OK,
@@ skipping 38 matching lines @@
 
    public:
     ValidationIntegrationTest* owner_;
     mojo::internal::Connector connector_;
   };
 
   void PumpMessages() {
     loop_.RunUntilIdle();
   }
 
-  Environment env_;
   RunLoop loop_;
   TestMessageReceiver* test_message_receiver_;
   ScopedMessagePipeHandle testee_endpoint_;
 };
 
 class IntegrationTestInterface1Client : public IntegrationTestInterface1 {
  public:
   virtual ~IntegrationTestInterface1Client() {
   }
 
   virtual void Method0(BasicStructPtr param0) MOJO_OVERRIDE {
   }
 };
 
 class IntegrationTestInterface1Impl
     : public InterfaceImpl<IntegrationTestInterface1> {
  public:
   virtual ~IntegrationTestInterface1Impl() {
   }
 
   virtual void Method0(BasicStructPtr param0) MOJO_OVERRIDE {
   }
 
   virtual void OnConnectionError() MOJO_OVERRIDE {
     delete this;
   }
 };
 
-TEST(ValidationTest, InputParser) {
+TEST_F(ValidationTest, InputParser) {
   {
     // The parser, as well as Append() defined above, assumes that this code is
     // running on a little-endian platform. Test whether that is true.
     uint16_t x = 1;
     ASSERT_EQ(1, *(reinterpret_cast<char*>(&x)));
   }
   {
     // Test empty input.
     std::string input;
     std::vector<uint8_t> expected;
@@ skipping 84 matching lines @@
     };
 
     for (size_t i = 0; error_inputs[i]; ++i) {
       std::vector<uint8_t> expected;
       if (!TestInputParser(error_inputs[i], false, expected, 0))
         ADD_FAILURE() << "Unexpected test result for: " << error_inputs[i];
     }
   }
 }
 
-TEST(ValidationTest, Conformance) {
+TEST_F(ValidationTest, Conformance) {
   DummyMessageReceiver dummy_receiver;
   mojo::internal::FilterChain validators(&dummy_receiver);
   validators.Append<mojo::internal::MessageHeaderValidator>();
   validators.Append<ConformanceTestInterface::RequestValidator_>();
 
   RunValidationTests("conformance_", validators.GetHead());
 }
 
 TEST_F(ValidationIntegrationTest, InterfacePtr) {
   // Test that InterfacePtr<X> applies the correct validators and they don't
@@ skipping 22 matching lines @@
   IntegrationTestInterface1Impl* interface1_impl =
       BindToPipe(new IntegrationTestInterface1Impl(), testee_endpoint().Pass());
   interface1_impl->internal_state()->router()->EnableTestingMode();
 
   RunValidationTests("integration_", test_message_receiver());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo