Fix test case table in HistoryURLProviderTest for C++11

chrome/browser/autocomplete/history_url_provider_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 "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 782 matching lines @@
 }
 
 TEST_F(HistoryURLProviderTest, SuggestExactInput) {
   struct TestCase {
     // Inputs:
     const char* input;
     bool trim_http;
     // Expected Outputs:
     const char* contents;
     // Offsets of the ACMatchClassifications, terminated by -1s.
-    size_t offsets[3];
+    ssize_t offsets[3];

[Peter Kasting, 2013/06/17 18:43:43]

Do not use ssize_t, use size_t.  To avoid having to static_cast everywhere
below, declare a constant of type size_t and value -1 and use that in the
various initializers.

[cmarcelo, 2013/06/17 18:48:52]

Would be OK to (re-)use std::string::npos?

[Peter Kasting, 2013/06/17 18:53:12]

Yes, in fact, that's what _should_ be used, since these are intended to be
offsets into strings.

Thanks for asking, I feel dumb not having realized that right away.

You could probably do "using std::string::npos" inside this function to avoid
having to paste longer qualified names everywhere.

     // The index of the ACMatchClassification that should have the MATCH bit
     // set, -1 if there no ACMatchClassification should have the MATCH bit set.
-    size_t match_classification_index;
+    ssize_t match_classification_index;
   } test_cases[] = {
     { "http://www.somesite.com", false,
       "http://www.somesite.com", {0, -1, -1}, 0 },
     { "www.somesite.com", true,
       "www.somesite.com", {0, -1, -1}, 0 },
     { "www.somesite.com", false,
       "http://www.somesite.com", {0, 7, -1}, 1 },
     { "somesite.com", true,
       "somesite.com", {0, -1, -1}, 0 },
     { "somesite.com", false,
@@ skipping 34 matching lines @@
                                     << test_cases[i].input << ", trim_http: "
                                     << test_cases[i].trim_http);
 
     AutocompleteInput input(ASCIIToUTF16(test_cases[i].input), string16::npos,
                             string16(), GURL("about:blank"),
                             false, false, true, AutocompleteInput::ALL_MATCHES);
     AutocompleteMatch match =
         HistoryURLProvider::SuggestExactInput(autocomplete_, input,
                                               test_cases[i].trim_http);
     EXPECT_EQ(ASCIIToUTF16(test_cases[i].contents), match.contents);
+    ssize_t match_classification_index =
+        test_cases[i].match_classification_index;
     for (size_t match_index = 0; match_index < match.contents_class.size();
          ++match_index) {
-      EXPECT_EQ(test_cases[i].offsets[match_index],
-                match.contents_class[match_index].offset);
+      ssize_t offset = test_cases[i].offsets[match_index];
+      EXPECT_NE(-1, offset);
+      EXPECT_EQ(size_t(offset), match.contents_class[match_index].offset);
+      bool should_match = match_classification_index >= 0 &&
+                          match_index == size_t(match_classification_index);
       EXPECT_EQ(ACMatchClassification::URL |
-                (match_index == test_cases[i].match_classification_index ?
-                 ACMatchClassification::MATCH : 0),
+                (should_match ? ACMatchClassification::MATCH : 0),
                 match.contents_class[match_index].style);
     }
-    EXPECT_EQ(std::string::npos,
-              test_cases[i].offsets[match.contents_class.size()]);
+    EXPECT_EQ(-1, test_cases[i].offsets[match.contents_class.size()]);
   }
 }