| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/base/load_log_unittest.h" | |
| 6 #include "testing/gtest/include/gtest/gtest.h" | |
| 7 | |
| 8 namespace net { | |
| 9 | |
| 10 namespace { | |
| 11 | |
| 12 TEST(LoadLogTest, Nullable) { | |
| 13 // Make sure that the static methods can be called with NULL (no-op). | |
| 14 // (Should not crash). | |
| 15 LoadLog::BeginEvent(NULL, LoadLog::TYPE_HOST_RESOLVER_IMPL); | |
| 16 LoadLog::AddEvent(NULL, LoadLog::TYPE_HOST_RESOLVER_IMPL); | |
| 17 LoadLog::EndEvent(NULL, LoadLog::TYPE_HOST_RESOLVER_IMPL); | |
| 18 } | |
| 19 | |
| 20 TEST(LoadLogTest, Basic) { | |
| 21 scoped_refptr<LoadLog> log(new LoadLog(10)); | |
| 22 | |
| 23 // Logs start off empty. | |
| 24 EXPECT_EQ(0u, log->entries().size()); | |
| 25 EXPECT_EQ(0u, log->num_entries_truncated()); | |
| 26 | |
| 27 // Add 3 entries. | |
| 28 | |
| 29 log->Add(LoadLog::Entry(MakeTime(0), | |
| 30 LoadLog::Event(LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 31 LoadLog::PHASE_BEGIN))); | |
| 32 log->Add(LoadLog::Entry(MakeTime(2), | |
| 33 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 34 LoadLog::PHASE_NONE))); | |
| 35 log->Add( | |
| 36 LoadLog::Entry( | |
| 37 MakeTime(11), | |
| 38 LoadLog::Event(LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART, | |
| 39 LoadLog::PHASE_END))); | |
| 40 | |
| 41 EXPECT_EQ(3u, log->entries().size()); | |
| 42 EXPECT_EQ(0u, log->num_entries_truncated()); | |
| 43 | |
| 44 EXPECT_TRUE(LogContainsEventAtTime( | |
| 45 *log, 0, MakeTime(0), LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 46 LoadLog::PHASE_BEGIN)); | |
| 47 | |
| 48 EXPECT_TRUE(LogContainsEventAtTime( | |
| 49 *log, 1, MakeTime(2), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | |
| 50 | |
| 51 EXPECT_TRUE(LogContainsEventAtTime( | |
| 52 *log, 2, MakeTime(11), LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART, | |
| 53 LoadLog::PHASE_END)); | |
| 54 } | |
| 55 | |
| 56 // Test that the log's size is strictly bounded. | |
| 57 TEST(LoadLogTest, Truncation) { | |
| 58 size_t kMaxNumEntries = 10; | |
| 59 scoped_refptr<LoadLog> log(new LoadLog(kMaxNumEntries)); | |
| 60 | |
| 61 // Max it out. | |
| 62 for (size_t i = 0; i < kMaxNumEntries; ++i) { | |
| 63 log->Add(LoadLog::Entry(MakeTime(i), | |
| 64 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 65 LoadLog::PHASE_NONE))); | |
| 66 } | |
| 67 | |
| 68 EXPECT_EQ(kMaxNumEntries, log->entries().size()); | |
| 69 EXPECT_EQ(0u, log->num_entries_truncated()); | |
| 70 | |
| 71 // Check the last entry. | |
| 72 EXPECT_TRUE(LogContainsEventAtTime( | |
| 73 *log, 9, MakeTime(9), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | |
| 74 | |
| 75 // Add three entries while maxed out (will cause truncation) | |
| 76 log->Add(LoadLog::Entry(MakeTime(0), | |
| 77 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 78 LoadLog::PHASE_NONE))); | |
| 79 log->Add(LoadLog::Entry(MakeTime(1), | |
| 80 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 81 LoadLog::PHASE_NONE))); | |
| 82 log->Add(LoadLog::Entry(MakeTime(2), | |
| 83 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 84 LoadLog::PHASE_NONE))); | |
| 85 | |
| 86 EXPECT_EQ(kMaxNumEntries, log->entries().size()); | |
| 87 EXPECT_EQ(3u, log->num_entries_truncated()); | |
| 88 | |
| 89 // Check the last entry -- it should be the final entry we added. | |
| 90 EXPECT_TRUE(LogContainsEventAtTime( | |
| 91 *log, 9, MakeTime(2), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | |
| 92 } | |
| 93 | |
| 94 TEST(LoadLogTest, Append) { | |
| 95 scoped_refptr<LoadLog> log1(new LoadLog(10)); | |
| 96 scoped_refptr<LoadLog> log2(new LoadLog(10)); | |
| 97 | |
| 98 log1->Add(LoadLog::Entry(MakeTime(0), | |
| 99 LoadLog::Event(LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 100 LoadLog::PHASE_BEGIN))); | |
| 101 | |
| 102 log2->Add(LoadLog::Entry(MakeTime(3), | |
| 103 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 104 LoadLog::PHASE_NONE))); | |
| 105 log2->Add(LoadLog::Entry(MakeTime(9), | |
| 106 LoadLog::Event(LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 107 LoadLog::PHASE_END))); | |
| 108 | |
| 109 log1->Append(log2); | |
| 110 | |
| 111 // Add something else to log2 (should NOT be reflected in log1). | |
| 112 log2->Add(LoadLog::Entry(MakeTime(19), | |
| 113 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 114 LoadLog::PHASE_NONE))); | |
| 115 | |
| 116 EXPECT_EQ(3u, log1->entries().size()); | |
| 117 EXPECT_EQ(0u, log1->num_entries_truncated()); | |
| 118 | |
| 119 EXPECT_TRUE(LogContainsEventAtTime( | |
| 120 *log1, 0, MakeTime(0), LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 121 LoadLog::PHASE_BEGIN)); | |
| 122 | |
| 123 EXPECT_TRUE(LogContainsEventAtTime( | |
| 124 *log1, 1, MakeTime(3), LoadLog::TYPE_CANCELLED, | |
| 125 LoadLog::PHASE_NONE)); | |
| 126 | |
| 127 EXPECT_TRUE(LogContainsEventAtTime( | |
| 128 *log1, 2, MakeTime(9), LoadLog::TYPE_HOST_RESOLVER_IMPL, | |
| 129 LoadLog::PHASE_END)); | |
| 130 } | |
| 131 | |
| 132 TEST(LoadLogTest, AppendWithTruncation) { | |
| 133 // Append() should also respect the maximum number of entries bound. | |
| 134 // (This is basically the same test as LoadLogTest.Truncation). | |
| 135 | |
| 136 // Create two load logs, which both have 6 out of 10 entries filled. | |
| 137 size_t kMaxNumEntries = 10; | |
| 138 scoped_refptr<LoadLog> log1(new LoadLog(kMaxNumEntries)); | |
| 139 scoped_refptr<LoadLog> log2(new LoadLog(kMaxNumEntries)); | |
| 140 for (size_t i = 0; i < 6; ++i) { | |
| 141 log1->Add(LoadLog::Entry(MakeTime(i), | |
| 142 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 143 LoadLog::PHASE_NONE))); | |
| 144 log2->Add(LoadLog::Entry(MakeTime(2 * i), | |
| 145 LoadLog::Event(LoadLog::TYPE_CANCELLED, | |
| 146 LoadLog::PHASE_NONE))); | |
| 147 } | |
| 148 | |
| 149 // Append log2 to log1. | |
| 150 log1->Append(log2); | |
| 151 | |
| 152 // The combined log totalled 12 entries, so 2 must have been dropped. | |
| 153 EXPECT_EQ(10u, log1->entries().size()); | |
| 154 EXPECT_EQ(2u, log1->num_entries_truncated()); | |
| 155 | |
| 156 // Combined log should end with the final entry of log2. | |
| 157 EXPECT_TRUE(LogContainsEventAtTime( | |
| 158 *log1, 9, MakeTime(10), LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | |
| 159 } | |
| 160 | |
| 161 TEST(LoadLogTest, EventTypeToString) { | |
| 162 EXPECT_STREQ("HOST_RESOLVER_IMPL", | |
| 163 LoadLog::EventTypeToString(LoadLog::TYPE_HOST_RESOLVER_IMPL)); | |
| 164 EXPECT_STREQ("HOST_RESOLVER_IMPL_OBSERVER_ONSTART", | |
| 165 LoadLog::EventTypeToString( | |
| 166 LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART)); | |
| 167 } | |
| 168 | |
| 169 TEST(LoadLogTest, String) { | |
| 170 scoped_refptr<LoadLog> log(new LoadLog(10)); | |
| 171 | |
| 172 // Make sure that AddStringLiteral() adds a literal and not a std::string. | |
| 173 // (in case there is any funny-business with implicit conversions). | |
| 174 LoadLog::AddStringLiteral(log, "This is a literal"); | |
| 175 log->Add(LoadLog::Entry(MakeTime(0), "Another literal")); | |
| 176 log->Add(LoadLog::Entry(MakeTime(0), std::string("Now a std::string"))); | |
| 177 | |
| 178 ASSERT_EQ(3u, log->entries().size()); | |
| 179 EXPECT_EQ(LoadLog::Entry::TYPE_STRING_LITERAL, log->entries()[0].type); | |
| 180 EXPECT_EQ(LoadLog::Entry::TYPE_STRING_LITERAL, log->entries()[1].type); | |
| 181 EXPECT_EQ(LoadLog::Entry::TYPE_STRING, log->entries()[2].type); | |
| 182 } | |
| 183 | |
| 184 } // namespace | |
| 185 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 848006:
Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog). (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/