Remove kint64min.

net/http/http_response_headers_unittest.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 <stdint.h>
+
 #include <algorithm>
 #include <iostream>
 #include <limits>
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
@@ skipping 1172 matching lines @@
     true
   },
 };
 
 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
                         IsRedirectTest,
                         testing::ValuesIn(is_redirect_tests));
 
 struct ContentLengthTestData {
   const char* headers;
-  int64 expected_len;
+  int64_t expected_len;
 };
 
 class GetContentLengthTest
     : public HttpResponseHeadersTest,
       public ::testing::WithParamInterface<ContentLengthTestData> {
 };
 
 TEST_P(GetContentLengthTest, GetContentLength) {
   const ContentLengthTestData test = GetParam();
 
   std::string headers(test.headers);
   HeadersToRaw(&headers);
   scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
 
   EXPECT_EQ(test.expected_len, parsed->GetContentLength());
 }
 
 const ContentLengthTestData content_length_tests[] = {
-  { "HTTP/1.1 200 OK\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 10\n",
-    10
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: \n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: abc\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: -10\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length:  +10\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 23xb5\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 0xA\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 010\n",
-    10
-  },
-  // Content-Length too big, will overflow an int64.
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 40000000000000000000\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length:       10\n",
-    10
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 10  \n",
-    10
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: \t10\n",
-    10
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: \v10\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: \f10\n",
-    -1
-  },
-  { "HTTP/1.1 200 OK\n"
-    "cOnTeNt-LENgth: 33\n",
-    33
-  },
-  { "HTTP/1.1 200 OK\n"
-    "Content-Length: 34\r\n",
-    -1
-  },
+    {"HTTP/1.1 200 OK\n", -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 10\n",
+     10},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: \n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: abc\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: -10\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length:  +10\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 23xb5\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 0xA\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 010\n",
+     10},
+    // Content-Length too big, will overflow an int64_t.
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 40000000000000000000\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length:       10\n",
+     10},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 10  \n",
+     10},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: \t10\n",
+     10},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: \v10\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: \f10\n",
+     -1},
+    {"HTTP/1.1 200 OK\n"
+     "cOnTeNt-LENgth: 33\n",
+     33},
+    {"HTTP/1.1 200 OK\n"
+     "Content-Length: 34\r\n",
+     -1},

[mmenke, 2015/11/25 18:33:46]

I assume this is just reformatting done by git cl format.  Which is fine, just
want to make sure I'm not missing anything.  Thought it ignored code that wasn't
modified, surprised it modified this code.

[Avi (use Gerrit), 2015/11/25 18:39:13]

I touched the comment "int64_t" so clang format went to town here.

 };
 
 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
                         GetContentLengthTest,
                         testing::ValuesIn(content_length_tests));
 
 struct ContentRangeTestData {
   const char* headers;
   bool expected_return_value;
-  int64 expected_first_byte_position;
-  int64 expected_last_byte_position;
-  int64 expected_instance_size;
+  int64_t expected_first_byte_position;
+  int64_t expected_last_byte_position;
+  int64_t expected_instance_size;
 };
 
 class ContentRangeTest
     : public HttpResponseHeadersTest,
       public ::testing::WithParamInterface<ContentRangeTestData> {
 };
 
 TEST_P(ContentRangeTest, GetContentRange) {
   const ContentRangeTestData test = GetParam();
 
   std::string headers(test.headers);
   HeadersToRaw(&headers);
   scoped_refptr<HttpResponseHeaders> parsed(new HttpResponseHeaders(headers));
 
-  int64 first_byte_position;
-  int64 last_byte_position;
-  int64 instance_size;
+  int64_t first_byte_position;
+  int64_t last_byte_position;
+  int64_t instance_size;
   bool return_value = parsed->GetContentRange(&first_byte_position,
                                               &last_byte_position,
                                               &instance_size);
   EXPECT_EQ(test.expected_return_value, return_value);
   EXPECT_EQ(test.expected_first_byte_position, first_byte_position);
   EXPECT_EQ(test.expected_last_byte_position, last_byte_position);
   EXPECT_EQ(test.expected_instance_size, instance_size);
 }
 
 const ContentRangeTestData content_range_tests[] = {
-  { "HTTP/1.1 206 Partial Content",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range:",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: megabytes 0-10/50",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: 0-10/50",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: Bytes 0-50/51",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-50/51",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes\t0-50/51",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range:     bytes 0-50/51",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range:     bytes    0    -   50  \t / \t51",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0\t-\t50\t/\t51\t",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range:   \tbytes\t\t\t 0\t-\t50\t/\t51\t",
-    true,
-    0,
-    50,
-    51
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: \t   bytes \t  0    -   50   /   5   1",
-    false,
-    0,
-    50,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: \t   bytes \t  0    -   5 0   /   51",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 50-0/51",
-    false,
-    50,
-    0,
-    -1
-  },
-  { "HTTP/1.1 416 Requested range not satisfiable\n"
-    "Content-Range: bytes * /*",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 416 Requested range not satisfiable\n"
-    "Content-Range: bytes *   /    *   ",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-50/*",
-    false,
-    0,
-    50,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-50  /    * ",
-    false,
-    0,
-    50,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-10000000000/10000000001",
-    true,
-    0,
-    10000000000ll,
-    10000000001ll
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-10000000000/10000000000",
-    false,
-    0,
-    10000000000ll,
-    10000000000ll
-  },
-  // 64 bit wraparound.
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0 - 9223372036854775807 / 100",
-    false,
-    0,
-    kint64max,
-    100
-  },
-  // 64 bit wraparound.
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0 - 100 / -9223372036854775808",
-    false,
-    0,
-    100,
-    kint64min
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes */50",
-    false,
-    -1,
-    -1,
-    50
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-50/10",
-    false,
-    0,
-    50,
-    10
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 40-50/45",
-    false,
-    40,
-    50,
-    45
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-50/-10",
-    false,
-    0,
-    50,
-    -10
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-0/1",
-    true,
-    0,
-    0,
-    1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-40000000000000000000/40000000000000000001",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 1-/100",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes -/100",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes -1/100",
-    false,
-    -1,
-    -1,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes 0-1233/*",
-    false,
-    0,
-    1233,
-    -1
-  },
-  { "HTTP/1.1 206 Partial Content\n"
-    "Content-Range: bytes -123 - -1/100",
-    false,
-    -1,
-    -1,
-    -1
-  },
+    {"HTTP/1.1 206 Partial Content", false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range:",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: megabytes 0-10/50",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: 0-10/50",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: Bytes 0-50/51",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-50/51",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes\t0-50/51",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range:     bytes 0-50/51",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range:     bytes    0    -   50  \t / \t51",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0\t-\t50\t/\t51\t",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range:   \tbytes\t\t\t 0\t-\t50\t/\t51\t",
+     true, 0, 50, 51},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: \t   bytes \t  0    -   50   /   5   1",
+     false, 0, 50, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: \t   bytes \t  0    -   5 0   /   51",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 50-0/51",
+     false, 50, 0, -1},
+    {"HTTP/1.1 416 Requested range not satisfiable\n"
+     "Content-Range: bytes * /*",
+     false, -1, -1, -1},
+    {"HTTP/1.1 416 Requested range not satisfiable\n"
+     "Content-Range: bytes *   /    *   ",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-50/*",
+     false, 0, 50, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-50  /    * ",
+     false, 0, 50, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-10000000000/10000000001",
+     true, 0, 10000000000ll, 10000000001ll},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-10000000000/10000000000",
+     false, 0, 10000000000ll, 10000000000ll},
+    // 64 bit wraparound.
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0 - 9223372036854775807 / 100",
+     false, 0, std::numeric_limits<int64_t>::max(), 100},
+    // 64 bit wraparound.
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0 - 100 / -9223372036854775808",
+     false, 0, 100, std::numeric_limits<int64_t>::min()},

[mmenke, 2015/11/25 18:33:46]

Other than the two numeric_limits line, I assume this is just reformatting done
by git cl format.

[Avi (use Gerrit), 2015/11/25 18:39:13]

Indeed it is.

+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes */50",
+     false, -1, -1, 50},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-50/10",
+     false, 0, 50, 10},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 40-50/45",
+     false, 40, 50, 45},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-50/-10",
+     false, 0, 50, -10},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-0/1",
+     true, 0, 0, 1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-40000000000000000000/40000000000000000001",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 1-/100",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes -/100",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes -1/100",
+     false, -1, -1, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes 0-1233/*",
+     false, 0, 1233, -1},
+    {"HTTP/1.1 206 Partial Content\n"
+     "Content-Range: bytes -123 - -1/100",
+     false, -1, -1, -1},
 };
 
 INSTANTIATE_TEST_CASE_P(HttpResponseHeaders,
                         ContentRangeTest,
                         testing::ValuesIn(content_range_tests));
 
 struct KeepAliveTestData {
   const char* headers;
   bool expected_keep_alive;
 };
@@ skipping 558 matching lines @@
 
 TEST_P(UpdateWithNewRangeTest, UpdateWithNewRange) {
   const UpdateWithNewRangeTestData test = GetParam();
 
   const HttpByteRange range = HttpByteRange::Bounded(3, 5);
 
   std::string orig_headers(test.orig_headers);
   std::replace(orig_headers.begin(), orig_headers.end(), '\n', '\0');
   scoped_refptr<HttpResponseHeaders> parsed(
       new HttpResponseHeaders(orig_headers + '\0'));
-  int64 content_size = parsed->GetContentLength();
+  int64_t content_size = parsed->GetContentLength();
   std::string resulting_headers;
 
   // Update headers without replacing status line.
   parsed->UpdateWithNewRange(range, content_size, false);
   parsed->GetNormalizedHeaders(&resulting_headers);
   EXPECT_EQ(std::string(test.expected_headers), resulting_headers);
 
   // Replace status line too.
   parsed->UpdateWithNewRange(range, content_size, true);
   parsed->GetNormalizedHeaders(&resulting_headers);
@@ skipping 89 matching lines @@
   EXPECT_EQ(TimeDelta::FromSeconds(0), GetMaxAgeValue());
 }
 
 TEST_F(HttpResponseHeadersCacheControlTest, MaxAgeCaseInsensitive) {
   InitializeHeadersWithCacheControl("Max-aGe=15");
   EXPECT_EQ(TimeDelta::FromSeconds(15), GetMaxAgeValue());
 }
 
 struct MaxAgeTestData {
   const char* max_age_string;
-  const int64 expected_seconds;
+  const int64_t expected_seconds;
 };
 
 class MaxAgeEdgeCasesTest
     : public HttpResponseHeadersCacheControlTest,
       public ::testing::WithParamInterface<MaxAgeTestData> {
 };
 
 TEST_P(MaxAgeEdgeCasesTest, MaxAgeEdgeCases) {
   const MaxAgeTestData test = GetParam();
 
   std::string max_age = "max-age=";
   InitializeHeadersWithCacheControl(
       (max_age + test.max_age_string).c_str());
   EXPECT_EQ(test.expected_seconds, GetMaxAgeValue().InSeconds())
       << " for max-age=" << test.max_age_string;
 }
 
 const MaxAgeTestData max_age_tests[] = {
-  {" 1 ", 1},    // Spaces are ignored.
-  {"-1", -1},    // Negative numbers are passed through.
-  {"--1", 0},    // Leading junk gives 0.
-  {"2s", 2},     // Trailing junk is ignored.
-  {"3 days", 3},
-  {"'4'", 0},    // Single quotes don't work.
-  {"\"5\"", 0},  // Double quotes don't work.
-  {"0x6", 0},    // Hex not parsed as hex.
-  {"7F", 7},     // Hex without 0x still not parsed as hex.
-  {"010", 10},   // Octal not parsed as octal.
-  {"9223372036854", 9223372036854},
-  //  {"9223372036855", -9223372036854},  // Undefined behaviour.
-  //  {"9223372036854775806", -2},        // Undefined behaviour.
-  {"9223372036854775807", 9223372036854775807},
-  {"20000000000000000000",
-  std::numeric_limits<int64>::max()},  // Overflow int64.
+    {" 1 ", 1},  // Spaces are ignored.
+    {"-1", -1},  // Negative numbers are passed through.
+    {"--1", 0},  // Leading junk gives 0.
+    {"2s", 2},   // Trailing junk is ignored.
+    {"3 days", 3},
+    {"'4'", 0},    // Single quotes don't work.
+    {"\"5\"", 0},  // Double quotes don't work.
+    {"0x6", 0},    // Hex not parsed as hex.
+    {"7F", 7},     // Hex without 0x still not parsed as hex.
+    {"010", 10},   // Octal not parsed as octal.
+    {"9223372036854", 9223372036854},
+    //  {"9223372036855", -9223372036854},  // Undefined behaviour.
+    //  {"9223372036854775806", -2},        // Undefined behaviour.
+    {"9223372036854775807", 9223372036854775807},
+    {"20000000000000000000",
+     std::numeric_limits<int64_t>::max()},  // Overflow int64_t.
 };
 
 INSTANTIATE_TEST_CASE_P(HttpResponseHeadersCacheControl,
                         MaxAgeEdgeCasesTest,
                         testing::ValuesIn(max_age_tests));
 
 TEST_F(HttpResponseHeadersCacheControlTest,
        AbsentStaleWhileRevalidateReturnsFalse) {
   InitializeHeadersWithCacheControl("max-age=3600");
   EXPECT_FALSE(headers()->GetStaleWhileRevalidateValue(TimeDeltaPointer()));
@@ skipping 19 matching lines @@
 TEST_F(HttpResponseHeadersCacheControlTest,
        FirstStaleWhileRevalidateValueUsed) {
   InitializeHeadersWithCacheControl(
       "stale-while-revalidate=1,stale-while-revalidate=7200");
   EXPECT_EQ(TimeDelta::FromSeconds(1), GetStaleWhileRevalidateValue());
 }
 
 }  // namespace
 
 }  // namespace net