Add QuicStream and friends to QUIC code.

net/quic/quic_session_test.cc

Index: net/quic/quic_session_test.cc
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..deebc78a9e01e49b20a7aa3b7acbf58997d5192f
--- /dev/null
+++ b/net/quic/quic_session_test.cc
@@ -0,0 +1,158 @@
+// 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/quic_session.h"
+#include "net/quic/quic_connection.h"
+
+#include <set>
+
+#include "base/hash_tables.h"
+#include "net/quic/test_tools/quic_test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::hash_map;
+using std::set;
+using testing::_;
+
+namespace net {
+namespace test {
+namespace {
+
+class TestCryptoStream : public QuicCryptoStream {
+ public:
+  explicit TestCryptoStream(QuicSession* session)
+      : QuicCryptoStream(session) {
+  }
+
+  void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+    set_handshake_complete(true);
+  }
+};
+
+class TestStream : public ReliableQuicStream {
+ public:
+  TestStream(QuicStreamId id, QuicSession* session)
+      : ReliableQuicStream(id, session) {
+  }
+
+  virtual uint32 ProcessData(const char* data, uint32 data_len) {
+    return data_len;
+  }
+};
+
+class TestSession : public QuicSession {
+ public:
+  TestSession(QuicConnection* connection, bool is_server)
+      : QuicSession(connection, is_server),
+        crypto_stream_(this) {
+  }
+
+  virtual QuicCryptoStream* GetCryptoStream() {
+    return &crypto_stream_;
+  }
+
+  virtual TestStream* CreateOutgoingReliableStream() {
+    TestStream* stream = new TestStream(GetNextStreamId(), this);
+    ActivateStream(stream);
+    return stream;
+  }
+
+  virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) {
+    return new TestStream(id, this);
+  }
+
+  bool IsClosedStream(QuicStreamId id) {
+    return QuicSession::IsClosedStream(id);
+  }
+
+  ReliableQuicStream* GetIncomingReliableStream(QuicStreamId stream_id) {
+    return QuicSession::GetIncomingReliableStream(stream_id);
+  }
+
+  TestCryptoStream crypto_stream_;
+};
+
+class QuicSessionTest : public ::testing::Test {
+ protected:
+  QuicSessionTest()
+      : guid_(1),
+        connection_(new MockConnection(guid_, IPEndPoint())),
+        session_(connection_, true) {
+  }
+
+  void CheckClosedStreams() {
+    for (int i = kCryptoStreamId; i < 100; i++) {
+      if (closed_streams_.count(i) == 0) {
+        EXPECT_FALSE(session_.IsClosedStream(i)) << " stream id: " << i;
+      } else {
+        EXPECT_TRUE(session_.IsClosedStream(i)) << " stream id: " << i;
+      }
+    }
+  }
+
+  void CloseStream(QuicStreamId id) {
+    session_.CloseStream(id);
+    closed_streams_.insert(id);
+  }
+
+  QuicGuid guid_;
+  MockConnection* connection_;
+  TestSession session_;
+  QuicConnectionVisitorInterface* visitor_;
+  hash_map<QuicStreamId, ReliableQuicStream*>* streams_;
+  set<QuicStreamId> closed_streams_;
+};
+
+TEST_F(QuicSessionTest, IsHandshakeComplete) {
+  EXPECT_FALSE(session_.IsHandshakeComplete());
+  CryptoHandshakeMessage message;
+  session_.crypto_stream_.OnHandshakeMessage(message);
+  EXPECT_TRUE(session_.IsHandshakeComplete());
+}
+
+TEST_F(QuicSessionTest, IsClosedStreamDefault) {
+  // Ensure that no streams are initially closed.
+  for (int i = kCryptoStreamId; i < 100; i++) {
+    EXPECT_FALSE(session_.IsClosedStream(i));
+  }
+}
+
+TEST_F(QuicSessionTest, IsClosedStreamLocallyCreated) {
+  scoped_ptr<TestStream> stream2(session_.CreateOutgoingReliableStream());
+  scoped_ptr<TestStream> stream4(session_.CreateOutgoingReliableStream());
+
+  CheckClosedStreams();
+  CloseStream(4);
+  CheckClosedStreams();
+  CloseStream(2);
+  CheckClosedStreams();
+}
+
+TEST_F(QuicSessionTest, IsClosedStreamPeerCreated) {
+  scoped_ptr<ReliableQuicStream> stream3(session_.GetIncomingReliableStream(3));
+  scoped_ptr<ReliableQuicStream> stream5(session_.GetIncomingReliableStream(5));
+
+  CheckClosedStreams();
+  CloseStream(3);
+  CheckClosedStreams();
+  CloseStream(5);
+  // Create stream id 9, and implicitly 7
+  scoped_ptr<ReliableQuicStream> stream9(session_.GetIncomingReliableStream(9));
+  CheckClosedStreams();
+  // Close 9, but make sure 7 is still not closed
+  CloseStream(9);
+  CheckClosedStreams();
+}
+
+TEST_F(QuicSessionTest, StreamIdTooLarge) {
+  scoped_ptr<ReliableQuicStream> stream3(session_.GetIncomingReliableStream(3));
+  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
+  scoped_ptr<ReliableQuicStream> stream5(
+      session_.GetIncomingReliableStream(105));
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace net