Split TrafficPolicer into a generic one-way packet filter class and a policer-specific logic.

net/quic/test_tools/simulator/simulator_test.cc

 // Copyright (c) 2012 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 "net/quic/test_tools/simulator/simulator.h"
 
 #include "base/memory/ptr_util.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/alarm_factory.h"
 #include "net/quic/test_tools/simulator/link.h"
+#include "net/quic/test_tools/simulator/packet_filter.h"
 #include "net/quic/test_tools/simulator/queue.h"
 #include "net/quic/test_tools/simulator/switch.h"
 #include "net/quic/test_tools/simulator/traffic_policer.h"
 
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::_;
+using testing::Return;
+using testing::StrictMock;
+
 namespace net {
 namespace simulator {
 
 // A simple counter that increments its value by 1 every specified period.
 class Counter : public Actor {
  public:
   Counter(Simulator* simulator, std::string name, QuicTime::Delta period)
       : Actor(simulator, name), value_(-1), period_(period) {
     Schedule(clock_->Now());
   }
@@ skipping 529 matching lines @@
 TEST(SimulatorTest, RunFor) {
   Simulator simulator;
 
   Counter counter(&simulator, "counter", QuicTime::Delta::FromSeconds(3));
 
   simulator.RunFor(QuicTime::Delta::FromSeconds(100));
 
   EXPECT_EQ(33, counter.get_value());
 }
 
+class MockPacketFilter : public PacketFilter {
+ public:
+  MockPacketFilter(Simulator* simulator, std::string name, Endpoint* endpoint)
+      : PacketFilter(simulator, name, endpoint) {}
+  MOCK_METHOD1(FilterPacket, bool(const Packet&));
+};
+
+// Set up two trivial packet filters, one allowing any packets, and one dropping
+// all of them.
+TEST(SimulatorTest, PacketFilter) {
+  const QuicBandwidth bandwidth =
+      QuicBandwidth::FromBytesPerSecond(1024 * 1024);
+  const QuicTime::Delta base_propagation_delay =
+      QuicTime::Delta::FromMilliseconds(5);
+
+  Simulator simulator;
+  LinkSaturator saturator_a(&simulator, "Saturator A", 1000, "Saturator B");
+  LinkSaturator saturator_b(&simulator, "Saturator B", 1000, "Saturator A");
+
+  // Attach packets to the switch to create a delay between the point at which
+  // the packet is generated and the point at which it is filtered.  Note that
+  // if the saturators were connected directly, the link would be always
+  // available for the endpoint which has all of its packets dropped, resulting
+  // in saturator looping infinitely.
+  Switch network_switch(&simulator, "Switch", 8,
+                        bandwidth * base_propagation_delay * 10);
+  StrictMock<MockPacketFilter> a_to_b_filter(&simulator, "A -> B filter",
+                                             network_switch.port(1));
+  StrictMock<MockPacketFilter> b_to_a_filter(&simulator, "B -> A filter",
+                                             network_switch.port(2));
+  SymmetricLink link_a(&a_to_b_filter, &saturator_b, bandwidth,
+                       base_propagation_delay);
+  SymmetricLink link_b(&b_to_a_filter, &saturator_a, bandwidth,
+                       base_propagation_delay);
+
+  // Allow packets from A to B, but not from B to A.
+  EXPECT_CALL(a_to_b_filter, FilterPacket(_)).WillRepeatedly(Return(true));
+  EXPECT_CALL(b_to_a_filter, FilterPacket(_)).WillRepeatedly(Return(false));
+
+  // Run the simulation for a while, and expect that only B will receive any
+  // packets.
+  simulator.RunFor(QuicTime::Delta::FromSeconds(10));
+  EXPECT_GE(saturator_b.counter()->packets(), 1u);
+  EXPECT_EQ(saturator_a.counter()->packets(), 0u);
+}
+
 // Set up a traffic policer in one direction that throttles at 25% of link
 // bandwidth, and put two link saturators at each endpoint.
 TEST(SimulatorTest, TrafficPolicer) {
   const QuicBandwidth bandwidth =
       QuicBandwidth::FromBytesPerSecond(1024 * 1024);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(5);
   const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
   Switch network_switch(&simulator, "Switch", 8,
                         bandwidth * base_propagation_delay * 10);
 
   const QuicByteCount initial_burst = 1000 * 10;
   const QuicByteCount max_bucket_size = 1000 * 100;
   const QuicBandwidth target_bandwidth = bandwidth * 0.25;
   TrafficPolicer policer(&simulator, "Policer", initial_burst, max_bucket_size,
                          target_bandwidth, network_switch.port(2));
 
   SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
                       base_propagation_delay);
-  SymmetricLink link2(&saturator2, policer.output(), bandwidth,
-                      base_propagation_delay);
+  SymmetricLink link2(&saturator2, &policer, bandwidth, base_propagation_delay);
 
   // Ensure the initial burst passes without being dropped at all.
   bool simulator_result = simulator.RunUntilOrTimeout(
       [&saturator1, initial_burst]() {
         return saturator1.bytes_transmitted() == initial_burst;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
   saturator1.Pause();
   simulator_result = simulator.RunUntilOrTimeout(
@@ skipping 37 matching lines @@
                         bandwidth * base_propagation_delay * 10);
 
   const QuicByteCount initial_burst = 1000 * 10;
   const QuicByteCount max_bucket_size = 1000 * 100;
   const QuicBandwidth target_bandwidth = bandwidth * 0.25;
   TrafficPolicer policer(&simulator, "Policer", initial_burst, max_bucket_size,
                          target_bandwidth, network_switch.port(2));
 
   SymmetricLink link1(&saturator1, network_switch.port(1), bandwidth,
                       base_propagation_delay);
-  SymmetricLink link2(&saturator2, policer.output(), bandwidth,
-                      base_propagation_delay);
+  SymmetricLink link2(&saturator2, &policer, bandwidth, base_propagation_delay);
 
   // Ensure at least one packet is sent on each side.
   bool simulator_result = simulator.RunUntilOrTimeout(
       [&saturator1, &saturator2]() {
         return saturator1.packets_transmitted() > 0 &&
                saturator2.packets_transmitted() > 0;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
 
@@ skipping 14 matching lines @@
 
   // Expect subsequent traffic to be policed.
   saturator1.Resume();
   simulator.RunFor(QuicTime::Delta::FromSeconds(10));
   test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
                        saturator2.counter()->bytes(), 0.1f);
 }
 
 }  // namespace simulator
 }  // namespace net