Remove requirement that mojo::Environment be instantiated.

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 <utility>
 #include <vector>
 
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/lib/connector.h"
 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
 #include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/tests/validation_test_input_parser.h"
-#include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/cpp/test_support/test_support.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 
 using internal::MessageValidator;
@@ skipping 155 matching lines @@
   }
 }
 
 class DummyMessageReceiver : public MessageReceiver {
  public:
   bool Accept(Message* message) override {
     return true;  // Any message is OK.
   }
 };
 
-class ValidationTest : public testing::Test {
- public:
-  ~ValidationTest() override {}
-
- private:
-  Environment env_;
-};
-
-class ValidationIntegrationTest : public ValidationTest {
+class ValidationIntegrationTest : public testing::Test {
  public:
   ValidationIntegrationTest() : test_message_receiver_(nullptr) {}
 
   ~ValidationIntegrationTest() override {}
 
   void SetUp() override {
     ScopedMessagePipeHandle tester_endpoint;
     ASSERT_EQ(MOJO_RESULT_OK,
               CreateMessagePipe(nullptr, &tester_endpoint, &testee_endpoint_));
     test_message_receiver_ =
@@ skipping 55 matching lines @@
  public:
   explicit FailingValidator(ValidationError err) : err_(err) {}
   ValidationError Validate(const Message* message, std::string* err) override {
     return err_;
   }
 
  private:
   ValidationError err_;
 };
 
-TEST_F(ValidationTest, InputParser) {
+TEST(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 83 matching lines @@
                                   nullptr};
 
     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_F(ValidationTest, Conformance) {
+TEST(ValidationTest, Conformance) {
   DummyMessageReceiver dummy_receiver;
   MessageValidatorList validators;
   validators.push_back(std::unique_ptr<MessageValidator>(
       new mojo::internal::MessageHeaderValidator));
   validators.push_back(std::unique_ptr<MessageValidator>(
       new ConformanceTestInterface::RequestValidator_));
 
   RunValidationTests("conformance_", validators, &dummy_receiver);
 }
 
 // This test is similar to Conformance test but its goal is specifically
 // do bounds-check testing of message validation. For example we test the
 // detection of off-by-one errors in method ordinals.
-TEST_F(ValidationTest, BoundsCheck) {
+TEST(ValidationTest, BoundsCheck) {
   DummyMessageReceiver dummy_receiver;
   MessageValidatorList validators;
   validators.push_back(std::unique_ptr<MessageValidator>(
       new mojo::internal::MessageHeaderValidator));
   validators.push_back(std::unique_ptr<MessageValidator>(
       new BoundsCheckTestInterface::RequestValidator_));
 
   RunValidationTests("boundscheck_", validators, &dummy_receiver);
 }
 
 // This test is similar to the Conformance test but for responses.
-TEST_F(ValidationTest, ResponseConformance) {
+TEST(ValidationTest, ResponseConformance) {
   DummyMessageReceiver dummy_receiver;
   MessageValidatorList validators;
   validators.push_back(std::unique_ptr<MessageValidator>(
       new mojo::internal::MessageHeaderValidator));
   validators.push_back(std::unique_ptr<MessageValidator>(
       new ConformanceTestInterface::ResponseValidator_));
 
   RunValidationTests("resp_conformance_", validators, &dummy_receiver);
 }
 
 // This test is similar to the BoundsCheck test but for responses.
-TEST_F(ValidationTest, ResponseBoundsCheck) {
+TEST(ValidationTest, ResponseBoundsCheck) {
   DummyMessageReceiver dummy_receiver;
   MessageValidatorList validators;
   validators.push_back(std::unique_ptr<MessageValidator>(
       new mojo::internal::MessageHeaderValidator));
   validators.push_back(std::unique_ptr<MessageValidator>(
       new BoundsCheckTestInterface::ResponseValidator_));
 
   RunValidationTests("resp_boundscheck_", validators, &dummy_receiver);
 }
 
@@ skipping 34 matching lines @@
       new mojo::internal::MessageHeaderValidator));
   validators.push_back(std::unique_ptr<MessageValidator>(
       new typename IntegrationTestInterface::RequestValidator_));
 
   RunValidationTests("integration_intf_rqst", validators,
                      test_message_receiver());
   RunValidationTests("integration_msghdr", validators, test_message_receiver());
 }
 
 // Test pointer validation (specifically, that the encoded offset is 32-bit)
-TEST_F(ValidationTest, ValidateEncodedPointer) {
+TEST(ValidationTest, ValidateEncodedPointer) {
   uint64_t offset;
 
   offset = 0ULL;
   EXPECT_TRUE(mojo::internal::ValidateEncodedPointer(&offset));
 
   offset = 1ULL;
   EXPECT_TRUE(mojo::internal::ValidateEncodedPointer(&offset));
 
   // offset must be <= 32-bit.
   offset = std::numeric_limits<uint32_t>::max() + 1ULL;
   EXPECT_FALSE(mojo::internal::ValidateEncodedPointer(&offset));
 }
 
-TEST_F(ValidationTest, RunValidatorsOnMessageTest) {
+TEST(ValidationTest, RunValidatorsOnMessageTest) {
   Message msg;
   mojo::internal::MessageValidatorList validators;
 
   validators.push_back(std::unique_ptr<MessageValidator>(
       new mojo::internal::PassThroughValidator));
   EXPECT_EQ(ValidationError::NONE,
             RunValidatorsOnMessage(validators, &msg, nullptr));
 
   validators.push_back(std::unique_ptr<MessageValidator>(
       new FailingValidator(ValidationError::MESSAGE_HEADER_INVALID_FLAGS)));
@@ skipping 36 matching lines @@
       static_cast<StructWithEnum::EnumWithin>(2)));
   EXPECT_TRUE(StructWithEnum::EnumWithin_IsValidValue(
       static_cast<StructWithEnum::EnumWithin>(3)));
   EXPECT_FALSE(StructWithEnum::EnumWithin_IsValidValue(
       static_cast<StructWithEnum::EnumWithin>(4)));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo