Optimize phishing page term feature extraction.

base/wide_string_piece_unittest.cc

Index: base/wide_string_piece_unittest.cc
diff --git a/base/wide_string_piece_unittest.cc b/base/wide_string_piece_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1a169f690d205f4818a0a62df8a2c4843811d6b3
--- /dev/null
+++ b/base/wide_string_piece_unittest.cc
@@ -0,0 +1,181 @@
+// Copyright (c) 2011 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 "base/wide_string_piece.h"
+
+#include "base/logging.h"
+#include "base/string16.h"
+#include "base/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+TEST(WideStringPieceTest, CheckComparisonOperators) {
+#define CMP_Y(op, x, y)                                               \

[Paweł Hajdan Jr., 2011/08/02 17:10:33]

Why do we need those? Gtest makes it possible to do custom comparisons without
additional macros. Please read the friendly manual. Hint:
http://code.google.com/p/googletest/wiki/V1_6_AdvancedGuide#Predicate_Asserti...

[Garrett Casto, 2011/08/02 21:52:28]

This was because I copied the meat of this test from string_piece_unittest.cc.
Since I didn't implemented a compare function, using these macros is not really
necessary, so I've removed them.

+  ASSERT_TRUE( (WideStringPiece((x)) op WideStringPiece((y))));       \
+
+#define CMP_N(op, x, y)                                          \
+  ASSERT_FALSE(WideStringPiece((x)) op WideStringPiece((y)));       \
+
+  CMP_Y(==, ASCIIToUTF16(""),  ASCIIToUTF16(""));
+  CMP_Y(==, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_Y(==, ASCIIToUTF16("aa"), ASCIIToUTF16("aa"));
+  CMP_N(==, ASCIIToUTF16("a"),  ASCIIToUTF16(""));
+  CMP_N(==, ASCIIToUTF16(""),   ASCIIToUTF16("a"));
+  CMP_N(==, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_N(==, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_N(==, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+
+  CMP_N(!=, ASCIIToUTF16(""),  ASCIIToUTF16(""));
+  CMP_N(!=, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_N(!=, ASCIIToUTF16("aa"), ASCIIToUTF16("aa"));
+  CMP_Y(!=, ASCIIToUTF16("a"),  ASCIIToUTF16(""));
+  CMP_Y(!=, ASCIIToUTF16(""),   ASCIIToUTF16("a"));
+  CMP_Y(!=, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_Y(!=, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_Y(!=, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+
+  CMP_Y(<, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_Y(<, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_Y(<, ASCIIToUTF16("aa"), ASCIIToUTF16("b"));
+  CMP_Y(<, ASCIIToUTF16("aa"), ASCIIToUTF16("bb"));
+  CMP_N(<, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_N(<, ASCIIToUTF16("b"),  ASCIIToUTF16("a"));
+  CMP_N(<, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+  CMP_N(<, ASCIIToUTF16("b"),  ASCIIToUTF16("aa"));
+  CMP_N(<, ASCIIToUTF16("bb"), ASCIIToUTF16("aa"));
+
+  CMP_Y(<=, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_Y(<=, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_Y(<=, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_Y(<=, ASCIIToUTF16("aa"), ASCIIToUTF16("b"));
+  CMP_Y(<=, ASCIIToUTF16("aa"), ASCIIToUTF16("bb"));
+  CMP_N(<=, ASCIIToUTF16("b"),  ASCIIToUTF16("a"));
+  CMP_N(<=, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+  CMP_N(<=, ASCIIToUTF16("b"),  ASCIIToUTF16("aa"));
+  CMP_N(<=, ASCIIToUTF16("bb"), ASCIIToUTF16("aa"));
+
+  CMP_N(>=, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_N(>=, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_N(>=, ASCIIToUTF16("aa"), ASCIIToUTF16("b"));
+  CMP_N(>=, ASCIIToUTF16("aa"), ASCIIToUTF16("bb"));
+  CMP_Y(>=, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_Y(>=, ASCIIToUTF16("b"),  ASCIIToUTF16("a"));
+  CMP_Y(>=, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+  CMP_Y(>=, ASCIIToUTF16("b"),  ASCIIToUTF16("aa"));
+  CMP_Y(>=, ASCIIToUTF16("bb"), ASCIIToUTF16("aa"));
+
+  CMP_N(>, ASCIIToUTF16("a"),  ASCIIToUTF16("a"));
+  CMP_N(>, ASCIIToUTF16("a"),  ASCIIToUTF16("b"));
+  CMP_N(>, ASCIIToUTF16("a"),  ASCIIToUTF16("aa"));
+  CMP_N(>, ASCIIToUTF16("aa"), ASCIIToUTF16("b"));
+  CMP_N(>, ASCIIToUTF16("aa"), ASCIIToUTF16("bb"));
+  CMP_Y(>, ASCIIToUTF16("b"),  ASCIIToUTF16("a"));
+  CMP_Y(>, ASCIIToUTF16("aa"), ASCIIToUTF16("a"));
+  CMP_Y(>, ASCIIToUTF16("b"),  ASCIIToUTF16("aa"));
+  CMP_Y(>, ASCIIToUTF16("bb"), ASCIIToUTF16("aa"));
+
+  string16 x;
+  for (int i = 0; i < 256; i++) {
+    x += 'a';
+    string16 y = x;
+    CMP_Y(==, x, y);
+    for (int j = 0; j < i; j++) {
+      string16 z = x;
+      z[j] = 'b';       // Differs in position 'j'
+      CMP_N(==, x, z);
+    }
+  }
+
+#undef CMP_Y
+#undef CMP_N
+}
+
+TEST(WideStringPieceTest, CheckSTL) {
+  string16 first = ASCIIToUTF16("abcdefghijklmnopqrstuvwxyz");
+  WideStringPiece a(first);
+  string16 second = ASCIIToUTF16("abc");
+  WideStringPiece b(second.c_str());
+  string16 third = ASCIIToUTF16("xyz");
+  WideStringPiece c(third.c_str(), third.size());
+  string16 fourth = ASCIIToUTF16("foobarrandomstuff");
+  WideStringPiece d(fourth.c_str(), 6);
+  WideStringPiece e;
+  // Check some non-ascii characters.
+  string16 fifth(ASCIIToUTF16("123"));
+  fifth.push_back(0x0000);
+  fifth.push_back(0xd8c5);
+  fifth.push_back(0xdffe);
+  WideStringPiece f(fifth);
+
+  ASSERT_EQ(a[6], 'g');
+  ASSERT_EQ(b[0], 'a');
+  ASSERT_EQ(c[2], 'z');
+  ASSERT_EQ(f[3], '\0');
+  ASSERT_EQ(f[5], static_cast<char16>(0xdffe));
+
+  ASSERT_EQ(*d.data(), 'f');
+  ASSERT_EQ(d.data()[5], 'r');
+  ASSERT_TRUE(e.data() == NULL);
+
+  ASSERT_EQ(*a.begin(), 'a');
+  ASSERT_EQ(*(b.begin() + 2), 'c');
+  ASSERT_EQ(*(c.end() - 1), 'z');
+
+  ASSERT_EQ(*a.rbegin(), 'z');
+  ASSERT_EQ(*(b.rbegin() + 2), 'a');
+  ASSERT_EQ(*(c.rend() - 1), 'x');
+  ASSERT_TRUE(a.rbegin() + 26 == a.rend());
+
+  ASSERT_EQ(a.size(), 26U);
+  ASSERT_EQ(b.size(), 3U);
+  ASSERT_EQ(c.size(), 3U);
+  ASSERT_EQ(d.size(), 6U);
+  ASSERT_EQ(e.size(), 0U);
+  ASSERT_EQ(f.size(), 6U);
+
+  ASSERT_TRUE(!d.empty());
+  ASSERT_TRUE(d.begin() != d.end());
+  ASSERT_TRUE(d.begin() + 6 == d.end());
+
+  ASSERT_TRUE(e.empty());
+  ASSERT_TRUE(e.begin() == e.end());
+
+  d.clear();
+  ASSERT_EQ(d.size(), 0U);
+  ASSERT_TRUE(d.empty());
+  ASSERT_TRUE(d.data() == NULL);
+  ASSERT_TRUE(d.begin() == d.end());
+
+  ASSERT_GE(a.max_size(), a.capacity());
+  ASSERT_GE(a.capacity(), a.size());
+}
+
+TEST(WideStringPieceTest, CheckNULL) {
+  WideStringPiece s(NULL);
+  ASSERT_EQ(s.data(), (const char16*)NULL);
+  ASSERT_EQ(s.size(), 0U);
+
+  s.set(NULL);
+  ASSERT_EQ(s.data(), (const char16*)NULL);
+  ASSERT_EQ(s.size(), 0U);
+
+  string16 str = s.as_string16();
+  ASSERT_EQ(s.data(), (const char16*)NULL);
+  ASSERT_EQ(s.size(), 0U);
+}
+
+TEST(WideStringPieceTest, HeterogenousStringPieceEquals) {
+  ASSERT_TRUE(WideStringPiece(ASCIIToUTF16("hello")) == ASCIIToUTF16("hello"));
+}
+
+TEST(WideStringPieceTest, CheckConversion) {
+  // Make sure that we can convert from UTF8 to UTF16 and back. We use a two
+  // byte character (G clef) to test this.
+  ASSERT_EQ(
+      UTF16ToUTF8(WideStringPiece(UTF8ToUTF16("\u1d11e")).as_string16()),
+      "\u1d11e");
+}
+
+}  // namespace base