Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2010 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 #ifndef NET_BASE_NET_LOG_UNITTEST_H_
      6 #define NET_BASE_NET_LOG_UNITTEST_H_
      7 #pragma once
      8 
      9 #include <cstddef>
     10 
     11 #include "net/base/capturing_net_log.h"
     12 #include "testing/gtest/include/gtest/gtest.h"
     13 
     14 namespace net {
     15 
     16 // Create a timestamp with internal value of |t| milliseconds from the epoch.
     17 inline base::TimeTicks MakeTime(int t) {
     18   base::TimeTicks ticks;  // initialized to 0.
     19   ticks += base::TimeDelta::FromMilliseconds(t);
     20   return ticks;
     21 }
     22 
     23 inline ::testing::AssertionResult LogContainsEventHelper(
     24     const CapturingNetLog::EntryList& entries,
     25     int i,  // Negative indices are reverse indices.
     26     const base::TimeTicks& expected_time,
     27     bool check_time,
     28     NetLog::EventType expected_event,
     29     NetLog::EventPhase expected_phase) {
     30   // Negative indices are reverse indices.
     31   size_t j = (i < 0) ?
     32       static_cast<size_t>(static_cast<int>(entries.size()) + i) :
     33       static_cast<size_t>(i);
     34   if (j >= entries.size())
     35     return ::testing::AssertionFailure() << j << " is out of bounds.";
     36   const CapturingNetLog::Entry& entry = entries[j];
     37   if (expected_event != entry.type) {
     38     return ::testing::AssertionFailure()
     39         << "Actual event: " << NetLog::EventTypeToString(entry.type)
     40         << ". Expected event: " << NetLog::EventTypeToString(expected_event)
     41         << ".";
     42   }
     43   if (expected_phase != entry.phase) {
     44     return ::testing::AssertionFailure()
     45         << "Actual phase: " << entry.phase
     46         << ". Expected phase: " << expected_phase << ".";
     47   }
     48   if (check_time) {
     49     if (expected_time != entry.time) {
     50       return ::testing::AssertionFailure()
     51           << "Actual time: " << entry.time.ToInternalValue()
     52           << ". Expected time: " << expected_time.ToInternalValue()
     53           << ".";
     54     }
     55   }
     56   return ::testing::AssertionSuccess();
     57 }
     58 
     59 inline ::testing::AssertionResult LogContainsEventAtTime(
     60     const CapturingNetLog::EntryList& log,
     61     int i,  // Negative indices are reverse indices.
     62     const base::TimeTicks& expected_time,
     63     NetLog::EventType expected_event,
     64     NetLog::EventPhase expected_phase) {
     65   return LogContainsEventHelper(log, i, expected_time, true,
     66                                 expected_event, expected_phase);
     67 }
     68 
     69 // Version without timestamp.
     70 inline ::testing::AssertionResult LogContainsEvent(
     71     const CapturingNetLog::EntryList& log,
     72     int i,  // Negative indices are reverse indices.
     73     NetLog::EventType expected_event,
     74     NetLog::EventPhase expected_phase) {
     75   return LogContainsEventHelper(log, i, base::TimeTicks(), false,
     76                                 expected_event, expected_phase);
     77 }
     78 
     79 // Version for PHASE_BEGIN (and no timestamp).
     80 inline ::testing::AssertionResult LogContainsBeginEvent(
     81     const CapturingNetLog::EntryList& log,
     82     int i,  // Negative indices are reverse indices.
     83     NetLog::EventType expected_event) {
     84   return LogContainsEvent(log, i, expected_event, NetLog::PHASE_BEGIN);
     85 }
     86 
     87 // Version for PHASE_END (and no timestamp).
     88 inline ::testing::AssertionResult LogContainsEndEvent(
     89     const CapturingNetLog::EntryList& log,
     90     int i,  // Negative indices are reverse indices.
     91     NetLog::EventType expected_event) {
     92   return LogContainsEvent(log, i, expected_event, NetLog::PHASE_END);
     93 }
     94 
     95 inline ::testing::AssertionResult LogContainsEntryWithType(
     96     const CapturingNetLog::EntryList& entries,
     97     int i, // Negative indices are reverse indices.
     98     NetLog::EventType type) {
     99   // Negative indices are reverse indices.
    100   size_t j = (i < 0) ?
    101       static_cast<size_t>(static_cast<int>(entries.size()) + i) :
    102       static_cast<size_t>(i);
    103   if (j >= entries.size())
    104     return ::testing::AssertionFailure() << j << " is out of bounds.";
    105   const CapturingNetLog::Entry& entry = entries[j];
    106   if (entry.type != type)
    107     return ::testing::AssertionFailure() << "Type does not match.";
    108   return ::testing::AssertionSuccess();
    109 }
    110 
    111 
    112 // Expect that the log contains an event, but don't care about where
    113 // as long as the first index where it is found is at least |min_index|.
    114 // Returns the position where the event was found.
    115 inline size_t ExpectLogContainsSomewhere(
    116     const CapturingNetLog::EntryList& entries,
    117     size_t min_index,
    118     NetLog::EventType expected_event,
    119     NetLog::EventPhase expected_phase) {
    120   size_t i = 0;
    121   for (; i < entries.size(); ++i) {
    122     const CapturingNetLog::Entry& entry = entries[i];
    123     if (entry.type == expected_event &&
    124         entry.phase == expected_phase)
    125       break;
    126   }
    127   EXPECT_LT(i, entries.size());
    128   EXPECT_GE(i, min_index);
    129   return i;
    130 }
    131 
    132 // Expect that the log contains an event, but don't care about where
    133 // as long as one index where it is found is at least |min_index|.
    134 // Returns the first such position where the event was found.
    135 inline size_t ExpectLogContainsSomewhereAfter(
    136     const CapturingNetLog::EntryList& entries,
    137     size_t min_index,
    138     NetLog::EventType expected_event,
    139     NetLog::EventPhase expected_phase) {
    140   size_t i = min_index;
    141   for (; i < entries.size(); ++i) {
    142     const CapturingNetLog::Entry& entry = entries[i];
    143     if (entry.type == expected_event &&
    144         entry.phase == expected_phase)
    145       break;
    146   }
    147   EXPECT_LT(i, entries.size());
    148   return i;
    149 }
    150 
    151 }  // namespace net
    152 
    153 #endif  // NET_BASE_NET_LOG_UNITTEST_H_
    154