faster_path 0.3.10 → 0.4.0

data/src/cleanpath_conservative.rs

@@ -1,96 +1,192 @@
 use std::borrow::Cow;
-use std::path::MAIN_SEPARATOR;
-use prepend_prefix::prepend_prefix;
-use basename::basename;
-use dirname::dirname;
-use chop_basename::chop_basename;
-use path_parsing::{SEP_STR, contains_sep};
-
-pub fn cleanpath_conservative(path: &str) -> Cow<str> {
-  let mut names: Vec<&str> = vec![];
+
+use crate::basename::basename;
+use crate::chop_basename::chop_basename;
+use crate::cleanpath_aggressive::with_separators;
+use crate::dirname::dirname;
+use crate::path_parsing::{Rules, SEP_BYTES};
+use crate::prepend_prefix::prepend_prefix;
+
+// Pathname's `cleanpath_conservative`
+pub fn cleanpath_conservative(rules: Rules, path: &[u8]) -> Cow<'_, [u8]> {
+  let mut names: Vec<&[u8]> = vec![];
   let mut prefix = path;
-  while let Some((ref p, ref base)) = chop_basename(&prefix) {
+  while let Some((p, base)) = chop_basename(rules, prefix) {
     prefix = p;
-    if base != &"." {
+    if base != b"." {
       names.push(base);
     }
   }
-  // // Windows Feature
-  //
-  // ```ruby
-  // pre.tr!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
-  // ```
-  //
-  if contains_sep(basename(&prefix, "").as_bytes()) {
-    let len = names.iter().rposition(|&c| c != "..").map_or(0, |pos| pos + 1);
+  let prefix = with_separators(rules, prefix);
+  if rules.contains_sep(basename(rules, &prefix, b"")) {
+    let len = names.iter().rposition(|&c| c != b"..").map_or(0, |pos| pos + 1);
     names.truncate(len);
   }
 
-  let last_name = match names.first() {
-    Some(&name) => name,
-    None => return dirname(&prefix).into(),
-  };
+  if names.is_empty() {
+    return Cow::Owned(dirname(rules, &prefix).into_owned());
+  }
+  names.reverse();
+  if names.last() != Some(&&b".."[..]) && basename(rules, path, b"") == b"." {
+    names.push(b".");
+  }
+  let result = prepend_prefix(rules, &prefix, &names.join(SEP_BYTES)).into_owned();
+  match names.last() {
+    Some(&b".") | Some(&b"..") => Cow::Owned(result),
+    _ if has_trailing_separator(rules, path) => Cow::Owned(add_trailing_separator(rules, Cow::Owned(result)).into_owned()),
+    _ => Cow::Owned(result),
+  }
+}
 
-  if last_name != ".." && basename(&path, "") == "." {
-    names.reverse();
-    names.push(".");
-  } else if last_name != "." && last_name != ".." &&
-      chop_basename(path).map(|(a, b)| a.len() + b.len()).unwrap() < path.len() {
-    return format!("{}{}", last_name, MAIN_SEPARATOR).into();
+// Pathname's `has_trailing_separator?`
+pub fn has_trailing_separator(rules: Rules, path: &[u8]) -> bool {
+  match chop_basename(rules, path) {
+    Some((dirname, basename)) => dirname.len() + basename.len() < path.len(),
+    None => false,
+  }
+}
+
+// Pathname's `add_trailing_separator`:
+// `File.basename(path + 'a') == 'a' ? path : File.join(path, '')`
+pub fn add_trailing_separator(rules: Rules, path: Cow<'_, [u8]>) -> Cow<'_, [u8]> {
+  let ends_a_path = if rules.is_dosish() {
+    basename(rules, &[&path[..], b"a"].concat(), b"") == b"a"
+  } else {
+    path.last().map_or(true, |&c| rules.is_sep(c))
+  };
+  if ends_a_path {
+    path
   } else {
-    names.reverse();
+    Cow::Owned(rules.join(&path, b""))
+  }
+}
+
+// Pathname's `del_trailing_separator`
+pub fn del_trailing_separator(rules: Rules, path: &[u8]) -> Cow<'_, [u8]> {
+  if let Some((dirname, basename)) = chop_basename(rules, path) {
+    // The basename follows the dirname
+    return Cow::Borrowed(&path[..dirname.len() + basename.len()]);
+  }
+  match rules.last_non_sep_pos(path) {
+    // No trailing separators
+    _ if path.last().map_or(true, |&c| !rules.is_sep(c)) => Cow::Borrowed(path),
+    // `$` + File.dirname(path)[/#{SEPARATOR_PAT}*\z/]`
+    last => {
+      let before = last.map_or(0, |pos| pos + 1);
+      let dir = dirname(rules, path);
+      let separators = dir.len() - dir.iter().rev().take_while(|&&c| rules.is_sep(c)).count();
+      Cow::Owned([&path[..before], &dir[separators..]].concat())
+    }
   }
-  prepend_prefix(&prefix, &names.join(&SEP_STR))
+}
+
+#[cfg(test)]
+fn cleanpath_conservative_str(path: &str) -> String {
+  String::from_utf8(cleanpath_conservative(Rules::UNIX, path.as_bytes()).into_owned()).unwrap()
+}
+
+#[cfg(test)]
+fn windows_cleanpath_conservative(path: &str) -> String {
+  String::from_utf8(cleanpath_conservative(Rules::WINDOWS, path.as_bytes()).into_owned()).unwrap()
+}
+
+#[cfg(test)]
+fn del_str(rules: Rules, path: &str) -> String {
+  String::from_utf8(del_trailing_separator(rules, path.as_bytes()).into_owned()).unwrap()
+}
+
+#[test]
+fn it_keeps_the_whole_path_with_a_trailing_separator() {
+  assert_eq!(cleanpath_conservative_str("a/b/"),     "a/b/");
+  assert_eq!(cleanpath_conservative_str("/a/b//"),   "/a/b/");
+  assert_eq!(cleanpath_conservative_str("a/./b/"),   "a/b/");
+  assert_eq!(cleanpath_conservative_str("a/b/../"),  "a/b/..");
+}
+
+#[test]
+fn it_adds_trailing_separators() {
+  assert_eq!(add_trailing_separator(Rules::UNIX, Cow::Borrowed(&b""[..])), &b""[..]);
+  assert_eq!(add_trailing_separator(Rules::UNIX, Cow::Borrowed(&b"/"[..])), &b"/"[..]);
+  assert_eq!(add_trailing_separator(Rules::UNIX, Cow::Borrowed(&b"a"[..])), &b"a/"[..]);
+  assert_eq!(add_trailing_separator(Rules::UNIX, Cow::Borrowed(&b"a/"[..])), &b"a/"[..]);
+}
+
+#[test]
+fn it_detects_trailing_separators() {
+  assert!(!has_trailing_separator(Rules::UNIX, b""));
+  assert!(!has_trailing_separator(Rules::UNIX, b"/"));
+  assert!(!has_trailing_separator(Rules::UNIX, b"a"));
+  assert!(has_trailing_separator(Rules::UNIX, b"a/"));
+  assert!(has_trailing_separator(Rules::UNIX, b"/a//"));
 }
 
 #[test]
 fn it_conservatively_cleans_the_path() {
-  assert_eq!(cleanpath_conservative("/"),      "/");
-  assert_eq!(cleanpath_conservative(""),      ".");
-  assert_eq!(cleanpath_conservative("."),      ".");
-  assert_eq!(cleanpath_conservative(".."),     "..");
-  assert_eq!(cleanpath_conservative("a"),      "a");
-  assert_eq!(cleanpath_conservative("/."),      "/");
-  assert_eq!(cleanpath_conservative("/.."),      "/");
-  assert_eq!(cleanpath_conservative("/a"),     "/a");
-  assert_eq!(cleanpath_conservative("./"),      ".");
-  assert_eq!(cleanpath_conservative("../"),     "..");
-  assert_eq!(cleanpath_conservative("a/"),     "a/");
-  assert_eq!(cleanpath_conservative("a//b"),    "a/b");
-  assert_eq!(cleanpath_conservative("a/."),    "a/.");
-  assert_eq!(cleanpath_conservative("a/./"),    "a/.");
-  assert_eq!(cleanpath_conservative("a/../"),   "a/..");
-  assert_eq!(cleanpath_conservative("/a/."),   "/a/.");
-  assert_eq!(cleanpath_conservative("./.."),     "..");
-  assert_eq!(cleanpath_conservative("../."),     "..");
-  assert_eq!(cleanpath_conservative("./../"),     "..");
-  assert_eq!(cleanpath_conservative(".././"),     "..");
-  assert_eq!(cleanpath_conservative("/./.."),      "/");
-  assert_eq!(cleanpath_conservative("/../."),      "/");
-  assert_eq!(cleanpath_conservative("/./../"),      "/");
-  assert_eq!(cleanpath_conservative("/.././"),      "/");
-  assert_eq!(cleanpath_conservative("a/b/c"),  "a/b/c");
-  assert_eq!(cleanpath_conservative("./b/c"),    "b/c");
-  assert_eq!(cleanpath_conservative("a/./c"),    "a/c");
-  assert_eq!(cleanpath_conservative("a/b/."),  "a/b/.");
-  assert_eq!(cleanpath_conservative("a/../."),   "a/..");
-  assert_eq!(cleanpath_conservative("/../.././../a"),     "/a");
-  assert_eq!(cleanpath_conservative("a/b/../../../../c/../d"), "a/b/../../../../c/../d");
-
-// Future Windows Support
-//
-// DOSISH = File::ALT_SEPARATOR != nil
-// DOSISH_DRIVE_LETTER = File.dirname("A:") == "A:."
-// DOSISH_UNC = File.dirname("//") == "//"
-//
-//
-//   if DOSISH
-//     assert_eq!(cleanpath_conservative, 'c:/foo/bar', 'c:\\foo\\bar')
-//   end
-//
-//   if DOSISH_UNC
-//     assert_eq!(cleanpath_conservative, '//',     '//')
-//   else
-//     assert_eq!(cleanpath_conservative, '/',      '//')
-//   end
+  assert_eq!(cleanpath_conservative_str("/"),      "/");
+  assert_eq!(cleanpath_conservative_str(""),      ".");
+  assert_eq!(cleanpath_conservative_str("."),      ".");
+  assert_eq!(cleanpath_conservative_str(".."),     "..");
+  assert_eq!(cleanpath_conservative_str("a"),      "a");
+  assert_eq!(cleanpath_conservative_str("/."),      "/");
+  assert_eq!(cleanpath_conservative_str("/.."),      "/");
+  assert_eq!(cleanpath_conservative_str("/a"),     "/a");
+  assert_eq!(cleanpath_conservative_str("./"),      ".");
+  assert_eq!(cleanpath_conservative_str("../"),     "..");
+  assert_eq!(cleanpath_conservative_str("a/"),     "a/");
+  assert_eq!(cleanpath_conservative_str("a//b"),    "a/b");
+  assert_eq!(cleanpath_conservative_str("a/."),    "a/.");
+  assert_eq!(cleanpath_conservative_str("a/./"),    "a/.");
+  assert_eq!(cleanpath_conservative_str("a/../"),   "a/..");
+  assert_eq!(cleanpath_conservative_str("/a/."),   "/a/.");
+  assert_eq!(cleanpath_conservative_str("./.."),     "..");
+  assert_eq!(cleanpath_conservative_str("../."),     "..");
+  assert_eq!(cleanpath_conservative_str("./../"),     "..");
+  assert_eq!(cleanpath_conservative_str(".././"),     "..");
+  assert_eq!(cleanpath_conservative_str("/./.."),      "/");
+  assert_eq!(cleanpath_conservative_str("/../."),      "/");
+  assert_eq!(cleanpath_conservative_str("/./../"),      "/");
+  assert_eq!(cleanpath_conservative_str("/.././"),      "/");
+  assert_eq!(cleanpath_conservative_str("a/b/c"),  "a/b/c");
+  assert_eq!(cleanpath_conservative_str("./b/c"),    "b/c");
+  assert_eq!(cleanpath_conservative_str("a/./c"),    "a/c");
+  assert_eq!(cleanpath_conservative_str("a/b/."),  "a/b/.");
+  assert_eq!(cleanpath_conservative_str("a/../."),   "a/..");
+  assert_eq!(cleanpath_conservative_str("/../.././../a"),     "/a");
+  assert_eq!(cleanpath_conservative_str("a/b/../../../../c/../d"), "a/b/../../../../c/../d");
+
+  assert_eq!(cleanpath_conservative_str("//"), "/");
+}
+
+#[test]
+fn it_conservatively_cleans_windows_paths() {
+  assert_eq!(windows_cleanpath_conservative("c:\\foo\\bar"), "c:/foo/bar");
+  assert_eq!(windows_cleanpath_conservative("//"), "//");
+  assert_eq!(windows_cleanpath_conservative("a\\b\\"), "a/b/");
+  assert_eq!(windows_cleanpath_conservative("C:/a/../b/"), "C:/a/../b/");
+}
+
+#[test]
+fn it_adds_trailing_separators_on_windows() {
+  let add = |path: &'static str| add_trailing_separator(Rules::WINDOWS, Cow::Borrowed(path.as_bytes())).into_owned();
+  assert_eq!(add("a"), b"a/");
+  assert_eq!(add("a\\"), b"a\\");
+  assert_eq!(add("C:"), b"C:");
+  assert_eq!(add("C:/"), b"C:/");
+  assert_eq!(add("//a/b"), b"//a/b/");
+  assert!(has_trailing_separator(Rules::WINDOWS, b"a\\"));
+  assert!(!has_trailing_separator(Rules::UNIX, b"a\\"));
+}
+
+#[test]
+fn it_deletes_trailing_separators() {
+  for &(path, expected) in &[("", ""), ("/", "/"), ("/a", "/a"), ("/a/", "/a"), ("/a//", "/a"),
+                             (".", "."), ("./", "."), (".//", "."), ("///", "/"), ("///a/", "///a")] {
+    assert_eq!(del_str(Rules::UNIX, path), expected, "{:?}", path);
+  }
+  for &(path, expected) in &[("A:", "A:"), ("A:/", "A:/"), ("A://", "A:/"), ("A:.", "A:."), ("A:./", "A:."),
+                             ("A:.//", "A:."), ("//", "//"), ("//a", "//a"), ("//a/", "//a"), ("//a//", "//a"),
+                             ("//a/b", "//a/b"), ("//a/b/", "//a/b"), ("//a/b//", "//a/b"), ("//a/b/c", "//a/b/c"),
+                             ("//a/b/c/", "//a/b/c"), ("//a/b/c//", "//a/b/c"), ("a\\", "a")] {
+    assert_eq!(del_str(Rules::WINDOWS, path), expected, "{:?}", path);
+  }
 }

data/src/dirname.rs

@@ -1,66 +1,130 @@
-use std::str;
-use path_parsing::{find_last_sep_pos, find_last_non_sep_pos};
-
-pub fn dirname(path: &str) -> &str {
-  let bytes = path.as_bytes();
-  let mut last_slash_pos = match find_last_sep_pos(bytes) {
-    Some(pos) => pos,
-    _ => return ".",
-  };
-  // Skip trailing slashes.
-  if last_slash_pos == bytes.len() - 1 {
-    let last_non_slash_pos = match find_last_non_sep_pos(&bytes[..last_slash_pos]) {
-      Some(pos) => pos,
-      _ => return "/"
-    };
-    last_slash_pos = match find_last_sep_pos(&bytes[..last_non_slash_pos]) {
-      Some(pos) => pos,
-      _ => return "."
-    };
-  };
-  if let Some(end) = find_last_non_sep_pos(&bytes[..last_slash_pos]) {
-    &path[..end + 1]
-  } else {
-    "/"
+use std::borrow::Cow;
+
+use crate::path_parsing::Rules;
+
+// Ruby's `File.dirname`
+pub fn dirname(rules: Rules, path: &[u8]) -> Cow<'_, [u8]> {
+  let mut name = 0;
+  let mut root = rules.skip_root(path);
+  if rules.is_dosish() {
+    // Keep a UNC prefix
+    if root > 1 && rules.is_sep(path[0]) {
+      name = root - 2;
+      root = name + rules.skip_prefix(&path[name..]);
+    }
+  } else if root > 1 {
+    // Leading separators become one
+    name = root - 1;
+  }
+  let end = rules.last_separator(&path[root..]).map_or(root, |pos| root + pos);
+  if end == name {
+    return Cow::Borrowed(b".");
   }
+  let path = &path[name..];
+  let end = end - name;
+  let root = root - name;
+  if rules.has_drive_letter(path) {
+    if path.len() > 2 && rules.is_sep(path[2]) {
+      // "C:" and one separator, then the rest
+      let top = 2 + rules.skip_root(&path[2..]);
+      return Cow::Owned([&path[..3], &path[top..end.max(top)]].concat());
+    }
+    if root == 2 && end == 2 {
+      return Cow::Owned([&path[..2], b"."].concat());
+    }
+  }
+  Cow::Borrowed(&path[..end])
+}
+
+#[cfg(test)]
+fn dirname_str(path: &str) -> String {
+  String::from_utf8(dirname(Rules::UNIX, path.as_bytes()).into_owned()).unwrap()
+}
+
+#[cfg(test)]
+fn windows_dirname(path: &str) -> String {
+  String::from_utf8(dirname(Rules::WINDOWS, path.as_bytes()).into_owned()).unwrap()
 }
 
 #[test]
 fn absolute() {
-  assert_eq!(dirname("/a/b///c"), "/a/b");
+  assert_eq!(dirname_str("/a/b///c"), "/a/b");
 }
 
 #[test]
 fn trailing_slashes_absolute() {
-  assert_eq!(dirname("/a/b///c//////"), "/a/b");
+  assert_eq!(dirname_str("/a/b///c//////"), "/a/b");
 }
 
 #[test]
 fn relative() {
-  assert_eq!(dirname("b///c"), "b");
+  assert_eq!(dirname_str("b///c"), "b");
 }
 
 #[test]
 fn trailing_slashes_relative() {
-  assert_eq!(dirname("b/c//"), "b");
+  assert_eq!(dirname_str("b/c//"), "b");
 }
 
 #[test]
 fn root() {
-  assert_eq!(dirname("//c"), "/");
+  assert_eq!(dirname_str("//c"), "/");
 }
 
 #[test]
 fn trailing_slashes_root() {
-  assert_eq!(dirname("//c//"), "/");
+  assert_eq!(dirname_str("//c//"), "/");
 }
 
 #[test]
 fn trailing_slashes_relative_root() {
-  assert_eq!(dirname("c//"), ".");
+  assert_eq!(dirname_str("c//"), ".");
 }
 
 #[test]
 fn returns_dot_for_empty_string() {
-  assert_eq!(dirname(""), ".");
+  assert_eq!(dirname_str(""), ".");
+}
+
+#[test]
+fn only_separators() {
+  assert_eq!(dirname_str("/"), "/");
+  assert_eq!(dirname_str("///"), "/");
+}
+
+#[test]
+fn non_utf8() {
+  assert_eq!(dirname(Rules::UNIX, b"\xff\xfe/a").as_ref(), b"\xff\xfe");
+}
+
+#[test]
+fn windows_separators() {
+  assert_eq!(windows_dirname("a\\b"), "a");
+  assert_eq!(windows_dirname("a\\b\\"), "a");
+  assert_eq!(windows_dirname("a/b\\c"), "a/b");
+  assert_eq!(dirname_str("a\\b"), ".");
+}
+
+#[test]
+fn windows_drive_letters() {
+  assert_eq!(windows_dirname("C:"), "C:.");
+  assert_eq!(windows_dirname("C:a"), "C:.");
+  assert_eq!(windows_dirname("C:/"), "C:/");
+  assert_eq!(windows_dirname("C:/a"), "C:/");
+  assert_eq!(windows_dirname("C://a"), "C:/");
+  assert_eq!(windows_dirname("C:/a/b"), "C:/a");
+  assert_eq!(windows_dirname("C://a//b"), "C:/a");
+  assert_eq!(windows_dirname("C:a/b"), "C:a");
+  assert_eq!(dirname_str("C:"), ".");
+}
+
+#[test]
+fn windows_unc() {
+  assert_eq!(windows_dirname("//"), "//");
+  assert_eq!(windows_dirname("//a"), "//a");
+  assert_eq!(windows_dirname("//a/b"), "//a/b");
+  assert_eq!(windows_dirname("//a/b/c"), "//a/b");
+  assert_eq!(windows_dirname("//a/b/c/d"), "//a/b/c");
+  assert_eq!(windows_dirname("///a"), "//a");
+  assert_eq!(dirname_str("//a/b"), "/a");
 }

data/src/extname.rs

@@ -1,25 +1,155 @@
-use std::str;
-use path_parsing::{SEP, find_last_non_sep_pos};
+use std::sync::atomic::{AtomicBool, Ordering};
 
-pub fn extname(path: &str) -> &str {
-  let end = match find_last_non_sep_pos(path.as_bytes()) {
-    Some(pos) => pos + 1,
-    _ => return "",
-  };
-  let bytes = &path.as_bytes()[..end];
-  for (pos, c) in bytes.iter().enumerate().rev() {
-    match *c {
-      b'.' => {
-        let prev = bytes.get(pos - 1);
-        if pos == end - 1 || prev == None || prev == Some(&SEP) {
-          return "";
-        } else {
-          return &path[pos..end]
-        };
+use crate::path_parsing::Rules;
+
+// Ruby 2.7 changed `File.extname` to return an extension of only a dot
+// (`"foo."` on Unix, `"foo./"` on both Unix and Windows, where trailing dots
+// aren't part of a file name) instead of `""`. `FasterPath` follows the Ruby
+// it is loaded into; see `Init_faster_pathname`.
+static TRAILING_DOT_IS_EXTNAME: AtomicBool = AtomicBool::new(false);
+
+pub fn set_trailing_dot_is_extname(value: bool) {
+  TRAILING_DOT_IS_EXTNAME.store(value, Ordering::Relaxed);
+}
+
+// Ruby's `File.extname`
+pub fn extname(rules: Rules, path: &[u8]) -> &[u8] {
+  extname_with(rules, path, TRAILING_DOT_IS_EXTNAME.load(Ordering::Relaxed))
+}
+
+// Ruby's `ruby_enc_find_extname`
+fn extname_with(rules: Rules, path: &[u8], trailing_dot_is_extname: bool) -> &[u8] {
+  let end = path.len();
+  // The last component
+  let mut p = match rules.last_separator(path) {
+    Some(pos) => {
+      let mut p = pos;
+      while p < end && rules.is_sep(path[p]) {
+        p += 1;
       }
-      SEP => return "",
-      _ => {}
+      p
     }
+    None => 0,
   };
-  ""
+  let name = p;
+
+  // Leading dots don't start an extension
+  while p < end && path[p] == b'.' {
+    p += 1;
+  }
+  let mut dot = None;
+  while p < end {
+    let c = path[p];
+    if c == b'.' || (rules.is_dosish() && c == b' ') {
+      if !rules.is_dosish() {
+        dot = Some(p);
+      } else {
+        // NTFS ignores trailing dots and spaces
+        let last = p;
+        let mut last_dot = last;
+        p += 1;
+        while p < end && (path[p] == b'.' || path[p] == b' ') {
+          if path[p] == b'.' {
+            last_dot = p;
+          }
+          p += 1;
+        }
+        if p >= end || rules.is_ads(path[p]) {
+          p = last;
+          break;
+        }
+        if c == b'.' || last_dot > last {
+          dot = Some(last_dot);
+        }
+        continue;
+      }
+    } else if rules.is_ads(c) || rules.is_sep(c) {
+      break;
+    }
+    p += 1;
+  }
+  match dot {
+    Some(dot) if dot != name && dot + 1 == p => if trailing_dot_is_extname { &path[dot..p] } else { b"" },
+    Some(dot) if dot != name => &path[dot..p],
+    _ => b"",
+  }
+}
+
+#[cfg(test)]
+fn extname_str(path: &str, trailing_dot_is_extname: bool) -> &str {
+  std::str::from_utf8(extname_with(Rules::UNIX, path.as_bytes(), trailing_dot_is_extname)).unwrap()
+}
+
+#[cfg(test)]
+fn windows_extname(path: &str) -> &str {
+  std::str::from_utf8(extname_with(Rules::WINDOWS, path.as_bytes(), true)).unwrap()
+}
+
+#[test]
+fn it_finds_the_extension() {
+  for &trailing_dot in &[false, true] {
+    assert_eq!(extname_str("", trailing_dot), "");
+    assert_eq!(extname_str("/", trailing_dot), "");
+    assert_eq!(extname_str("a.rb", trailing_dot), ".rb");
+    assert_eq!(extname_str("a.rb/", trailing_dot), ".rb");
+    assert_eq!(extname_str("a.rb//", trailing_dot), ".rb");
+    assert_eq!(extname_str("a/b.c.d", trailing_dot), ".d");
+    assert_eq!(extname_str("a..b", trailing_dot), ".b");
+    assert_eq!(extname_str(".a.b", trailing_dot), ".b");
+    assert_eq!(extname_str("a/.rb", trailing_dot), "");
+    assert_eq!(extname_str("a.b/c", trailing_dot), "");
+    assert_eq!(extname_str(".bashrc", trailing_dot), "");
+    assert_eq!(extname_str("..foo", trailing_dot), "");
+    assert_eq!(extname_str("a/..b", trailing_dot), "");
+    assert_eq!(extname_str("...a", trailing_dot), "");
+    assert_eq!(extname_str("a.rb ", trailing_dot), ".rb ");
+    assert_eq!(extname_str("a\\b.c", trailing_dot), ".c");
+  }
+}
+
+#[test]
+fn only_dots() {
+  for &trailing_dot in &[false, true] {
+    assert_eq!(extname_str(".", trailing_dot), "");
+    assert_eq!(extname_str("..", trailing_dot), "");
+    assert_eq!(extname_str("....", trailing_dot), "");
+    assert_eq!(extname_str("/.", trailing_dot), "");
+    assert_eq!(extname_str(".a/", trailing_dot), "");
+  }
+}
+
+#[test]
+fn trailing_dot() {
+  assert_eq!(extname_str("foo.", false), "");
+  assert_eq!(extname_str(".foo.", false), "");
+  assert_eq!(extname_str("foo..", false), "");
+  assert_eq!(extname_str("a./", false), "");
+  assert_eq!(extname_str("foo.", true), ".");
+  assert_eq!(extname_str(".foo.", true), ".");
+  assert_eq!(extname_str("foo..", true), ".");
+  assert_eq!(extname_str("a./", true), ".");
+}
+
+#[test]
+fn non_utf8() {
+  assert_eq!(extname_with(Rules::UNIX, b"\xff.\xfe", false), b".\xfe");
+}
+
+#[test]
+fn windows() {
+  assert_eq!(windows_extname("a.rb"), ".rb");
+  assert_eq!(windows_extname("a.b\\c"), "");
+  assert_eq!(windows_extname("a\\b.c"), ".c");
+  assert_eq!(windows_extname("a.rb\\"), ".rb");
+  assert_eq!(windows_extname("foo."), "");
+  assert_eq!(windows_extname("foo.rb."), ".rb");
+  assert_eq!(windows_extname("foo.rb "), ".rb");
+  assert_eq!(windows_extname("foo.rb. ."), ".rb");
+  assert_eq!(windows_extname("foo.rb::$DATA"), ".rb");
+  assert_eq!(windows_extname("foo.rb::$DATA.bar"), ".rb");
+  assert_eq!(windows_extname("foo .ext"), ".ext");
+  assert_eq!(windows_extname("foo. .ext"), ".ext");
+  assert_eq!(windows_extname("foo.ext .ext"), ".ext");
+  assert_eq!(windows_extname("foo .ext "), ".ext");
+  assert_eq!(windows_extname(".bashrc"), "");
 }