Use wire values in SpdySettingsIds.

net/spdy/spdy_protocol_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/spdy/spdy_protocol.h"
 
 #include <iostream>
 #include <limits>
 #include <memory>
 
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::ostream;
+using std::string;
 
 namespace net {
 
 ostream& operator<<(ostream& os, const SpdyStreamPrecedence precedence) {
   if (precedence.is_spdy3_priority()) {
     os << "SpdyStreamPrecedence[spdy3_priority=" << precedence.spdy3_priority()
        << "]";
   } else {
     os << "SpdyStreamPrecedence[parent_id=" << precedence.parent_id()
        << ", weight=" << precedence.weight()
@@ skipping 52 matching lines @@
   EXPECT_EQ(d1.data_len(), 0ul);
   EXPECT_NE(d1.data(), nullptr);
 
   // Confirms makes a copy of char array.
   const char s2[] = "something";
   SpdyDataIR d2(2, s2);
   EXPECT_EQ(base::StringPiece(d2.data(), d2.data_len()), s2);
   EXPECT_NE(base::StringPiece(d1.data(), d1.data_len()), s2);
 
   // Confirm copies a const string.
-  const std::string foo = "foo";
+  const string foo = "foo";
   SpdyDataIR d3(3, foo);
   EXPECT_EQ(foo, d3.data());
 
   // Confirm copies a non-const string.
-  std::string bar = "bar";
+  string bar = "bar";
   SpdyDataIR d4(4, bar);
   EXPECT_EQ("bar", bar);
   EXPECT_EQ("bar", base::StringPiece(d4.data(), d4.data_len()));
 
   // Confirm moves an rvalue reference. Note that the test string "baz" is too
   // short to trigger the move optimization, and instead a copy occurs.
-  std::string baz = "the quick brown fox";
+  string baz = "the quick brown fox";
   SpdyDataIR d5(5, std::move(baz));
   EXPECT_EQ("", baz);
   EXPECT_EQ(base::StringPiece(d5.data(), d5.data_len()), "the quick brown fox");
 
   // Confirms makes a copy of string literal.
   SpdyDataIR d7(7, "something else");
   EXPECT_EQ(base::StringPiece(d7.data(), d7.data_len()), "something else");
 }
 
 TEST(SpdyProtocolTest, ClampSpdy3Priority) {
@@ skipping 33 matching lines @@
   EXPECT_EQ(3u, Http2WeightToSpdy3Priority(111));
   EXPECT_EQ(4u, Http2WeightToSpdy3Priority(110));
   EXPECT_EQ(4u, Http2WeightToSpdy3Priority(75));
   EXPECT_EQ(5u, Http2WeightToSpdy3Priority(74));
   EXPECT_EQ(5u, Http2WeightToSpdy3Priority(38));
   EXPECT_EQ(6u, Http2WeightToSpdy3Priority(37));
   EXPECT_EQ(6u, Http2WeightToSpdy3Priority(2));
   EXPECT_EQ(7u, Http2WeightToSpdy3Priority(1));
 }
 
+TEST(SpdyProtocolTest, ParseSettingsId) {
+  SpdySettingsIds setting_id;
+  EXPECT_FALSE(SpdyConstants::ParseSettingsId(0, &setting_id));
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(1, &setting_id));
+  EXPECT_EQ(SETTINGS_HEADER_TABLE_SIZE, setting_id);
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(2, &setting_id));
+  EXPECT_EQ(SETTINGS_ENABLE_PUSH, setting_id);
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(3, &setting_id));
+  EXPECT_EQ(SETTINGS_MAX_CONCURRENT_STREAMS, setting_id);
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(4, &setting_id));
+  EXPECT_EQ(SETTINGS_INITIAL_WINDOW_SIZE, setting_id);
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(5, &setting_id));
+  EXPECT_EQ(SETTINGS_MAX_FRAME_SIZE, setting_id);
+  EXPECT_TRUE(SpdyConstants::ParseSettingsId(6, &setting_id));
+  EXPECT_EQ(SETTINGS_MAX_HEADER_LIST_SIZE, setting_id);
+  EXPECT_FALSE(SpdyConstants::ParseSettingsId(7, &setting_id));
+}
+
+TEST(SpdyProtocolTest, SettingsIdToString) {
+  struct {
+    SpdySettingsIds setting_id;
+    bool expected_bool;
+    const string expected_string;
+  } test_cases[] = {
+      {static_cast<SpdySettingsIds>(0), false, "SETTINGS_UNKNOWN"},
+      {SETTINGS_HEADER_TABLE_SIZE, true, "SETTINGS_HEADER_TABLE_SIZE"},
+      {SETTINGS_ENABLE_PUSH, true, "SETTINGS_ENABLE_PUSH"},
+      {SETTINGS_MAX_CONCURRENT_STREAMS, true,
+       "SETTINGS_MAX_CONCURRENT_STREAMS"},
+      {SETTINGS_INITIAL_WINDOW_SIZE, true, "SETTINGS_INITIAL_WINDOW_SIZE"},
+      {SETTINGS_MAX_FRAME_SIZE, true, "SETTINGS_MAX_FRAME_SIZE"},
+      {SETTINGS_MAX_HEADER_LIST_SIZE, true, "SETTINGS_MAX_HEADER_LIST_SIZE"},
+      {static_cast<SpdySettingsIds>(7), false, "SETTINGS_UNKNOWN"}};
+  for (auto test_case : test_cases) {
+    const char* settings_id_string;
+    EXPECT_EQ(test_case.expected_bool,
+              SpdyConstants::SettingsIdToString(test_case.setting_id,
+                                                &settings_id_string));
+    EXPECT_EQ(test_case.expected_string, settings_id_string);
+  }
+}
+
 TEST(SpdyStreamPrecedenceTest, Basic) {
   SpdyStreamPrecedence spdy3_prec(2);
   EXPECT_TRUE(spdy3_prec.is_spdy3_priority());
   EXPECT_EQ(2, spdy3_prec.spdy3_priority());
   EXPECT_EQ(kHttp2RootStreamId, spdy3_prec.parent_id());
   EXPECT_EQ(Spdy3PriorityToHttp2Weight(2), spdy3_prec.weight());
   EXPECT_FALSE(spdy3_prec.is_exclusive());
 
   for (bool is_exclusive : {true, false}) {
     SpdyStreamPrecedence h2_prec(7, 123, is_exclusive);
@@ skipping 54 matching lines @@
             SpdyStreamPrecedence(1, 2, true));
 
   SpdyStreamPrecedence spdy3_prec(3);
   SpdyStreamPrecedence h2_prec(spdy3_prec.parent_id(), spdy3_prec.weight(),
                                spdy3_prec.is_exclusive());
   EXPECT_NE(spdy3_prec, h2_prec);
 }
 
 }  // namespace test
 }  // namespace net