Remove file_util::kPathSeparator from posix.

base/file_util_unittest.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 129 matching lines @@
     std::wstring result = value.path;
     file_util::AppendToPath(&result, value.ending);
     EXPECT_EQ(value.result, result);
   }
 
 #ifdef NDEBUG
   file_util::AppendToPath(NULL, L"path");  // asserts in debug mode
 #endif
 }
 
+// TODO(port): enable this test for non-Windows.
+#if defined(OS_WIN)
 static const struct InsertBeforeExtensionCase {
   std::wstring path;
   std::wstring suffix;
   std::wstring result;
 } kInsertBeforeExtension[] = {
   {L"", L"", L""},
   {L"", L"txt", L"txt"},
   {L".", L"txt", L"txt."},
   {L".", L"", L"."},
   {L"foo.dll", L"txt", L"footxt.dll"},
@@ skipping 37 matching lines @@
 #endif
 };
 
 TEST_F(FileUtilTest, InsertBeforeExtensionTest) {
   for (unsigned int i = 0; i < arraysize(kInsertBeforeExtension); ++i) {
     std::wstring path(kInsertBeforeExtension[i].path);
     file_util::InsertBeforeExtension(&path, kInsertBeforeExtension[i].suffix);
     EXPECT_EQ(path, kInsertBeforeExtension[i].result);
   }
 }
+#endif  // defined(OS_WIN)
 
 static const struct filename_case {
   const wchar_t* path;
   const wchar_t* filename;
 } filename_cases[] = {
 #if defined(OS_WIN)
   {L"c:\\colon\\backslash", L"backslash"},
   {L"c:\\colon\\backslash\\", L""},
   {L"\\\\filename.exe", L"filename.exe"},
   {L"filename.exe", L"filename.exe"},
@@ skipping 561 matching lines @@
 };
 
 TEST_F(FileUtilTest, ReplaceIllegalCharactersTest) {
   for (unsigned int i = 0; i < arraysize(kIllegalCharacterCases); ++i) {
     std::wstring bad_name(kIllegalCharacterCases[i].bad_name);
     file_util::ReplaceIllegalCharacters(&bad_name, L'-');
     EXPECT_EQ(kIllegalCharacterCases[i].good_name, bad_name);
   }
 }
 
+// TODO(port): enable this test for non-windows.
+#if defined(OS_WIN)
 static const struct ReplaceExtensionCase {
   std::wstring file_name;
   std::wstring extension;
   std::wstring result;
 } kReplaceExtension[] = {
   {L"", L"", L""},
   {L"", L"txt", L".txt"},
   {L".", L"txt", L".txt"},
   {L".", L"", L""},
   {L"foo.dll", L"txt", L"foo.txt"},
@@ skipping 22 matching lines @@
 // the directory names of the path.
 TEST_F(FileUtilTest, ReplaceExtensionTestWithPathSeparators) {
   std::wstring path;
   file_util::AppendToPath(&path, L"foo.bar");
   file_util::AppendToPath(&path, L"foo");
   // '/foo.bar/foo' with extension '.baz'
   std::wstring result_path = path;
   file_util::ReplaceExtension(&result_path, L".baz");
   EXPECT_EQ(path + L".baz", result_path);
 }
+#endif  // defined(OS_WIN)
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
   file_util::FileEnumerator f0(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   EXPECT_EQ(f0.Next(), L"");
   EXPECT_EQ(f0.Next(), L"");
 
   // create the directories
   FilePath dir1 = test_dir_.Append(FILE_PATH_LITERAL("dir1"));
@@ skipping 78 matching lines @@
   EXPECT_EQ(c5.size(), 5);
 
   // Make sure the destructor closes the find handle while in the middle of a
   // query to allow TearDown to delete the directory.
   file_util::FileEnumerator f6(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   EXPECT_FALSE(f6.Next().empty());  // Should have found something
                                     // (we don't care what).
 }
 
+
+void PathComponents(const std::wstring& path,
+                    std::vector<std::wstring>* components) {
+  DCHECK(components != NULL);
+  if (components == NULL)
+    return;
+  std::wstring::size_type start = 0;
+  std::wstring::size_type end = path.find('/', start);
+
+  // Special case the "/" or "\" directory.  On Windows with a drive letter,
+  // this code path won't hit, but the right thing should still happen.
+  // "E:\foo" will turn into "E:","foo".
+  if (end == start) {
+    components->push_back(std::wstring(path, 0, 1));
+    start = end + 1;
+    end = path.find('/', start);
+  }
+  while (end != std::wstring::npos) {
+    std::wstring component = std::wstring(path, start, end - start);
+    components->push_back(component);
+    start = end + 1;
+    end = path.find('/', start);
+  }
+  std::wstring component = std::wstring(path, start);
+  components->push_back(component);
+}
+
+static const struct PathComponentsCase {
+  std::wstring path;
+  FilePath::StringType result;
+} kPathComponents[] = {
+  {L"/foo/bar/baz/", FILE_PATH_LITERAL("/|foo|bar|baz|")},
+  {L"/foo/bar/baz", FILE_PATH_LITERAL("/|foo|bar|baz")},
+  {L"e:/foo", FILE_PATH_LITERAL("e:|foo")},
+};
+
+TEST_F(FileUtilTest, PathComponentsTest) {
+  for (size_t i = 0; i < arraysize(kPathComponents); ++i) {
+    FilePath path = FilePath::FromWStringHack(kPathComponents[i].path);
+    std::vector<FilePath::StringType> comps;
+    file_util::PathComponents(path, &comps);
+
+    FilePath::StringType result;
+    for (size_t j = 0; j < comps.size(); ++j) {
+      result.append(comps[j]);
+      if (j < comps.size() - 1)
+        result.append(FILE_PATH_LITERAL("|"), 1);
+    }
+    EXPECT_EQ(kPathComponents[i].result, result);
+  }
+}
+
 }  // namespace