net/ftp/ftp_util_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/ftp/ftp_util.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/format_macros.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/time/time.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using base::ASCIIToUTF16;
  16 using base::UTF8ToUTF16;
  17
  18 namespace {
  19
  20 TEST(FtpUtilTest, UnixFilePathToVMS) {
  21   const struct {
  22     const char* input;
  23     const char* expected_output;
  24   } kTestCases[] = {
  25     { "",           ""            },
  26     { "/",          "[]"          },
  27     { "/a",         "a"           },
  28     { "/a/b",       "a:[000000]b" },
  29     { "/a/b/c",     "a:[b]c"      },
  30     { "/a/b/c/d",   "a:[b.c]d"    },
  31     { "/a/b/c/d/e", "a:[b.c.d]e"  },
  32     { "a",          "a"           },
  33     { "a/b",        "[.a]b"       },
  34     { "a/b/c",      "[.a.b]c"     },
  35     { "a/b/c/d",    "[.a.b.c]d"   },
  36   };
  37   for (size_t i = 0; i < arraysize(kTestCases); i++) {
  38     EXPECT_EQ(kTestCases[i].expected_output,
  39               net::FtpUtil::UnixFilePathToVMS(kTestCases[i].input))
  40         << kTestCases[i].input;
  41   }
  42 }
  43
  44 TEST(FtpUtilTest, UnixDirectoryPathToVMS) {
  45   const struct {
  46     const char* input;
  47     const char* expected_output;
  48   } kTestCases[] = {
  49     { "",            ""            },
  50     { "/",           ""            },
  51     { "/a",          "a:[000000]"  },
  52     { "/a/",         "a:[000000]"  },
  53     { "/a/b",        "a:[b]"       },
  54     { "/a/b/",       "a:[b]"       },
  55     { "/a/b/c",      "a:[b.c]"     },
  56     { "/a/b/c/",     "a:[b.c]"     },
  57     { "/a/b/c/d",    "a:[b.c.d]"   },
  58     { "/a/b/c/d/",   "a:[b.c.d]"   },
  59     { "/a/b/c/d/e",  "a:[b.c.d.e]" },
  60     { "/a/b/c/d/e/", "a:[b.c.d.e]" },
  61     { "a",           "[.a]"        },
  62     { "a/",          "[.a]"        },
  63     { "a/b",         "[.a.b]"      },
  64     { "a/b/",        "[.a.b]"      },
  65     { "a/b/c",       "[.a.b.c]"    },
  66     { "a/b/c/",      "[.a.b.c]"    },
  67     { "a/b/c/d",     "[.a.b.c.d]"  },
  68     { "a/b/c/d/",    "[.a.b.c.d]"  },
  69   };
  70   for (size_t i = 0; i < arraysize(kTestCases); i++) {
  71     EXPECT_EQ(kTestCases[i].expected_output,
  72               net::FtpUtil::UnixDirectoryPathToVMS(kTestCases[i].input))
  73         << kTestCases[i].input;
  74   }
  75 }
  76
  77 TEST(FtpUtilTest, VMSPathToUnix) {
  78   const struct {
  79     const char* input;
  80     const char* expected_output;
  81   } kTestCases[] = {
  82     { "",            "."          },
  83     { "[]",          "/"          },
  84     { "a",           "/a"         },
  85     { "a:[000000]",  "/a"         },
  86     { "a:[000000]b", "/a/b"       },
  87     { "a:[b]",       "/a/b"       },
  88     { "a:[b]c",      "/a/b/c"     },
  89     { "a:[b.c]",     "/a/b/c"     },
  90     { "a:[b.c]d",    "/a/b/c/d"   },
  91     { "a:[b.c.d]",   "/a/b/c/d"   },
  92     { "a:[b.c.d]e",  "/a/b/c/d/e" },
  93     { "a:[b.c.d.e]", "/a/b/c/d/e" },
  94     { "[.a]",        "a"          },
  95     { "[.a]b",       "a/b"        },
  96     { "[.a.b]",      "a/b"        },
  97     { "[.a.b]c",     "a/b/c"      },
  98     { "[.a.b.c]",    "a/b/c"      },
  99     { "[.a.b.c]d",   "a/b/c/d"    },
 100     { "[.a.b.c.d]",  "a/b/c/d"    },
 101     { "[.",          ""           },
 102
 103     // UNIX emulation:
 104     { "/",           "/"          },
 105     { "/a",          "/a"         },
 106     { "/a/b",        "/a/b"       },
 107     { "/a/b/c",      "/a/b/c"     },
 108     { "/a/b/c/d",    "/a/b/c/d"   },
 109   };
 110   for (size_t i = 0; i < arraysize(kTestCases); i++) {
 111     EXPECT_EQ(kTestCases[i].expected_output,
 112               net::FtpUtil::VMSPathToUnix(kTestCases[i].input))
 113         << kTestCases[i].input;
 114   }
 115 }
 116
 117 TEST(FtpUtilTest, LsDateListingToTime) {
 118   base::Time mock_current_time;
 119   ASSERT_TRUE(base::Time::FromString("Tue, 15 Nov 1994 12:45:26 GMT",
 120                                      &mock_current_time));
 121
 122   const struct {
 123     // Input.
 124     const char* month;
 125     const char* day;
 126     const char* rest;
 127
 128     // Expected output.
 129     int expected_year;
 130     int expected_month;
 131     int expected_day_of_month;
 132     int expected_hour;
 133     int expected_minute;
 134   } kTestCases[] = {
 135     { "Nov", "01", "2007", 2007, 11, 1, 0, 0 },
 136     { "Jul", "25", "13:37", 1994, 7, 25, 13, 37 },
 137
 138     // Test date listings in German.
 139     { "M\xc3\xa4r", "13", "2009", 2009, 3, 13, 0, 0 },
 140     { "Mai", "1", "10:10", 1994, 5, 1, 10, 10 },
 141     { "Okt", "14", "21:18", 1994, 10, 14, 21, 18 },
 142     { "Dez", "25", "2008", 2008, 12, 25, 0, 0 },
 143
 144     // Test date listings in Russian.
 145     { "\xd1\x8f\xd0\xbd\xd0\xb2", "1", "2011", 2011, 1, 1, 0, 0 },
 146     { "\xd1\x84\xd0\xb5\xd0\xb2", "1", "2011", 2011, 2, 1, 0, 0 },
 147     { "\xd0\xbc\xd0\xb0\xd1\x80", "1", "2011", 2011, 3, 1, 0, 0 },
 148     { "\xd0\xb0\xd0\xbf\xd1\x80", "1", "2011", 2011, 4, 1, 0, 0 },
 149     { "\xd0\xbc\xd0\xb0\xd0\xb9", "1", "2011", 2011, 5, 1, 0, 0 },
 150     { "\xd0\xb8\xd1\x8e\xd0\xbd", "1", "2011", 2011, 6, 1, 0, 0 },
 151     { "\xd0\xb8\xd1\x8e\xd0\xbb", "1", "2011", 2011, 7, 1, 0, 0 },
 152     { "\xd0\xb0\xd0\xb2\xd0\xb3", "1", "2011", 2011, 8, 1, 0, 0 },
 153     { "\xd1\x81\xd0\xb5\xd0\xbd", "1", "2011", 2011, 9, 1, 0, 0 },
 154     { "\xd0\xbe\xd0\xba\xd1\x82", "1", "2011", 2011, 10, 1, 0, 0 },
 155     { "\xd0\xbd\xd0\xbe\xd1\x8f", "1", "2011", 2011, 11, 1, 0, 0 },
 156     { "\xd0\xb4\xd0\xb5\xd0\xba", "1", "2011", 2011, 12, 1, 0, 0 },
 157
 158     // Test current year detection.
 159     { "Nov", "01", "12:00", 1994, 11, 1, 12, 0 },
 160     { "Nov", "15", "12:00", 1994, 11, 15, 12, 0 },
 161     { "Nov", "16", "12:00", 1993, 11, 16, 12, 0 },
 162     { "Jan", "01", "08:30", 1994, 1, 1, 8, 30 },
 163     { "Sep", "02", "09:00", 1994, 9, 2, 9, 0 },
 164     { "Dec", "06", "21:00", 1993, 12, 6, 21, 0 },
 165   };
 166   for (size_t i = 0; i < arraysize(kTestCases); i++) {
 167     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s %s", i,
 168                                     kTestCases[i].month, kTestCases[i].day,
 169                                     kTestCases[i].rest));
 170
 171     base::Time time;
 172     ASSERT_TRUE(net::FtpUtil::LsDateListingToTime(
 173         UTF8ToUTF16(kTestCases[i].month), UTF8ToUTF16(kTestCases[i].day),
 174         UTF8ToUTF16(kTestCases[i].rest), mock_current_time, &time));
 175
 176     base::Time::Exploded time_exploded;
 177     time.LocalExplode(&time_exploded);
 178     EXPECT_EQ(kTestCases[i].expected_year, time_exploded.year);
 179     EXPECT_EQ(kTestCases[i].expected_month, time_exploded.month);
 180     EXPECT_EQ(kTestCases[i].expected_day_of_month, time_exploded.day_of_month);
 181     EXPECT_EQ(kTestCases[i].expected_hour, time_exploded.hour);
 182     EXPECT_EQ(kTestCases[i].expected_minute, time_exploded.minute);
 183     EXPECT_EQ(0, time_exploded.second);
 184     EXPECT_EQ(0, time_exploded.millisecond);
 185   }
 186 }
 187
 188 TEST(FtpUtilTest, WindowsDateListingToTime) {
 189   const struct {
 190     // Input.
 191     const char* date;
 192     const char* time;
 193
 194     // Expected output.
 195     int expected_year;
 196     int expected_month;
 197     int expected_day_of_month;
 198     int expected_hour;
 199     int expected_minute;
 200   } kTestCases[] = {
 201     { "11-01-07", "12:42", 2007, 11, 1, 12, 42 },
 202     { "11-01-07", "12:42AM", 2007, 11, 1, 0, 42 },
 203     { "11-01-07", "12:42PM", 2007, 11, 1, 12, 42 },
 204
 205     { "11-01-2007", "12:42", 2007, 11, 1, 12, 42 },
 206   };
 207   for (size_t i = 0; i < arraysize(kTestCases); i++) {
 208     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s", i,
 209                                     kTestCases[i].date, kTestCases[i].time));
 210
 211     base::Time time;
 212     ASSERT_TRUE(net::FtpUtil::WindowsDateListingToTime(
 213                     UTF8ToUTF16(kTestCases[i].date),
 214                     UTF8ToUTF16(kTestCases[i].time),
 215                     &time));
 216
 217     base::Time::Exploded time_exploded;
 218     time.LocalExplode(&time_exploded);
 219     EXPECT_EQ(kTestCases[i].expected_year, time_exploded.year);
 220     EXPECT_EQ(kTestCases[i].expected_month, time_exploded.month);
 221     EXPECT_EQ(kTestCases[i].expected_day_of_month, time_exploded.day_of_month);
 222     EXPECT_EQ(kTestCases[i].expected_hour, time_exploded.hour);
 223     EXPECT_EQ(kTestCases[i].expected_minute, time_exploded.minute);
 224     EXPECT_EQ(0, time_exploded.second);
 225     EXPECT_EQ(0, time_exploded.millisecond);
 226   }
 227 }
 228
 229 TEST(FtpUtilTest, GetStringPartAfterColumns) {
 230   const struct {
 231     const char* text;
 232     int column;
 233     const char* expected_result;
 234   } kTestCases[] = {
 235     { "", 0, "" },
 236     { "", 1, "" },
 237     { "foo abc", 0, "foo abc" },
 238     { "foo abc", 1, "abc" },
 239     { "  foo   abc", 0, "foo   abc" },
 240     { "  foo   abc", 1, "abc" },
 241     { "  foo   abc", 2, "" },
 242     { "  foo   abc ", 0, "foo   abc" },
 243     { "  foo   abc ", 1, "abc" },
 244     { "  foo   abc ", 2, "" },
 245   };
 246   for (size_t i = 0; i < arraysize(kTestCases); i++) {
 247     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %d", i,
 248                                     kTestCases[i].text, kTestCases[i].column));
 249
 250     EXPECT_EQ(ASCIIToUTF16(kTestCases[i].expected_result),
 251               net::FtpUtil::GetStringPartAfterColumns(
 252                   ASCIIToUTF16(kTestCases[i].text), kTestCases[i].column));
 253   }
 254 }
 255
 256 }  // namespace