Remove requirement that mojo::Environment be instantiated.

mojo/public/cpp/bindings/tests/array_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 "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/tests/container_test_util.h"
 #include "mojo/public/cpp/bindings/tests/iterator_test_util.h"
-#include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/interfaces/bindings/tests/test_arrays.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 using mojo::internal::Array_Data;
 using mojo::internal::ArrayValidateParams;
 using mojo::internal::FixedBufferForTesting;
 using mojo::internal::String_Data;
 
-class ArrayTest : public testing::Test {
- public:
-  ~ArrayTest() override {}
-
- private:
-  Environment env_;
-};
-
 // Tests that basic Array operations work.
-TEST_F(ArrayTest, Basic) {
+TEST(ArrayTest, Basic) {
   auto array = Array<uint8_t>::New(8);
   for (size_t i = 0u; i < array.size(); ++i) {
     uint8_t val = static_cast<uint8_t>(i * 2);
     array[i] = val;
     EXPECT_EQ(val, array.at(i));
   }
 
   EXPECT_EQ(0u, *array.data());
   EXPECT_EQ(2u, *(array.data() + 1));
   EXPECT_EQ(4u, *(array.data() + 2));
 }
 
-TEST_F(ArrayTest, Testability) {
+TEST(ArrayTest, Testability) {
   Array<int32_t> array;
   EXPECT_FALSE(array);
   EXPECT_TRUE(array.is_null());
 
   array.push_back(123);
   EXPECT_TRUE(array);
   EXPECT_FALSE(array.is_null());
 }
 
 void NullptrConstructorTestHelper(Array<int32_t> array) {
   EXPECT_FALSE(array);
   EXPECT_TRUE(array.is_null());
   EXPECT_EQ(0u, array.size());
 }
 
-TEST_F(ArrayTest, NullptrConstructor) {
+TEST(ArrayTest, NullptrConstructor) {
   Array<int32_t> array(nullptr);
   EXPECT_FALSE(array);
   EXPECT_TRUE(array.is_null());
   EXPECT_EQ(0u, array.size());
 
   array.push_back(123);
   EXPECT_TRUE(array);
   EXPECT_FALSE(array.is_null());
   EXPECT_EQ(1u, array.size());
 
   // Test some implicit constructions of |Array<int32_t>| from a |nullptr|.
   array = nullptr;
   NullptrConstructorTestHelper(nullptr);
 }
 
 // Tests that basic Array<bool> operations work.
-TEST_F(ArrayTest, Bool) {
+TEST(ArrayTest, Bool) {
   auto array = Array<bool>::New(64);
   for (size_t i = 0; i < array.size(); ++i) {
     bool val = i % 3 == 0;
     array[i] = val;
     EXPECT_EQ(val, array.at(i));
   }
 }
 
 // Tests that Array<ScopedMessagePipeHandle> supports transferring handles.
-TEST_F(ArrayTest, Handle) {
+TEST(ArrayTest, Handle) {
   MessagePipe pipe;
   auto handles = Array<ScopedMessagePipeHandle>::New(2);
   handles[0] = pipe.handle0.Pass();
   handles[1].reset(pipe.handle1.release());
 
   EXPECT_FALSE(pipe.handle0.is_valid());
   EXPECT_FALSE(pipe.handle1.is_valid());
 
   Array<ScopedMessagePipeHandle> handles2 = handles.Pass();
   EXPECT_TRUE(handles2[0].is_valid());
   EXPECT_TRUE(handles2[1].is_valid());
 
   ScopedMessagePipeHandle pipe_handle = handles2[0].Pass();
   EXPECT_TRUE(pipe_handle.is_valid());
   EXPECT_FALSE(handles2[0].is_valid());
 }
 
 // Tests that Array<ScopedMessagePipeHandle> supports closing handles.
-TEST_F(ArrayTest, HandlesAreClosed) {
+TEST(ArrayTest, HandlesAreClosed) {
   MessagePipe pipe;
   MojoHandle pipe0_value = pipe.handle0.get().value();
   MojoHandle pipe1_value = pipe.handle0.get().value();
 
   {
     auto handles = Array<ScopedMessagePipeHandle>::New(2);
     handles[0] = pipe.handle0.Pass();
     handles[1].reset(pipe.handle0.release());
   }
 
   // We expect the pipes to have been closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe0_value));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe1_value));
 }
 
-TEST_F(ArrayTest, Clone) {
+TEST(ArrayTest, Clone) {
   {
     // Test POD.
     auto array = Array<int32_t>::New(3);
     for (size_t i = 0; i < array.size(); ++i)
       array[i] = static_cast<int32_t>(i);
 
     Array<int32_t> clone_array = array.Clone();
     EXPECT_EQ(array.size(), clone_array.size());
     for (size_t i = 0; i < array.size(); ++i)
       EXPECT_EQ(array[i], clone_array[i]);
@@ skipping 44 matching lines @@
     EXPECT_EQ(array[1][1], clone_array[1][1]);
   }
 
   {
     // Test that array of handles still works although Clone() is not available.
     auto array = Array<ScopedMessagePipeHandle>::New(10);
     EXPECT_FALSE(array[0].is_valid());
   }
 }
 
-TEST_F(ArrayTest, Serialization_ArrayOfPOD) {
+TEST(ArrayTest, Serialization_ArrayOfPOD) {
   auto array = Array<int32_t>::New(4);
   for (size_t i = 0; i < array.size(); ++i)
     array[i] = static_cast<int32_t>(i);
 
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U + 4 * 4U, size);
 
   FixedBufferForTesting buf(size);
   Array_Data<int32_t>* data = nullptr;
   ArrayValidateParams validate_params(0, false, nullptr);
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             SerializeArray_(&array, &buf, &data, &validate_params));
 
   Array<int32_t> array2;
   Deserialize_(data, &array2);
 
   EXPECT_EQ(4U, array2.size());
   for (size_t i = 0; i < array2.size(); ++i)
     EXPECT_EQ(static_cast<int32_t>(i), array2[i]);
 }
 
-TEST_F(ArrayTest, Serialization_EmptyArrayOfPOD) {
+TEST(ArrayTest, Serialization_EmptyArrayOfPOD) {
   auto array = Array<int32_t>::New(0);
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U, size);
 
   FixedBufferForTesting buf(size);
   Array_Data<int32_t>* data = nullptr;
   ArrayValidateParams validate_params(0, false, nullptr);
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             SerializeArray_(&array, &buf, &data, &validate_params));
 
   Array<int32_t> array2;
   Deserialize_(data, &array2);
   EXPECT_EQ(0U, array2.size());
 }
 
-TEST_F(ArrayTest, Serialization_ArrayOfArrayOfPOD) {
+TEST(ArrayTest, Serialization_ArrayOfArrayOfPOD) {
   auto array = Array<Array<int32_t>>::New(2);
   for (size_t j = 0; j < array.size(); ++j) {
     auto inner = Array<int32_t>::New(4);
     for (size_t i = 0; i < inner.size(); ++i)
       inner[i] = static_cast<int32_t>(i + (j * 10));
     array[j] = inner.Pass();
   }
 
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U + 2 * 8U + 2 * (8U + 4 * 4U), size);
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(2U, array2.size());
   for (size_t j = 0; j < array2.size(); ++j) {
     const Array<int32_t>& inner = array2[j];
     EXPECT_EQ(4U, inner.size());
     for (size_t i = 0; i < inner.size(); ++i)
       EXPECT_EQ(static_cast<int32_t>(i + (j * 10)), inner[i]);
   }
 }
 
-TEST_F(ArrayTest, Serialization_ArrayOfScopedEnum) {
+TEST(ArrayTest, Serialization_ArrayOfScopedEnum) {
   enum class TestEnum : int32_t {
     E0,
     E1,
     E2,
     E3,
   };
   static const TestEnum TEST_VALS[] = {
       TestEnum::E0, TestEnum::E2, TestEnum::E1, TestEnum::E3,
       TestEnum::E2, TestEnum::E2, TestEnum::E2, TestEnum::E0,
   };
@@ skipping 11 matching lines @@
   SerializeArray_(&array, &buf, &data, &validate_params);
 
   Array<TestEnum> array2;
   Deserialize_(data, &array2);
 
   EXPECT_EQ(MOJO_ARRAYSIZE(TEST_VALS), array2.size());
   for (size_t i = 0; i < array2.size(); ++i)
     EXPECT_EQ(TEST_VALS[i], array2[i]);
 }
 
-TEST_F(ArrayTest, Serialization_ArrayOfBool) {
+TEST(ArrayTest, Serialization_ArrayOfBool) {
   auto array = Array<bool>::New(10);
   for (size_t i = 0; i < array.size(); ++i)
     array[i] = i % 2 ? true : false;
 
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U + 8U, size);
 
   FixedBufferForTesting buf(size);
   Array_Data<bool>* data = nullptr;
   ArrayValidateParams validate_params(0, false, nullptr);
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             SerializeArray_(&array, &buf, &data, &validate_params));
 
   Array<bool> array2;
   Deserialize_(data, &array2);
 
   EXPECT_EQ(10U, array2.size());
   for (size_t i = 0; i < array2.size(); ++i)
     EXPECT_EQ(i % 2 ? true : false, array2[i]);
 }
 
-TEST_F(ArrayTest, Serialization_ArrayOfString) {
+TEST(ArrayTest, Serialization_ArrayOfString) {
   auto array = Array<String>::New(10);
   for (size_t i = 0; i < array.size(); ++i) {
     char c = 'A' + static_cast<char>(i);
     array[i] = String(&c, 1);
   }
 
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U +            // array header
                 10 * 8U +   // array payload (10 pointers)
                 10 * (8U +  // string header
@@ skipping 11 matching lines @@
   Deserialize_(data, &array2);
 
   EXPECT_EQ(10U, array2.size());
   for (size_t i = 0; i < array2.size(); ++i) {
     char c = 'A' + static_cast<char>(i);
     EXPECT_EQ(String(&c, 1), array2[i]);
   }
 }
 
 // Tests serializing and deserializing an Array<Handle>.
-TEST_F(ArrayTest, Serialization_ArrayOfHandle) {
+TEST(ArrayTest, Serialization_ArrayOfHandle) {
   auto array = Array<ScopedHandleBase<MessagePipeHandle>>::New(4);
   MessagePipe p0;
   MessagePipe p1;
   // array[0] is left invalid.
   array[1] = p0.handle1.Pass();
   array[2] = p1.handle0.Pass();
   array[3] = p1.handle1.Pass();
 
   size_t size = GetSerializedSize_(array);
   EXPECT_EQ(8U               // array header
@@ skipping 25 matching lines @@
   EXPECT_FALSE(array[2].is_valid());
   EXPECT_FALSE(array[3].is_valid());
 
   Deserialize_(data, &array);
   EXPECT_FALSE(array[0].is_valid());
   EXPECT_TRUE(array[1].is_valid());
   EXPECT_TRUE(array[2].is_valid());
   EXPECT_TRUE(array[3].is_valid());
 }
 
-TEST_F(ArrayTest, Serialization_StructWithArraysOfHandles) {
+TEST(ArrayTest, Serialization_StructWithArraysOfHandles) {
   StructWithHandles handles_struct;
   MessagePipe handle_pair_0;
 }
 
 // Test serializing and deserializing an Array<InterfacePtr>.
-TEST_F(ArrayTest, Serialization_ArrayOfInterfacePtr) {
+TEST(ArrayTest, Serialization_ArrayOfInterfacePtr) {
   auto iface_array = Array<mojo::InterfaceHandle<TestInterface>>::New(1);
   size_t size = GetSerializedSize_(iface_array);
   EXPECT_EQ(8U               // array header
                 + (8U * 1),  // Interface_Data * number of elements
             size);
 
   FixedBufferForTesting buf(size * 3);
   Array_Data<mojo::internal::Interface_Data>* output = nullptr;
 
   // 1.  Invalid InterfacePtr should fail serialization.
@@ skipping 20 matching lines @@
       mojo::internal::ValidationError::NONE,
       SerializeArray_(&iface_array, &buf, &output, &validate_non_nullable));
   EXPECT_FALSE(iface_array[0].is_valid());
 
   Deserialize_(output, &iface_array);
   EXPECT_TRUE(iface_array[0].is_valid());
 }
 
 // Test serializing and deserializing a struct with an Array<> of another struct
 // which has an InterfacePtr.
-TEST_F(ArrayTest, Serialization_StructWithArrayOfInterfacePtr) {
+TEST(ArrayTest, Serialization_StructWithArrayOfInterfacePtr) {
   StructWithInterfaceArray struct_arr_iface;
   struct_arr_iface.structs_array = Array<StructWithInterfacePtr>::New(1);
   struct_arr_iface.nullable_structs_array =
       Array<StructWithInterfacePtr>::New(1);
 
   size_t size = GetSerializedSize_(struct_arr_iface);
   EXPECT_EQ(8U            // struct header
                 + 8U      // offset to |structs_array|
                 + (8U     // array header
                    + 8U)  // offset to StructWithInterface (nullptr)
@@ skipping 24 matching lines @@
             Serialize_(&struct_arr_iface, &buf, &struct_arr_iface_data));
 
   EXPECT_FALSE(struct_arr_iface.structs_array[0]->iptr.is_valid());
 
   Deserialize_(struct_arr_iface_data, &struct_arr_iface);
   EXPECT_TRUE(struct_arr_iface.structs_array[0]->iptr.is_valid());
 }
 
 // Test serializing and deserializing a struct with an Array<> of interface
 // requests.
-TEST_F(ArrayTest, Serialization_StructWithArrayOfIntefaceRequest) {
+TEST(ArrayTest, Serialization_StructWithArrayOfIntefaceRequest) {
   StructWithInterfaceRequests struct_arr_iface_req;
   struct_arr_iface_req.req_array =
       Array<InterfaceRequest<TestInterface>>::New(1);
   struct_arr_iface_req.nullable_req_array =
       Array<InterfaceRequest<TestInterface>>::New(1);
 
   size_t size = GetSerializedSize_(struct_arr_iface_req);
   EXPECT_EQ(8U            // struct header
                 + 8U      // offset to |req_array|
                 + (8U     // array header for |req_array|
@@ skipping 23 matching lines @@
   EXPECT_EQ(
       mojo::internal::ValidationError::NONE,
       Serialize_(&struct_arr_iface_req, &buf, &struct_arr_iface_req_data));
 
   EXPECT_FALSE(struct_arr_iface_req.req_array[0].is_pending());
 
   Deserialize_(struct_arr_iface_req_data, &struct_arr_iface_req);
   EXPECT_TRUE(struct_arr_iface_req.req_array[0].is_pending());
 }
 
-TEST_F(ArrayTest, Resize_Copyable) {
+TEST(ArrayTest, Resize_Copyable) {
   ASSERT_EQ(0u, CopyableType::num_instances());
   auto array = mojo::Array<CopyableType>::New(3);
   std::vector<CopyableType*> value_ptrs;
   value_ptrs.push_back(array[0].ptr());
   value_ptrs.push_back(array[1].ptr());
 
   for (size_t i = 0; i < array.size(); i++)
     array[i].ResetCopied();
 
   array.resize(2);
@@ skipping 31 matching lines @@
     EXPECT_EQ(value_ptrs[i], array[i].ptr());
   }
   array.reset();
   EXPECT_EQ(0u, CopyableType::num_instances());
   EXPECT_FALSE(array);
   array.resize(0);
   EXPECT_EQ(0u, CopyableType::num_instances());
   EXPECT_TRUE(array);
 }
 
-TEST_F(ArrayTest, Resize_MoveOnly) {
+TEST(ArrayTest, Resize_MoveOnly) {
   ASSERT_EQ(0u, MoveOnlyType::num_instances());
   auto array = mojo::Array<MoveOnlyType>::New(3);
   std::vector<MoveOnlyType*> value_ptrs;
   value_ptrs.push_back(array[0].ptr());
   value_ptrs.push_back(array[1].ptr());
 
   for (size_t i = 0; i < array.size(); i++)
     EXPECT_FALSE(array[i].moved());
 
   array.resize(2);
@@ skipping 31 matching lines @@
     EXPECT_FALSE(array[i].moved());
 
   array.reset();
   EXPECT_EQ(0u, MoveOnlyType::num_instances());
   EXPECT_FALSE(array);
   array.resize(0);
   EXPECT_EQ(0u, MoveOnlyType::num_instances());
   EXPECT_TRUE(array);
 }
 
-TEST_F(ArrayTest, PushBack_Copyable) {
+TEST(ArrayTest, PushBack_Copyable) {
   ASSERT_EQ(0u, CopyableType::num_instances());
   auto array = mojo::Array<CopyableType>::New(2);
   array.reset();
   std::vector<CopyableType*> value_ptrs;
   size_t capacity = array.storage().capacity();
   for (size_t i = 0; i < capacity; i++) {
     CopyableType value;
     value_ptrs.push_back(value.ptr());
     array.push_back(value);
     ASSERT_EQ(i + 1, array.size());
@@ skipping 14 matching lines @@
   EXPECT_EQ(array.size(), CopyableType::num_instances());
 
   for (size_t i = 0; i < array.size(); i++) {
     EXPECT_TRUE(array[i].copied());
     EXPECT_EQ(value_ptrs[i], array[i].ptr());
   }
   array.reset();
   EXPECT_EQ(0u, CopyableType::num_instances());
 }
 
-TEST_F(ArrayTest, PushBack_MoveOnly) {
+TEST(ArrayTest, PushBack_MoveOnly) {
   ASSERT_EQ(0u, MoveOnlyType::num_instances());
   auto array = mojo::Array<MoveOnlyType>::New(2);
   array.reset();
   std::vector<MoveOnlyType*> value_ptrs;
   size_t capacity = array.storage().capacity();
   for (size_t i = 0; i < capacity; i++) {
     MoveOnlyType value;
     value_ptrs.push_back(value.ptr());
     array.push_back(value.Pass());
     ASSERT_EQ(i + 1, array.size());
@@ skipping 14 matching lines @@
   EXPECT_EQ(array.size(), MoveOnlyType::num_instances());
 
   for (size_t i = 0; i < array.size(); i++) {
     EXPECT_TRUE(array[i].moved());
     EXPECT_EQ(value_ptrs[i], array[i].ptr());
   }
   array.reset();
   EXPECT_EQ(0u, MoveOnlyType::num_instances());
 }
 
-TEST_F(ArrayTest, Iterator) {
+TEST(ArrayTest, Iterator) {
   std::vector<int> values;
   values.push_back(0);
   values.push_back(1);
   values.push_back(2);
   values.push_back(3);
   Array<int> arr = Array<int>::From(values);
 
   // Test RandomAcessIterator traits.
   {
     // Test +,-,+=,-=.
@@ skipping 29 matching lines @@
   }
 
   {
     SCOPED_TRACE("Array iterator bidirectionality test.");
     ExpectBidiIteratorConcept(arr.begin(), arr.end(), values);
     ExpectBidiMutableIteratorConcept(arr.begin(), arr.end(), values);
   }
 }
 
 // Test serializing and deserializing of an array with null elements.
-TEST_F(ArrayTest, Serialization_ArrayOfStructPtr) {
+TEST(ArrayTest, Serialization_ArrayOfStructPtr) {
   ArrayValidateParams validate_nullable(2, true, nullptr);
   ArrayValidateParams validate_non_nullable(2, false, nullptr);
 
   Array<RectPtr> array = Array<RectPtr>::New(2);
   array[1] = Rect::New();
   array[1]->x = 1;
   array[1]->y = 2;
   array[1]->width = 3;
   array[1]->height = 4;
 
@@ skipping 62 matching lines @@
     EXPECT_EQ(1, array3[1]->x);
     EXPECT_EQ(2, array3[1]->y);
     EXPECT_EQ(3, array3[1]->width);
     EXPECT_EQ(4, array3[1]->height);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo