Fix a pair of bugs in UNIX->VMS path conversion.

net/ftp/ftp_util_unittest.cc

 // 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 "net/ftp/ftp_util.h"
 
 #include "base/format_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 16 matching lines @@
     { "/",          "[]"          },
     { "/a",         "a"           },
     { "/a/b",       "a:[000000]b" },
     { "/a/b/c",     "a:[b]c"      },
     { "/a/b/c/d",   "a:[b.c]d"    },
     { "/a/b/c/d/e", "a:[b.c.d]e"  },
     { "a",          "a"           },
     { "a/b",        "[.a]b"       },
     { "a/b/c",      "[.a.b]c"     },
     { "a/b/c/d",    "[.a.b.c]d"   },
+    // Extra slashes shouldn't matter.
+    { "/////",      "[]"          },
+    { "/////a",     "a"           },
+    { "//a//b///c", "a:[b]c"      },
+    { "a//b///c",   "[.a.b]c"     },
   };
   for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               FtpUtil::UnixFilePathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
   }
 }
 
 TEST(FtpUtilTest, UnixDirectoryPathToVMS) {
   const struct {
     const char* input;
     const char* expected_output;
   } kTestCases[] = {
-    { "",            ""            },
-    { "/",           ""            },
-    { "/a",          "a:[000000]"  },
-    { "/a/",         "a:[000000]"  },
-    { "/a/b",        "a:[b]"       },
-    { "/a/b/",       "a:[b]"       },
-    { "/a/b/c",      "a:[b.c]"     },
-    { "/a/b/c/",     "a:[b.c]"     },
-    { "/a/b/c/d",    "a:[b.c.d]"   },
-    { "/a/b/c/d/",   "a:[b.c.d]"   },
-    { "/a/b/c/d/e",  "a:[b.c.d.e]" },
-    { "/a/b/c/d/e/", "a:[b.c.d.e]" },
-    { "a",           "[.a]"        },
-    { "a/",          "[.a]"        },
-    { "a/b",         "[.a.b]"      },
-    { "a/b/",        "[.a.b]"      },
-    { "a/b/c",       "[.a.b.c]"    },
-    { "a/b/c/",      "[.a.b.c]"    },
-    { "a/b/c/d",     "[.a.b.c.d]"  },
-    { "a/b/c/d/",    "[.a.b.c.d]"  },
+    { "",             ""            },
+    { "/",            ""            },
+    { "/a",           "a:[000000]"  },
+    { "/a/",          "a:[000000]"  },
+    { "/a/b",         "a:[b]"       },
+    { "/a/b/",        "a:[b]"       },
+    { "/a/b/c",       "a:[b.c]"     },
+    { "/a/b/c/",      "a:[b.c]"     },
+    { "/a/b/c/d",     "a:[b.c.d]"   },
+    { "/a/b/c/d/",    "a:[b.c.d]"   },
+    { "/a/b/c/d/e",   "a:[b.c.d.e]" },
+    { "/a/b/c/d/e/",  "a:[b.c.d.e]" },
+    { "a",            "[.a]"        },
+    { "a/",           "[.a]"        },
+    { "a/b",          "[.a.b]"      },
+    { "a/b/",         "[.a.b]"      },
+    { "a/b/c",        "[.a.b.c]"    },
+    { "a/b/c/",       "[.a.b.c]"    },
+    { "a/b/c/d",      "[.a.b.c.d]"  },
+    { "a/b/c/d/",     "[.a.b.c.d]"  },
+    // Extra slashes shouldn't matter.
+    { "/////",        ""            },
+    { "//a//b///c//", "a:[b.c]"     },
+    { "a//b///c//",   "[.a.b.c]"    },
   };
   for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               FtpUtil::UnixDirectoryPathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
   }
 }
 
 TEST(FtpUtilTest, VMSPathToUnix) {
   const struct {
@@ skipping 169 matching lines @@
 
     EXPECT_EQ(ASCIIToUTF16(kTestCases[i].expected_result),
               FtpUtil::GetStringPartAfterColumns(
                   ASCIIToUTF16(kTestCases[i].text), kTestCases[i].column));
   }
 }
 
 }  // namespace
 
 }  // namespace net